oakscriptjs 0.9.4 → 0.9.6

package/dist/cjs/math/index.d.ts

@@ -8,9 +8,10 @@
  *
  * Known difference: `log10`, `exp`, `log`, `pow`, `sin`, `cos`, `tan` use JavaScript's `Math`. PineScript uses
  * other algorithms, whose results differ by 1 or 2 units in the last place on part of the inputs (`log10` about 4 %,
- * `exp` about 9 %, `sin` / `cos` / `tan` about 3 %, `log` 0.4 %, `pow` 0.05 % of random inputs). A constant argument
- * (`math.log10(2)`) can differ by up to 3 units in the last place. This is visible only when a script amplifies
- * these tiny differences (e.g. `ma > ma[1]` on values of 1e195); `sqrt`, `atan`, `asin`, `acos` are equal.
+ * `exp` about 9 %, `sin` / `cos` / `tan` about 3 %, `log` 0.4 %, `pow` 0.05 % of random inputs). This is visible
+ * only when a script amplifies these tiny differences (e.g. `ma > ma[1]` on values of 1e195); `sqrt`, `atan`,
+ * `asin`, `acos` are equal. A constant argument (`math.log10(2)`) is computed before the script runs, with other
+ * rules: see `constant`.
  *
  * @version 6
  */
@@ -90,20 +91,55 @@ export declare function floor(value: float): int;
  * @remarks
  * - Rounds to nearest integer by default
  * - With precision, rounds to that many decimal places
- * - Uses "round half up" strategy (0.5 rounds to 1)
  * - If value is a Series, returns a Series; if value is a number, returns a number
  *
+ * PineScript rules:
+ * - ties go away from zero (2.5 -> 3, -2.5 -> -3, -0.5 -> -1)
+ * - without a precision, or with a precision <= 0, the result is the integer rounding (1234.5678 @ -2 -> 1235)
+ * - a positive precision rounds only the fraction: `int + round(frac * scale) / scale` with
+ *   `scale = 1 / 10^-precision` (precision above 16 acts as 16); the tie is decided on the exact value of
+ *   `frac * scale` with a 1e-10 tolerance (1.005 @ 2 -> 1.01, 0.285 @ 2 -> 0.29, -1.45 @ 1 -> -1.5)
+ * - an infinite value gives na
+ *
  * @example
  * ```typescript
  * math.round(4.2) // Returns: 4
  * math.round(4.5) // Returns: 5
- * math.round(4.8) // Returns: 5
+ * math.round(-2.5) // Returns: -3
  * math.round(4.567, 2) // Returns: 4.57
- * math.round(4.567, 1) // Returns: 4.6
+ * math.round(1.005, 2) // Returns: 1.01
  * ```
  */
 export declare function round(value: Series, precision?: int): Series;
 export declare function round(value: float, precision?: int): float;
+/**
+ * Returns the value PineScript gives to a constant float expression (not a PineScript function).
+ *
+ * @param value - The result of the constant expression, computed in JavaScript (e.g. `1 / 255`)
+ * @returns The value of the same expression in a PineScript script
+ *
+ * @remarks
+ * PineScript computes a constant expression (only literals and constants: `1 / 255`, `0.1 * 3`,
+ * `math.sqrt(0.1)`) before the script runs, and the value is then rounded. JavaScript cannot tell a constant from a
+ * series value, so wrap the constant expressions of a script with this function.
+ * - |value| >= 0.001: the exact value of the double is rounded to 16 decimals, ties to even
+ *   (`1 / 255` -> 0.003921568627451, `1 / 7` -> 0.1428571428571428)
+ * - |value| < 0.001, na and infinities: unchanged
+ * - the whole expression is computed first, then rounded once (`(1 / 7) * 7` is 1)
+ * - math functions of constants use JavaScript's `Math` there: `math.constant(math.sqrt(0.1))` is the PineScript
+ *   value; `math.log10` of a constant is `math.log(x) / math.log(10)` there:
+ *   `math.constant(math.log(2) / math.log(10))` -> 0.3010299956639811
+ * - the same expression with a series operand (`close / 255`) is not rounded: do not wrap it
+ *
+ * @example
+ * ```typescript
+ * // Pine: var const float i_255 = 1 / 255
+ * const i_255 = math.constant(1 / 255) // 0.003921568627451 (JavaScript: 0.00392156862745098)
+ * math.constant(1 / 7) // 0.1428571428571428 (JavaScript: 0.14285714285714285)
+ * math.constant(1 / 3) // 0.3333333333333333 (unchanged)
+ * ```
+ */
+export declare function constant(value: float): float;
 /**
  * Returns the maximum value from the arguments.
  *
@@ -156,6 +192,8 @@ export declare function min(...values: (float | Series)[]): float | Series;
  * - Calculates sum of all values divided by count
  * - Returns NaN if no arguments provided (division by zero)
  * - If any argument is a Series, returns a Series; otherwise returns a number
+ * - PineScript rule: with 1 or 2 values the sum is plain; with 3 values or more it is a Kahan compensated sum whose
+ *   pending correction is subtracted before the division (math.avg(0.1, 0.2, 0.3) = 0.19999999999999998)
  *
  * @example
  * ```typescript
@@ -170,7 +208,7 @@ export declare function avg(...values: (float | Series)[]): float | Series;
  * Returns the sum of values over a sliding window.
  *
  * @param source - Series of values or array
- * @param length - Window length for summation
+ * @param length - Window length for summation, or one length per bar (a series length: array or Series)
  * @returns Series or array with rolling sum values
  *
  * @remarks
@@ -180,6 +218,11 @@ export declare function avg(...values: (float | Series)[]): float | Series;
  * - A compensated running sum, as in PineScript, so the result can differ from the exact window sum in the last
  *   bits (bit for bit with PineScript)
  * - When passed a Series, returns a Series; when passed an array, returns an array
+ * - With a series length, PineScript moves the running sum to the new length when the length changes, with Kahan
+ *   steps of the raw values: a smaller length removes the values that leave the window (oldest first); a larger
+ *   length adds back the values from the one before the old window down to the one `length` values back (newest
+ *   first), then the usual step removes the stored value of the one `length` values back. A bar with an `na` value
+ *   gives the sum of the last `length` earlier values
  *
  * @example
  * ```typescript
@@ -187,8 +230,8 @@ export declare function avg(...values: (float | Series)[]): float | Series;
  * // Explanation: [NaN, NaN, 1+2+3, 2+3+4, 3+4+5]
  * ```
  */
-export declare function sum(source: Series, length: simple_int): Series;
-export declare function sum(source: series_float, length: simple_int): series_float;
+export declare function sum(source: Series, length: simple_int | ArrayLike<number> | Series): Series;
+export declare function sum(source: series_float, length: simple_int | ArrayLike<number> | Series): series_float;
 /**
  * Returns the square root of a number.
  *
@@ -485,39 +528,47 @@ export declare function toradians(degrees: float): float;
  */
 export declare function todegrees(radians: Series): Series;
 export declare function todegrees(radians: float): float;
+/**
+ * PineScript's seeded generator: Java's linear congruential generator (`java.util.Random`), `nextDouble()`.
+ * Each generator draws one number per call.
+ */
+export declare function seededRandom(seed: int): (min?: float, max?: float) => float;
+/** Starts every seeded sequence of `math.random` again (called at the start of a script run). */
+export declare function resetRandom(): void;
 /**
  * Returns a pseudo-random number.
  *
- * @param min - Optional minimum value (inclusive)
- * @param max - Optional maximum value (exclusive)
- * @param seed - Optional seed for deterministic random
+ * @param min - Optional minimum value (inclusive), default 0
+ * @param max - Optional maximum value (exclusive), default 1
+ * @param seed - Optional seed: a repeatable sequence, as PineScript (Java's `java.util.Random`)
  * @returns A random number in the specified range, or [0, 1) if no range specified
  *
  * @remarks
- * - Without arguments: returns value in [0, 1)
- * - With min and max: returns value in [min, max)
- * - **WARNING**: The seed parameter is accepted for API compatibility but NOT currently implemented
- * - This implementation always generates non-deterministic random values
- * - PineScript's version supports deterministic seeding for repeatable sequences
+ * - Without a seed: `Math.random()`
+ * - With a seed: PineScript's sequence, one number per call (measured: the call on each bar draws the next number
+ *   of `new java.util.Random(seed).nextDouble()` from the first bar of the history). PineScript keeps one generator
+ *   per call site; here there is one generator per seed value (started again by `executeScript`): for two call sites
+ *   with the same seed use `callsite.random(seed)`
  *
  * @example
  * ```typescript
  * math.random() // Returns: value between 0 and 1 (e.g., 0.234...)
  * math.random(0, 10) // Returns: value between 0 and 10 (e.g., 7.45...)
- * math.random(5, 15) // Returns: value between 5 and 15 (e.g., 11.82...)
+ * math.random(0, 1, 42) // Returns: 0.7275636800328681 on the first call, as PineScript
  * ```
  */
-export declare function random(min?: float, max?: float, _seed?: int): float;
+export declare 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
  *
@@ -527,6 +578,7 @@ export declare 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 declare function sign(value: Series): Series;
@@ -543,9 +595,14 @@ export declare function sign(value: float): int;
  * - **JavaScript signature**: Requires explicit `mintick` OR use `createContext()` with syminfo
  * - Rounds to the nearest value divisible by mintick
  * - Returns NaN for NaN input
- * - Ties round up (0.5 -> 1)
  * - If number is a Series, returns a Series; if number is a float, returns a float
  *
+ * PineScript rules:
+ * - mintick is `minmove / pricescale` (here rebuilt from `mintick`: the smallest power of 10 that makes it an
+ *   integer); the position on the tick grid is `|number| * pricescale / minmove`
+ * - ties go away from zero, decided on the exact value of that product with a 1e-10 tolerance
+ *   (-1.075 -> -1.08, 1.005 -> 1.01, 2.675 -> 2.68 at mintick 0.01)
+ *
  * @example
  * ```typescript
  * // Direct call with explicit mintick
@@ -562,5 +619,5 @@ export declare function round_to_mintick(number: float, mintick?: float): float;
 export declare const pi: number;
 export declare const e: number;
 export declare const phi = 1.618033988749895;
-export declare const rphi = 0.618033988749895;
+export declare const rphi = 0.6180339887498948;
 //# sourceMappingURL=index.d.ts.map

package/dist/cjs/math/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/math/index.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/math/index.ts"],"names":[],"mappings":"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"}

package/dist/cjs/math/index.js

@@ -24,6 +24,7 @@ __export(math_exports, {
   atan: () => atan,
   avg: () => avg,
   ceil: () => ceil,
+  constant: () => constant,
   cos: () => cos,
   e: () => e,
   exp: () => exp,
@@ -36,9 +37,11 @@ __export(math_exports, {
   pi: () => pi,
   pow: () => pow,
   random: () => random,
+  resetRandom: () => resetRandom,
   round: () => round,
   round_to_mintick: () => round_to_mintick,
   rphi: () => rphi,
+  seededRandom: () => seededRandom,
   sign: () => sign,
   sin: () => sin,
   sqrt: () => sqrt,
@@ -96,27 +99,75 @@ function round(value, precision) {
   if (value instanceof import_series.Series) {
     const bars = value.bars;
     const valueArray = value.toArray();
-    const length = bars.length;
     const result = [];
-    if (precision === void 0) {
-      for (let i = 0; i < length; i++) {
-        const v = valueArray[i] ?? NaN;
-        result.push(Math.round(v));
-      }
-    } else {
-      const multiplier2 = Math.pow(10, precision);
-      for (let i = 0; i < length; i++) {
-        const v = valueArray[i] ?? NaN;
-        result.push(Math.round(v * multiplier2) / multiplier2);
-      }
+    for (let i = 0; i < bars.length; i++) {
+      result.push(roundValue(valueArray[i] ?? NaN, precision));
     }
     return import_series.Series.fromArray(bars, result);
   }
-  if (precision === void 0) {
-    return Math.round(value);
-  }
-  const multiplier = Math.pow(10, precision);
-  return Math.round(value * multiplier) / multiplier;
+  return roundValue(value, precision);
+}
+const TIE_SCALE = 10n ** 10n;
+const TIE_HALF = 5n * 10n ** 9n - 1n;
+const INT_LIMIT = 2 ** 52;
+function exactRatio(x) {
+  const view = new DataView(new ArrayBuffer(8));
+  view.setFloat64(0, x);
+  const hi = view.getUint32(0);
+  const lo = view.getUint32(4);
+  const expField = hi >>> 20 & 2047;
+  let mantissa = BigInt(hi & 1048575) << 32n | BigInt(lo);
+  let exp2 = -1074;
+  if (expField !== 0) {
+    mantissa |= 1n << 52n;
+    exp2 = expField - 1075;
+  }
+  return exp2 >= 0 ? [mantissa << BigInt(exp2), 1n] : [mantissa, 1n << BigInt(-exp2)];
+}
+function reachesTie(num, den, units) {
+  return (num - units * den) * TIE_SCALE >= TIE_HALF * den;
+}
+function tenToMinus(p) {
+  return Number.isInteger(p) ? Number(`1e-${p}`) : Math.pow(10, -p);
+}
+function roundValue(value, precision) {
+  if (!Number.isFinite(value)) return NaN;
+  const negative = value < 0;
+  const magnitude = negative ? -value : value;
+  if (precision === void 0 || Number.isNaN(precision) || precision <= 0) {
+    if (magnitude >= INT_LIMIT) return value;
+    let units2 = Math.floor(magnitude);
+    if (magnitude - units2 >= 0.5) units2++;
+    return negative ? 0 - units2 : units2;
+  }
+  const scale = 1 / tenToMinus(Math.min(precision, 16));
+  const fraction = magnitude % 1;
+  const scaled = fraction * scale;
+  let units = Math.floor(scaled);
+  const offset = scaled - units - 0.5;
+  const slack = 1e-9 + scaled * 18e-16;
+  if (-slack < offset && offset < slack) {
+    const [fn, fd] = exactRatio(fraction);
+    const [sn, sd] = exactRatio(scale);
+    if (reachesTie(fn * sn, fd * sd, BigInt(units))) units++;
+  } else if (offset > 0) {
+    units++;
+  }
+  const result = magnitude - fraction + units / scale;
+  return negative ? 0 - result : result;
+}
+const CONSTANT_SCALE = 10n ** 16n;
+function constant(value) {
+  const magnitude = Math.abs(value);
+  if (!(magnitude >= 1e-3 && magnitude < 0.5)) return value;
+  const [num, den] = exactRatio(magnitude);
+  const scaled = num * CONSTANT_SCALE;
+  let units = scaled / den;
+  const twiceRest = (scaled - units * den) * 2n;
+  if (twiceRest > den || twiceRest === den && (units & 1n) === 1n) units++;
+  const digits = units.toString().padStart(17, "0");
+  const result = Number(`${digits.slice(0, -16)}.${digits.slice(-16)}`);
+  return value < 0 ? -result : result;
 }
 function max(...values) {
   const hasSeries = values.some((v) => v instanceof import_series.Series);
@@ -161,7 +212,7 @@ function min(...values) {
 function avg(...values) {
   const hasSeries = values.some((v) => v instanceof import_series.Series);
   if (!hasSeries) {
-    return values.reduce((a, b) => a + b, 0) / values.length;
+    return avgOf(values);
   }
   const firstSeries = values.find((v) => v instanceof import_series.Series);
   const bars = firstSeries.bars;
@@ -174,14 +225,29 @@ function avg(...values) {
     const nums = values.map(
       (v, idx) => valueArrays[idx] ? valueArrays[idx][i] ?? NaN : v
     );
-    const sum2 = nums.reduce((a, b) => a + b, 0);
-    result.push(sum2 / nums.length);
+    result.push(avgOf(nums));
   }
   return import_series.Series.fromArray(bars, result);
 }
+function avgOf(nums) {
+  if (nums.length <= 2) {
+    let sum3 = 0;
+    for (const n of nums) sum3 = sum3 + n;
+    return sum3 / nums.length;
+  }
+  let sum2 = 0;
+  let c = 0;
+  for (const n of nums) {
+    const y = n - c;
+    const t = sum2 + y;
+    c = t - sum2 - y;
+    sum2 = t;
+  }
+  return (sum2 - c) / nums.length;
+}
 function sum(source, length) {
   const sourceArray = source instanceof import_series.Series ? source.toArray() : source;
-  const result = (0, import_running_sum.runningSum)(sourceArray, length);
+  const result = typeof length === "number" ? (0, import_running_sum.runningSum)(sourceArray, length) : (0, import_running_sum.runningSumSeries)(sourceArray, length instanceof import_series.Series ? length.toArray() : length, "math.sum");
   if (source instanceof import_series.Series) {
     return import_series.Series.fromArray(source.bars, result);
   }
@@ -373,7 +439,33 @@ function todegrees(radians) {
   }
   return radians * (180 / Math.PI);
 }
-function random(min2, max2, _seed) {
+function seededRandom(seed) {
+  const mask = (1n << 48n) - 1n;
+  let state = (BigInt(Math.trunc(seed)) ^ 0x5deece66dn) & mask;
+  const next = (bits) => {
+    state = 0x5deece66dn * state + 11n & mask;
+    return state >> 48n - bits;
+  };
+  return (min2 = 0, max2 = 1) => {
+    const hi = next(26n);
+    const lo = next(27n);
+    const unit = Number((hi << 27n) + lo) / 2 ** 53;
+    return min2 + unit * (max2 - min2);
+  };
+}
+const seeded = /* @__PURE__ */ new Map();
+function resetRandom() {
+  seeded.clear();
+}
+function random(min2, max2, seed) {
+  if (seed !== void 0 && seed !== null && !Number.isNaN(seed)) {
+    let gen = seeded.get(seed);
+    if (!gen) {
+      gen = seededRandom(seed);
+      seeded.set(seed, gen);
+    }
+    return gen(min2 ?? 0, max2 ?? 1);
+  }
   const rand = Math.random();
   if (min2 !== void 0 && max2 !== void 0) {
     return min2 + rand * (max2 - min2);
@@ -388,36 +480,24 @@ function sign(value) {
     const result = [];
     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 import_series.Series.fromArray(bars, result);
   }
-  return value > 0 ? 1 : value < 0 ? -1 : 0;
+  return value > 0 ? 1 : value < 0 ? -1 : value === 0 ? 0 : NaN;
 }
 function round_to_mintick(number, mintick) {
   if (number instanceof import_series.Series) {
     const bars = number.bars;
     const valueArray = number.toArray();
-    const length = bars.length;
     if (mintick === void 0) {
       throw new Error(
         "math.round_to_mintick() requires mintick value. Either pass it explicitly or use createContext({ syminfo: { mintick } }) for implicit data."
       );
     }
     const result = [];
-    if (mintick === 0) {
-      for (let i = 0; i < length; i++) {
-        result.push(valueArray[i] ?? NaN);
-      }
-    } else {
-      for (let i = 0; i < length; i++) {
-        const v = valueArray[i];
-        if (v === void 0 || isNaN(v)) {
-          result.push(NaN);
-        } else {
-          result.push(Math.round(v / mintick) * mintick);
-        }
-      }
+    for (let i = 0; i < bars.length; i++) {
+      result.push(roundToTick(valueArray[i] ?? NaN, mintick));
     }
     return import_series.Series.fromArray(bars, result);
   }
@@ -429,13 +509,47 @@ function round_to_mintick(number, mintick) {
       "math.round_to_mintick() requires mintick value. Either pass it explicitly or use createContext({ syminfo: { mintick } }) for implicit data."
     );
   }
-  if (mintick === 0) {
-    return number;
-  }
-  return Math.round(number / mintick) * mintick;
+  return roundToTick(number, mintick);
+}
+function tickPair(mintick) {
+  for (let k = 0; k <= 15; k++) {
+    const pricescale = Number(`1e${k}`);
+    const scaled = mintick * pricescale;
+    const minmove = Math.round(scaled);
+    if (minmove >= 1 && Math.abs(scaled - minmove) <= 1e-9 * minmove) return [minmove, pricescale];
+  }
+  return null;
+}
+function roundToTick(number, mintick) {
+  if (!Number.isFinite(number)) return NaN;
+  if (mintick === 0) return number;
+  const pair = tickPair(mintick);
+  const negative = number < 0;
+  const magnitude = negative ? -number : number;
+  if (pair === null) {
+    const scaled2 = magnitude / mintick;
+    let units2 = Math.trunc(scaled2);
+    if (scaled2 - units2 >= 0.5) units2++;
+    return (negative ? 0 - units2 : units2) * mintick;
+  }
+  const [minmove, pricescale] = pair;
+  const scaled = magnitude * pricescale / minmove;
+  let units = Math.trunc(scaled);
+  const offset = scaled - units - 0.5;
+  const slack = 1e-6 + scaled * 18e-16;
+  if (-slack < offset && offset < slack) {
+    const [n, d] = exactRatio(magnitude);
+    const num = n * BigInt(pricescale);
+    const den = d * BigInt(minmove);
+    const whole = num / den;
+    units = Number(whole) + (reachesTie(num, den, whole) ? 1 : 0);
+  } else if (offset > 0) {
+    units++;
+  }
+  return (negative ? 0 - units : units) * minmove / pricescale;
 }
 const pi = Math.PI;
 const e = Math.E;
 const phi = 1.618033988749895;
-const rphi = 0.618033988749895;
+const rphi = 0.6180339887498948;
 //# sourceMappingURL=index.js.map