oakscriptjs 0.9.3 → 0.9.5

package/src/callsite/index.ts

@@ -11,6 +11,8 @@
  *   loops, called only on the bars where the Pine call runs.
  * - {@link lowest} / {@link highest}: `ta.lowest` / `ta.highest` with a series length (a different length on each
  *   call), which PineScript computes with a state kept between calls.
+ * - {@link lowestByBar} / {@link highestByBar} / {@link linreg}: `ta.lowest` / `ta.highest` / `ta.linreg` in a
+ *   conditional block, whose history is kept by bar (not by call).
  *
  * Since PineScript v6, `and` / `or` are lazy: the right operand runs only when the left operand does not decide
  * the result. A ta.* call in the right operand of `a or b` runs on the bars where `a` is false, in `a and b` on the
@@ -40,6 +42,7 @@
  */
 
 import type { Source } from '../types/index.js';
+import { linreg as linregSeries } from '../ta/index.js';
 
 /**
  * Runs `fn` on the bars where `called` is true only, like a ta.* call inside an `if` block.
@@ -65,24 +68,35 @@ export function whenCalled<T extends number | boolean>(
   return out;
 }
 
-/** A call site that keeps the two previous arguments (na before the first call). */
+/**
+ * A call site that keeps the arguments of the last call where both were not na (na before such a call), as
+ * ta.crossover / ta.crossunder / ta.cross.
+ */
 function twoSeriesSite(test: (a: number, b: number, prevA: number, prevB: number) => boolean) {
   let prevA = NaN;
   let prevB = NaN;
   return (a: number, b: number): boolean => {
     const result = test(a, b, prevA, prevB);
-    prevA = a;
-    prevB = b;
+    if (!Number.isNaN(a) && !Number.isNaN(b)) {
+      prevA = a;
+      prevB = b;
+    }
     return result;
   };
 }
 
-/** One `ta.crossover(a, b)` call site: false on its first call, as its history is na. */
+/**
+ * One `ta.crossover(a, b)` call site: compared with the last call where both arguments were not na; false before
+ * such a call.
+ */
 export function crossover(): (a: number, b: number) => boolean {
   return twoSeriesSite((a, b, pa, pb) => a > b && pa <= pb);
 }
 
-/** One `ta.crossunder(a, b)` call site: false on its first call, as its history is na. */
+/**
+ * One `ta.crossunder(a, b)` call site: compared with the last call where both arguments were not na; false before
+ * such a call.
+ */
 export function crossunder(): (a: number, b: number) => boolean {
   return twoSeriesSite((a, b, pa, pb) => a < b && pa >= pb);
 }
@@ -100,7 +114,10 @@ export function barssince(): (condition: boolean | number) => number {
   };
 }
 
-/** One `ta.cross(a, b)` call site: false on its first call, as its history is na. */
+/**
+ * One `ta.cross(a, b)` call site: compared with the last call where both arguments were not na; false before such
+ * a call.
+ */
 export function cross(): (a: number, b: number) => boolean {
   return twoSeriesSite((a, b, pa, pb) => (a > b && pa <= pb) || (a < b && pa >= pb));
 }
@@ -176,3 +193,99 @@ export function lowest(): (value: number, length: number) => number {
 export function highest(): (value: number, length: number) => number {
   return extremeSite(false);
 }
+
+/** One `ta.lowest` / `ta.highest` call site whose history is kept by bar; rules in {@link lowestByBar}. */
+function extremeByBarSite(isLowest: boolean): (barIndex: number, value: number, length: number) => number {
+  const better = isLowest ? (a: number, b: number) => a < b : (a: number, b: number) => a > b;
+  let ring: number[] = [];
+  let extreme = NaN;
+  let extremeAt = -1;
+  return (barIndex, value, length) => {
+    const len = Math.floor(length);
+    if (ring.length !== len + 1) {
+      ring = new Array<number>(len + 1).fill(0);
+      extreme = NaN;
+    }
+    ring[barIndex % (len + 1)] = value;
+    if (Number.isNaN(extreme) || better(value, extreme)) {
+      extreme = value;
+      extremeAt = barIndex;
+    } else if (barIndex - extremeAt >= len) {
+      extreme = NaN;
+      for (let b = barIndex - len + 1; b <= barIndex; b++) {
+        const v = ring[b % (len + 1)]!;
+        if (!Number.isNaN(v) && (Number.isNaN(extreme) || better(v, extreme))) {
+          extreme = v;
+          extremeAt = b;
+        }
+      }
+    }
+    return barIndex < len - 1 ? NaN : extreme;
+  };
+}
+
+/**
+ * One `ta.lowest(source, length)` call site in a conditional block whose history is kept by bar (not by call), called
+ * with `(barIndex, value, length)` on the bars where the Pine call runs.
+ *
+ * PineScript rules (measured on a call in a ternary branch, length 6):
+ * - the values are kept in a ring of `length + 1` slots indexed by the bar index, filled with 0 at the start and
+ *   written only on the bars where the call runs: a bar before the first call counts as 0, and a bar without a call
+ *   holds the value of the call `length + 1` bars earlier (0 if there was none)
+ * - on a call, the value replaces the kept extreme when there is none or when it is strictly lower; only otherwise,
+ *   when the kept extreme is `length` bars old, the last `length` bars are read again from the ring (the oldest bar
+ *   wins a tie)
+ * - na before bar `length - 1` (by bar, not by call)
+ *
+ * {@link lowest} keeps the history by call instead; both rules were measured, on different scripts.
+ *
+ * @example
+ * ```typescript
+ * // Pine:  lo = cond ? ta.lowest(low, 6) : na
+ * const site = callsite.lowestByBar();
+ * const lo = lows.map((v, i) => (cond[i] ? site(i, v, 6) : NaN));
+ * ```
+ */
+export function lowestByBar(): (barIndex: number, value: number, length: number) => number {
+  return extremeByBarSite(true);
+}
+
+/**
+ * One `ta.highest(source, length)` call site in a conditional block whose history is kept by bar, called with
+ * `(barIndex, value, length)`. Same rules as {@link lowestByBar} (a value replaces the kept extreme when it is
+ * strictly higher).
+ */
+export function highestByBar(): (barIndex: number, value: number, length: number) => number {
+  return extremeByBarSite(false);
+}
+
+/**
+ * One `ta.linreg(source, length, offset)` call site in a conditional block, called with
+ * `(barIndex, value, length, offset)` on the bars where the Pine call runs.
+ *
+ * PineScript rules (measured): `ta.linreg` keeps the values it receives in a ring of `length + 1` slots indexed by the
+ * bar index, filled with 0 at the start and written only on the bars where it is called. The window is read from the
+ * ring for the last `length` bars: a bar before the first call counts as 0, and a bar without a call holds the value of
+ * the call `length + 1` bars earlier (0 if there was none). The result is na before bar `length - 1`. Called on every
+ * bar, it equals `ta.linreg`.
+ *
+ * @example
+ * ```typescript
+ * // Pine:  if bar_index >= 20
+ * //            a := ta.linreg(close, 10, 0)
+ * const site = callsite.linreg();
+ * const a = closes.map((c, i) => (i >= 20 ? site(i, c, 10, 0) : NaN));
+ * ```
+ */
+export function linreg(): (barIndex: number, value: number, length: number, offset?: number) => number {
+  let ring: number[] = [];
+  return (barIndex, value, length, offset = 0) => {
+    const len = Math.floor(length);
+    if (ring.length !== len + 1) ring = new Array<number>(len + 1).fill(0);
+    ring[barIndex % (len + 1)] = value;
+    if (barIndex < len - 1) return NaN;
+    const window = Array.from({ length: len }, (_, k) => ring[(barIndex - len + 1 + k) % (len + 1)]!);
+    return linregSeries(window, len, offset)[len - 1]!;
+  };
+}
+

package/src/index.ts

@@ -164,7 +164,7 @@ export type { LightweightSeriesDefinitions } from './runtime/adapters/Lightweigh
 export { SimpleInputAdapter } from './runtime/adapters/SimpleInputAdapter.js';
 
 // Version
-export const VERSION = '0.9.3';
+export const VERSION = '0.9.5';
 
 /**
  * Library information

package/src/math/index.ts

@@ -952,12 +952,13 @@ export function random(min?: float, max?: float, _seed?: int): float {
  * Returns the sign of a number.
  *
  * @param value - The number to check or Series
- * @returns 1 for positive, -1 for negative, 0 for zero
+ * @returns 1 for positive, -1 for negative, 0 for zero, na for na
  *
  * @remarks
  * - Returns 1 if value > 0
  * - Returns -1 if value < 0
  * - Returns 0 if value = 0
+ * - Returns na if value is na (as PineScript)
  * - Useful for determining direction or polarity
  * - If value is a Series, returns a Series; if value is a number, returns a number
  *
@@ -967,6 +968,7 @@ export function random(min?: float, max?: float, _seed?: int): float {
  * math.sign(-3) // Returns: -1
  * math.sign(0) // Returns: 0
  * math.sign(0.001) // Returns: 1
+ * math.sign(NaN) // Returns: NaN
  * ```
  */
 export function sign(value: Series): Series;
@@ -980,13 +982,13 @@ export function sign(value: float | Series): int | Series {
     const result: number[] = [];
     for (let i = 0; i < length; i++) {
       const v = valueArray[i] ?? NaN;
-      result.push(v > 0 ? 1 : v < 0 ? -1 : 0);
+      result.push(v > 0 ? 1 : v < 0 ? -1 : v === 0 ? 0 : NaN);
     }
     
     return Series.fromArray(bars, result);
   }
   
-  return value > 0 ? 1 : value < 0 ? -1 : 0;
+  return value > 0 ? 1 : value < 0 ? -1 : value === 0 ? 0 : NaN;
 }
 
 /**

package/src/ta/index.ts

@@ -74,26 +74,21 @@ export function ema(source: Source, length: simple_int): series_float {
   const len = Math.floor(length);
   const multiplier = 2 / (len + 1);
 
-  // SMA seed: slide past leading NaN, then collect `len` valid values.
-  // An infinite value is na, as in PineScript.
+  // SMA seed on the bar of the `len`-th valid value. An infinite value is na, as in PineScript.
   let firstValidIndex = -1;
   let validCount = 0;
-  let initSum = 0;
 
   for (let i = 0; i < source.length; i++) {
     const val = source[i];
-    if (val !== undefined && Number.isFinite(val)) {
-      initSum += val;
-      validCount++;
-      if (validCount === len) {
-        firstValidIndex = i;
-        break;
-      }
+    if (val !== undefined && Number.isFinite(val) && ++validCount === len) {
+      firstValidIndex = i;
+      break;
     }
   }
 
-  let emaValue = validCount > 0 ? initSum / validCount : NaN;
   const emaInitialized = firstValidIndex >= 0;
+  // The seed is ta.sma on that bar: the running sum of math.sum (PineScript bits), not a plain loop sum
+  let emaValue = emaInitialized ? runningSum(source.slice(0, firstValidIndex + 1), len)[firstValidIndex]! / len : NaN;
 
   for (let i = 0; i < source.length; i++) {
     if (!emaInitialized || i < firstValidIndex) {
@@ -350,6 +345,32 @@ function extremeValue(source: Source, length: simple_int, lowest: boolean): seri
   });
 }
 
+/**
+ * Compares each bar with the last earlier bar where both values were not na (PineScript rule for ta.crossover,
+ * ta.crossunder and ta.cross): false while there is no such bar, and false on a bar with an na value.
+ *
+ * @internal
+ */
+function crossTest(
+  series1: Source,
+  series2: Source,
+  test: (a: number, b: number, prevA: number, prevB: number) => boolean,
+): series_bool {
+  const result: series_bool = [];
+  let prevA = NaN;
+  let prevB = NaN;
+  for (let i = 0; i < series1.length; i++) {
+    const a = series1[i]!;
+    const b = series2[i]!;
+    result.push(test(a, b, prevA, prevB));
+    if (!Number.isNaN(a) && !Number.isNaN(b)) {
+      prevA = a;
+      prevB = b;
+    }
+  }
+  return result;
+}
+
 /**
  * Crossover - returns true when series1 crosses over series2 (moves from below to above).
  *
@@ -358,8 +379,10 @@ function extremeValue(source: Source, length: simple_int, lowest: boolean): seri
  * @returns Boolean series (true at crossover points)
  *
  * @remarks
- * - True when: series1[i]! > series2[i]! AND series1[i-1] <= series2[i-1]
+ * - True when: series1[i] > series2[i] AND series1[j] <= series2[j], where j is the last bar before i where both
+ *   values were not na (PineScript rule: a crossing right after an na bar is not missed)
  * - First value is always false (no previous value to compare)
+ * - Comparisons are exact (no tolerance)
  * - Useful for detecting bullish signals (e.g., fast MA crossing over slow MA)
  *
  * @example
@@ -368,17 +391,7 @@ function extremeValue(source: Source, length: simple_int, lowest: boolean): seri
  * ```
  */
 export function crossover(series1: Source, series2: Source): series_bool {
-  const result: series_bool = [];
-
-  for (let i = 0; i < series1.length; i++) {
-    if (i === 0) {
-      result.push(false);
-    } else {
-      result.push(series1[i]! > series2[i]! && series1[i - 1]! <= series2[i - 1]!);
-    }
-  }
-
-  return result;
+  return crossTest(series1, series2, (a, b, pa, pb) => a > b && pa <= pb);
 }
 
 /**
@@ -389,8 +402,10 @@ export function crossover(series1: Source, series2: Source): series_bool {
  * @returns Boolean series (true at crossunder points)
  *
  * @remarks
- * - True when: series1[i]! < series2[i]! AND series1[i-1] >= series2[i-1]
+ * - True when: series1[i] < series2[i] AND series1[j] >= series2[j], where j is the last bar before i where both
+ *   values were not na
  * - First value is always false (no previous value to compare)
+ * - Comparisons are exact (no tolerance)
  * - Useful for detecting bearish signals (e.g., fast MA crossing under slow MA)
  *
  * @example
@@ -399,17 +414,7 @@ export function crossover(series1: Source, series2: Source): series_bool {
  * ```
  */
 export function crossunder(series1: Source, series2: Source): series_bool {
-  const result: series_bool = [];
-
-  for (let i = 0; i < series1.length; i++) {
-    if (i === 0) {
-      result.push(false);
-    } else {
-      result.push(series1[i]! < series2[i]! && series1[i - 1]! >= series2[i - 1]!);
-    }
-  }
-
-  return result;
+  return crossTest(series1, series2, (a, b, pa, pb) => a < b && pa >= pb);
 }
 
 /**
@@ -859,8 +864,9 @@ export function cum(source: Source): series_float {
  * @returns Boolean series (true at cross points)
  *
  * @remarks
- * - True when: (source1[i]! > source2[i]! AND source1[i-1] <= source2[i-1]) OR
- *              (source1[i]! < source2[i]! AND source1[i-1] >= source2[i-1])
+ * - True when: (source1[i] > source2[i] AND source1[j] <= source2[j]) OR
+ *              (source1[i] < source2[i] AND source1[j] >= source2[j]),
+ *   where j is the last bar before i where both values were not na
  * - First value is always false (no previous value to compare)
  * - Detects any crossing (either over or under)
  * - Use `ta.crossover()` or `ta.crossunder()` for directional crosses
@@ -872,19 +878,7 @@ export function cum(source: Source): series_float {
  * ```
  */
 export function cross(source1: Source, source2: Source): series_bool {
-  const result: series_bool = [];
-
-  for (let i = 0; i < source1.length; i++) {
-    if (i === 0) {
-      result.push(false);
-    } else {
-      const crossedUp = source1[i]! > source2[i]! && source1[i - 1]! <= source2[i - 1]!;
-      const crossedDown = source1[i]! < source2[i]! && source1[i - 1]! >= source2[i - 1]!;
-      result.push(crossedUp || crossedDown);
-    }
-  }
-
-  return result;
+  return crossTest(source1, source2, (a, b, pa, pb) => (a > b && pa <= pb) || (a < b && pa >= pb));
 }
 
 /**
@@ -1428,7 +1422,7 @@ export function correlation(source1: Source, source2: Source, length: simple_int
  * - Useful for identifying relative strength within a period
  *
  * PineScript rules:
- * - percentrank = count(source[k] <= source, k = 1..length) / length * 100
+ * - percentrank = count(source[k] <= source, k = 1..length) * 100 / length (in this order: the PineScript bits)
  * - a value from bar `length` on, when the current source is not `na`; an `na` value in the window counts as not
  *   `<=` the current value
  * - the comparison uses the 1e-10 tolerance
@@ -1454,7 +1448,7 @@ export function percentrank(source: Source, length: simple_int): series_float {
     for (let j = 1; j <= length; j++) {
       if (le(source[i - j]!, currentValue)) countLessOrEqual++;
     }
-    result.push((countLessOrEqual / length) * 100);
+    result.push((countLessOrEqual * 100) / length);
   }
 
   return result;
@@ -2078,7 +2072,8 @@ export function tsi(source: Source, shortLength: simple_int, longLength: simple_
  * - CMO > +50: overbought conditions
  * - CMO < -50: oversold conditions
  * - Unlike RSI, CMO uses sum of gains/losses instead of averages
- * - na on a flat window (every change 0), as in PineScript
+ * - As in PineScript: the sums are the running sums of `math.sum` (bit for bit), and a flat window (every change 0)
+ *   is `0 / 0` = na
  * - More volatile than RSI
  *
  * @example
@@ -2089,37 +2084,20 @@ export function tsi(source: Source, shortLength: simple_int, longLength: simple_
  * ```
  */
 export function cmo(source: Source, length: simple_int): series_float {
-  const result: series_float = [];
-
+  // PineScript definition: mom = ta.change(src), sm1 = math.sum(mom >= 0 ? mom : 0, length),
+  // sm2 = math.sum(mom >= 0 ? 0 : -mom, length), cmo = 100 * (sm1 - sm2) / (sm1 + sm2), with the running sums of
+  // math.sum (bit for bit). A comparison with na is false: an na change adds 0 to sm1 and na (skipped) to sm2.
+  const up: number[] = [];
+  const down: number[] = [];
   for (let i = 0; i < source.length; i++) {
-    if (i < length) {
-      result.push(NaN);
-      continue;
-    }
-
-    let sumGains = 0;
-    let sumLosses = 0;
-
-    for (let j = 0; j < length; j++) {
-      const change = source[i - j]! - source[i - j - 1]!;
-      if (change > 0) {
-        sumGains += change;
-      } else {
-        sumLosses += Math.abs(change);
-      }
-    }
-
-    // PineScript: 100 * (sm1 - sm2) / (sm1 + sm2), so a flat window (0 / 0) is na
-    const totalMovement = sumGains + sumLosses;
-    if (totalMovement === 0) {
-      result.push(NaN);
-    } else {
-      const cmoValue = ((sumGains - sumLosses) / totalMovement) * 100;
-      result.push(cmoValue);
-    }
-  }
-
-  return result;
+    const mom = i > 0 ? source[i]! - source[i - 1]! : NaN;
+    up.push(mom >= 0 ? mom : 0);
+    down.push(mom >= 0 ? 0 : -mom);
+  }
+  const sm1 = runningSum(up, length);
+  const sm2 = runningSum(down, length);
+  // a flat window is 0 / 0 = na
+  return sm1.map((s1, i) => (100 * (s1 - sm2[i]!)) / (s1 + sm2[i]!));
 }
 
 /**

package/src/ta/running-sum.ts

@@ -6,7 +6,8 @@
  * - each bar first removes, with a Kahan step, the compensated value that was added for the value that leaves the
  *   window, then adds the new value with a Kahan step and keeps its compensated value;
  * - when the compensation of the previous step would be lost when applied to the new value, the sum is computed
- *   again from the window values (newest first) and the compensation is reset.
+ *   again from the window values (newest first) and the compensation is reset. The test rounds on the grid of the
+ *   new value toward +infinity: for a negative power of two, the finer grid of the binade below (#136).
  *
  * So the result can differ from the exact window sum in the last bits (e.g. a small residue on a window of zeros),
  * as in PineScript.
@@ -23,18 +24,29 @@ function exponentOf(x: number): number {
   return e === 0 ? -1074 : e - 1023;
 }
 
+/**
+ * Distance from a finite non-zero `x` to the next number toward +infinity: the spacing of the binade of `x`, or half
+ * of it when `x` is a negative power of two (the next number up is in the binade below).
+ */
+function spacingUp(x: number): number {
+  const e = exponentOf(x);
+  const powerOfTwo = (view.getUint16(0) & 0xf) === 0 && view.getUint16(2) === 0 && view.getUint32(4) === 0;
+  return 2 ** (e - (x < 0 && powerOfTwo && e > -1022 ? 53 : 52));
+}
+
 /**
  * Whether the compensation `c` is (partly) lost when it is applied to `x`: `x - c` rounded on the grid of `x`
- * (spacing of the binade of `x`, ties to an even mantissa) applies less than `c`.
+ * (spacing {@link spacingUp}, ties to an even mantissa) applies less than `c`.
  */
 function compensationLost(x: number, c: number): boolean {
   if (c === 0 || x === 0) return false;
-  const ulp = 2 ** (exponentOf(x) - 52);
+  const ulp = spacingUp(x);
   const q = c / ulp;
   const mantissa = x / ulp;
   const f = Math.floor(q);
   const d = q - f;
-  const applied = d > 0.5 ? f + 1 : d < 0.5 ? f : (mantissa - f) % 2 === 0 ? f : f + 1;
+  // parity of mantissa - f from each part: the mantissa can be 2^53 (half spacing), where mantissa - f is not exact
+  const applied = d > 0.5 ? f + 1 : d < 0.5 ? f : Math.abs(mantissa % 2) === Math.abs(f % 2) ? f : f + 1;
   return Math.abs(applied) < Math.abs(q);
 }