Merge branch 'master' of https://github.com/fsprojects/LocSta

# Conflicts:
#	src/LocSta2/Core.fs

Author: SchlenkR

package-lock.json

@@ -4,8 +4,9 @@ open LocSta.Core
 
 /// Linearly maps the input from [inMin, inMax] to [outMin, outMax].
 let rescale (inMin: float) inMax outMin outMax =
+    let invRange = 1.0 / (inMax - inMin)
+    let outRange = outMax - outMin
     stream {
         let! ctx = getCtx()
-        let normalized = (ctx - inMin) / (inMax - inMin)
-        return outMin + normalized * (outMax - outMin)
+        return outMin + (ctx - inMin) * invRange * outRange
     }

src/LocSta2/Arithmetic/Rescale.fs

@@ -25,21 +25,29 @@ type SigStreamBuilder() =
                 | ValueNone -> StateController(ValueNone), StateController(ValueNone)
                 | ValueSome (ms,fs) -> ms, fs
             let mvs,ms = m ms ctx
-            let results = ResizeArray()
-            let mutable currentFs = fs
-            for mv in mvs do
-                let fStream = f mv
-                let fvs, newFs = fStream currentFs ctx
-                for fv in fvs do results.Add(fv)
-                currentFs <- newFs
-            do s.Set(ms, currentFs)
-            results :> seq<_>, s
+            // Fast path: most streams emit exactly one value via [| x |], so skip ResizeArray
+            match mvs with
+            | :? ('a array) as arr when arr.Length = 1 ->
+                let fStream = f arr[0]
+                let fvs, newFs = fStream fs ctx
+                do s.Set(ms, newFs)
+                fvs, s
+            | _ ->
+                let results = ResizeArray()
+                let mutable currentFs = fs
+                for mv in mvs do
+                    let fStream = f mv
+                    let fvs, newFs = fStream currentFs ctx
+                    for fv in fvs do results.Add(fv)
+                    currentFs <- newFs
+                do s.Set(ms, currentFs)
+                results :> seq<_>, s
 
     member inline _.Return(x) : SigStream<_,_,unit> =
-        fun s _ -> Seq.singleton x, s
+        fun s _ -> [| x |] :> seq<_>, s
 
     member inline _.Yield(x) : SigStream<_,_,unit> =
-        fun s _ -> Seq.singleton x, s
+        fun s _ -> [| x |] :> seq<_>, s
 
     member inline _.ReturnFrom(v) = v
 
@@ -71,7 +79,8 @@ let ofSeq (sequence: seq<_>) : SigStream<_,_,_> =
             | ValueSome e -> e
         match enumerator.MoveNext() with
         | true ->
-            Seq.singleton enumerator.Current, s
+            s.Set(enumerator)
+            [| enumerator.Current |] :> seq<_>, s
         | false ->
             // failwith "Sequence contains no more elements"
             Seq.empty, s
@@ -85,12 +94,12 @@ let inline map ([<InlineIfLambda>] proj) ([<InlineIfLambda>] s1) =
 
 /// Get the context value
 let inline getCtx<'c> () : SigStream<'c,'c,unit> =
-    fun s ctx -> Seq.singleton ctx, s
+    fun s ctx -> [| ctx |] :> seq<_>, s
 
 /// Get the state controller of this block
 let inline getState<'c,'s> () : SigStream<StateController<'s>,'c,'s> =
     fun state ctx ->
-        Seq.singleton state, state
+        [| state |] :> seq<_>, state
 
 /// Use a memoized value (lazy initialization)
 let inline useMemoWith ([<InlineIfLambda>] initializer) : SigStream<'a,'c,'a> =
@@ -100,7 +109,7 @@ let inline useMemoWith ([<InlineIfLambda>] initializer) : SigStream<'a,'c,'a> =
             | ValueNone -> initializer()
             | ValueSome v -> v
         state.Set(value)
-        Seq.singleton value, state
+        [| value |] :> seq<_>, state
 
 let useMemo (value: 'a) : SigStream<'a,'c,'a> =
     fun (state: StateController<'a>) ctx ->
@@ -109,7 +118,7 @@ let useMemo (value: 'a) : SigStream<'a,'c,'a> =
             | ValueNone -> value
             | ValueSome v -> v
         state.Set(v)
-        Seq.singleton v, state
+        [| v |] :> seq<_>, state
 
 /// Mutable value for local state within streams
 type MutableValue<'s>(initValue: 's) =
@@ -159,14 +168,23 @@ module Eval =
         toSeqWith 1000 getCtx stream
 
     /// Evaluate n samples
-    let inline run n getCtx stream =
-        toSeq getCtx stream |> Seq.take n |> Seq.toList
+    let inline run (n: int) getCtx stream =
+        let state = StateController(ValueNone)
+        let results = ResizeArray<_>(n)
+        let mutable i = 0
+        while results.Count < n do
+            let ctx = getCtx i
+            i <- i + 1
+            let vs, _ = stream state ctx
+            for v in vs do
+                if results.Count < n then results.Add(v)
+        Seq.toList results
 
     /// Evaluate with input sequence
     let inline runWith (inputs: seq<_>) stream =
         let state = StateController(ValueNone)
-        inputs
-        |> Seq.collect (fun ctx ->
+        let results = ResizeArray<_>()
+        for ctx in inputs do
             let vs, _ = stream state ctx
-            vs)
-        |> Seq.toList
+            for v in vs do results.Add(v)
+        Seq.toList results

src/LocSta2/Core.fs

@@ -6,8 +6,17 @@ open LocSta.Core
 let countIn windowSize =
     stream {
         let! ctx = getCtx()
-        let! window = useState []
-        let newWindow = (ctx :: window.Value) |> List.truncate windowSize
-        window.Value <- newWindow
-        return newWindow |> List.filter id |> List.length
+        let! state = useStateWith (fun () ->
+            let arr = Array.create windowSize false
+            MutableValue(arr, 0, 0, 0))
+        let (arr, idx, count, trueCount) = state.Value.Value
+        let newCount = min (count + 1) windowSize
+        // Subtract old value being overwritten (only if buffer is full)
+        let removed = if count >= windowSize && arr[idx] then 1 else 0
+        let added = if ctx then 1 else 0
+        let newTrueCount = trueCount - removed + added
+        arr[idx] <- ctx
+        let nextIdx = (idx + 1) % windowSize
+        state.Value.Value <- (arr, nextIdx, newCount, newTrueCount)
+        return newTrueCount
     }

src/LocSta2/Counting/CountIn.fs

@@ -6,9 +6,17 @@ open LocSta.Core
 let rate windowSize =
     stream {
         let! ctx = getCtx()
-        let! window = useState []
-        let newWindow = (ctx :: window.Value) |> List.truncate windowSize
-        window.Value <- newWindow
-        let count = newWindow |> List.filter id |> List.length
-        return float count / float newWindow.Length
+        let! state = useStateWith (fun () ->
+            let arr = Array.create windowSize false
+            MutableValue(arr, 0, 0, 0))
+        let (arr, idx, count, trueCount) = state.Value.Value
+        let newCount = min (count + 1) windowSize
+        // Subtract old value being overwritten (only if buffer is full)
+        let removed = if count >= windowSize && arr[idx] then 1 else 0
+        let added = if ctx then 1 else 0
+        let newTrueCount = trueCount - removed + added
+        arr[idx] <- ctx
+        let nextIdx = (idx + 1) % windowSize
+        state.Value.Value <- (arr, nextIdx, newCount, newTrueCount)
+        return float newTrueCount / float newCount
     }

src/LocSta2/Counting/Rate.fs

@@ -6,15 +6,15 @@ open LocSta.Core
 let delayByN n defaultValue =
     stream {
         let! ctx = getCtx()
-        let! buffer = useStateWith (fun () -> List.replicate n defaultValue)
+        let! state = useStateWith (fun () ->
+            let arr = Array.create (max 1 n) defaultValue
+            MutableValue(arr, 0))
+        let (arr, idx) = state.Value.Value
         let output =
-            match buffer.Value with
-            | [] -> ctx
-            | head :: _ -> head
-        if n > 0 then
-            buffer.Value <-
-                match buffer.Value with
-                | [] -> [ ctx ]
-                | _ :: tail -> tail @ [ ctx ]
+            if n > 0 then arr[idx]
+            else ctx
+        arr[idx] <- ctx
+        let nextIdx = (idx + 1) % (max 1 n)
+        state.Value.Value <- (arr, nextIdx)
         return output
     }

src/LocSta2/Delay/DelayByN.fs

@@ -7,15 +7,14 @@ let crossover s1 s2 =
     stream {
         let! v1 = s1
         let! v2 = s2
-        let! prevDiff = useState ValueNone
+        let! st = useMemoWith (fun () -> MutableValue(0.0, false))
+        let (prevDiff, hasPrev) = st.Value
         let currDiff = v1 - v2
         let output =
-            match prevDiff.Value with
-            | ValueNone -> 0
-            | ValueSome pd ->
-                if pd <= 0.0 && currDiff > 0.0 then 1
-                elif pd >= 0.0 && currDiff < 0.0 then -1
-                else 0
-        prevDiff.Value <- ValueSome currDiff
+            if not hasPrev then 0
+            elif prevDiff <= 0.0 && currDiff > 0.0 then 1
+            elif prevDiff >= 0.0 && currDiff < 0.0 then -1
+            else 0
+        st.Value <- (currDiff, true)
         return output
     }

src/LocSta2/Detection/Crossover.fs

@@ -6,14 +6,13 @@ open LocSta.Core
 let inline threshold level =
     stream {
         let! ctx = getCtx()
-        let! prev = useState ValueNone
+        let! st = useMemoWith (fun () -> MutableValue(ctx, false))
+        let (p, hasPrev) = st.Value
         let output =
-            match prev.Value with
-            | ValueNone -> 0
-            | ValueSome p ->
-                if p < level && ctx >= level then 1
-                elif p >= level && ctx < level then -1
-                else 0
-        prev.Value <- ValueSome ctx
+            if not hasPrev then 0
+            elif p < level && ctx >= level then 1
+            elif p >= level && ctx < level then -1
+            else 0
+        st.Value <- (ctx, true)
         return output
     }

src/LocSta2/Detection/Threshold.fs

@@ -2,13 +2,24 @@ module LocSta.Blocks.Dsp.Analysis.Rms
 
 open LocSta.Core
 
+/// Computes RMS over the first 'count' elements of 'arr'.
+let private computeRms (arr: float array) (count: int) =
+    let mutable sumSq = 0.0
+    for i = 0 to count - 1 do
+        sumSq <- sumSq + arr[i] * arr[i]
+    sqrt (sumSq / float count)
+
 /// RMS (Root Mean Square) level over a window of 'windowSize' samples.
 let rms windowSize =
     stream {
         let! signal = getCtx()
-        let! window = useState []
-        let newWindow = (signal :: window.Value) |> List.truncate windowSize
-        window.Value <- newWindow
-        let sumOfSquares = newWindow |> List.sumBy (fun x -> x * x)
-        return sqrt (sumOfSquares / float newWindow.Length)
+        let! state = useStateWith (fun () ->
+            let arr = Array.zeroCreate<float> windowSize
+            MutableValue(arr, 0, 0))
+        let (arr, idx, count) = state.Value.Value
+        let newCount = min (count + 1) windowSize
+        arr[idx] <- signal
+        let nextIdx = (idx + 1) % windowSize
+        state.Value.Value <- (arr, nextIdx, newCount)
+        return computeRms arr newCount
     }

src/LocSta2/Dsp/Analysis/Rms.fs

@@ -2,16 +2,30 @@ module LocSta.Blocks.Dsp.Analysis.ZeroCrossRate
 
 open LocSta.Core
 
+/// Computes zero-crossing rate over 'count' elements in circular buffer starting at 'startIdx'.
+let private computeZeroCrossings (arr: float array) (count: int) (startIdx: int) (windowSize: int) =
+    if count < 2 then 0.0
+    else
+        let mutable crossings = 0
+        for k = 0 to count - 2 do
+            let i = (startIdx + k) % windowSize
+            let j = (startIdx + k + 1) % windowSize
+            if (arr[i] >= 0.0 && arr[j] < 0.0) || (arr[i] < 0.0 && arr[j] >= 0.0) then
+                crossings <- crossings + 1
+        float crossings / float (count - 1)
+
 /// Zero crossing rate over a window of 'windowSize' samples.
 let zeroCrossRate windowSize =
     stream {
         let! signal = getCtx()
-        let! window = useState []
-        let newWindow = (signal :: window.Value) |> List.truncate windowSize
-        window.Value <- newWindow
-        let crossings =
-            newWindow
-            |> List.pairwise
-            |> List.sumBy (fun (a, b) -> if (a >= 0.0 && b < 0.0) || (a < 0.0 && b >= 0.0) then 1 else 0)
-        return float crossings / float (max 1 (newWindow.Length - 1))
+        let! state = useStateWith (fun () ->
+            let arr = Array.zeroCreate<float> windowSize
+            MutableValue(arr, 0, 0))
+        let (arr, idx, count) = state.Value.Value
+        let newCount = min (count + 1) windowSize
+        arr[idx] <- signal
+        let nextIdx = (idx + 1) % windowSize
+        state.Value.Value <- (arr, nextIdx, newCount)
+        let startIdx = if newCount < windowSize then 0 else nextIdx
+        return computeZeroCrossings arr newCount startIdx windowSize
     }