code reviews

lib/numerics/highest/Highest.Tests.cs

@@ -129,7 +129,8 @@ public class HighestTests
 
         indicator.Update(new TValue(time, 15.0));
         indicator.Update(new TValue(time.AddMinutes(1), double.PositiveInfinity));
-        Assert.True(double.IsFinite(indicator.Last.Value));
+        // Should use last valid value (15.0) instead of infinity
+        Assert.Equal(15.0, indicator.Last.Value, Tolerance);
     }
 
     [Fact]
@@ -296,4 +297,4 @@ public class HighestTests
         indicator.Update(new TValue(time.AddMinutes(5), 5.0));
         Assert.Equal(9.0, indicator.Last.Value, Tolerance);
     }
-}
+}

lib/numerics/highest/Highest.cs

@@ -148,33 +148,48 @@ public sealed class Highest : AbstractBase
             }
 
             // Second pass: compute rolling max using corrected values
-            int dequeStart = 0;
-            int dequeEnd = 0;
+            // Use circular buffer indexing to avoid compaction overhead
+            // Branch-based wrapping is faster than modulo in hot paths
+            int head = 0;  // front of deque (oldest/max)
+            int tail = 0;  // back of deque (newest)
+            int count = 0; // number of elements in deque
+            int capacity = deque.Length;
 
             for (int i = 0; i < len; i++)
             {
                 double value = values[i];
 
-                // Remove indices outside window
-                while (dequeEnd > dequeStart && deque[dequeStart] <= i - period)
-                    dequeStart++;
-
-                // Remove smaller values from back
-                while (dequeEnd > dequeStart && values[deque[dequeEnd - 1]] <= value)
-                    dequeEnd--;
-
-                // Compact deque if needed
-                if (dequeEnd >= deque.Length)
+                // Remove indices outside window from front
+                while (count > 0 && deque[head] <= i - period)
                 {
-                    int count = dequeEnd - dequeStart;
-                    for (int j = 0; j < count; j++)
-                        deque[j] = deque[dequeStart + j];
-                    dequeStart = 0;
-                    dequeEnd = count;
+                    head++;
+                    if (head >= capacity) head -= capacity;
+                    count--;
                 }
 
-                deque[dequeEnd++] = i;
-                output[i] = values[deque[dequeStart]];
+                // Remove smaller values from back
+                while (count > 0)
+                {
+                    int backIdx = tail - 1;
+                    if (backIdx < 0) backIdx += capacity;
+                    if (values[deque[backIdx]] <= value)
+                    {
+                        tail = backIdx;
+                        count--;
+                    }
+                    else
+                    {
+                        break;
+                    }
+                }
+
+                // Add current index at tail
+                deque[tail] = i;
+                tail++;
+                if (tail >= capacity) tail -= capacity;
+                count++;
+
+                output[i] = values[deque[head]];
             }
         }
         finally
@@ -193,4 +208,4 @@ public sealed class Highest : AbstractBase
         _p_state = default;
         Last = default;
     }
-}
+}