oakscriptjs 0.9.4 → 0.9.6

package/src/math/index.ts

@@ -8,16 +8,17 @@
  *
  * 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
  */
 
 import type { float, int, simple_int, series_float } from '../types/index.js';
 import { Series } from '../runtime/series.js';
-import { runningSum } from '../ta/running-sum.js';
+import { runningSum, runningSumSeries } from '../ta/running-sum.js';
 
 /**
  * Returns the absolute value of a number.
@@ -147,16 +148,23 @@ export function floor(value: float | Series): int | Series {
  * @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 function round(value: Series, precision?: int): Series;
@@ -165,30 +173,118 @@ export function round(value: float | Series, precision?: int): float | Series {
   if (value instanceof Series) {
     const bars = value.bars;
     const valueArray = value.toArray();
-    const length = bars.length;
-    
     const result: number[] = [];
-    if (precision === undefined) {
-      for (let i = 0; i < length; i++) {
-        const v = valueArray[i] ?? NaN;
-        result.push(Math.round(v));
-      }
-    } else {
-      const multiplier = Math.pow(10, precision);
-      for (let i = 0; i < length; i++) {
-        const v = valueArray[i] ?? NaN;
-        result.push(Math.round(v * multiplier) / multiplier);
-      }
+    for (let i = 0; i < bars.length; i++) {
+      result.push(roundValue(valueArray[i] ?? NaN, precision));
     }
-    
     return Series.fromArray(bars, result);
   }
-  
-  if (precision === undefined) {
-    return Math.round(value);
+  return roundValue(value, precision);
+}
+
+/** `0.5 - 1e-10` as the exact fraction TIE_HALF / TIE_SCALE: the tie threshold of round / round_to_mintick. */
+const TIE_SCALE = 10n ** 10n;
+const TIE_HALF = 5n * 10n ** 9n - 1n;
+/** From 2^52 up every double is an integer. */
+const INT_LIMIT = 2 ** 52;
+
+/** Exact value of a finite double >= 0 as `[numerator, denominator]`. */
+function exactRatio(x: number): [bigint, bigint] {
+  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) & 0x7ff;
+  let mantissa = (BigInt(hi & 0xfffff) << 32n) | BigInt(lo);
+  let exp = -1074;
+  if (expField !== 0) {
+    mantissa |= 1n << 52n;
+    exp = expField - 1075;
+  }
+  return exp >= 0 ? [mantissa << BigInt(exp), 1n] : [mantissa, 1n << BigInt(-exp)];
+}
+
+/** True when `num / den - units` (exact) is >= 0.5 - 1e-10. */
+function reachesTie(num: bigint, den: bigint, units: bigint): boolean {
+  return (num - units * den) * TIE_SCALE >= TIE_HALF * den;
+}
+
+/** `10^-p`: the exact literal for an integer p (correctly rounded), Math.pow otherwise. */
+function tenToMinus(p: number): number {
+  return Number.isInteger(p) ? Number(`1e-${p}`) : Math.pow(10, -p);
+}
+
+/** PineScript math.round of one value (see `round`). */
+function roundValue(value: number, precision?: number): number {
+  if (!Number.isFinite(value)) return NaN;
+  const negative = value < 0;
+  const magnitude = negative ? -value : value;
+  if (precision === undefined || Number.isNaN(precision) || precision <= 0) {
+    if (magnitude >= INT_LIMIT) return value;
+    let units = Math.floor(magnitude);
+    if (magnitude - units >= 0.5) units++;
+    return negative ? 0 - units : units;
+  }
+  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;
+  // Only a near-tie needs the exact product; the window covers the double's own error.
+  const slack = 1e-9 + scaled * 1.8e-15;
+  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 multiplier = Math.pow(10, precision);
-  return Math.round(value * multiplier) / multiplier;
+  const result = magnitude - fraction + units / scale;
+  return negative ? 0 - result : result;
+}
+
+/** 10^16: a constant keeps 16 decimals. */
+const CONSTANT_SCALE = 10n ** 16n;
+
+/**
+ * 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 function constant(value: float): float {
+  const magnitude = Math.abs(value);
+  // from 0.5 up, 16 decimals move a double by less than half its spacing: it stays the same
+  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;
 }
 
 /**
@@ -301,6 +397,8 @@ export 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
@@ -313,10 +411,9 @@ export function min(...values: (float | Series)[]): float | Series {
 export function avg(...values: (float | Series)[]): float | Series {
   // Check if any value is a Series
   const hasSeries = values.some(v => v instanceof Series);
-  
+
   if (!hasSeries) {
-    // All scalars - calculate simple average
-    return (values as number[]).reduce((a, b) => a + b, 0) / values.length;
+    return avgOf(values as number[]);
   }
   
   // At least one Series - return a Series
@@ -334,18 +431,35 @@ export function avg(...values: (float | Series)[]): float | Series {
     const nums = values.map((v, idx) => 
       valueArrays[idx] ? valueArrays[idx]![i] ?? NaN : (v as number)
     );
-    const sum = nums.reduce((a, b) => a + b, 0);
-    result.push(sum / nums.length);
+    result.push(avgOf(nums));
   }
-  
+
   return Series.fromArray(bars, result);
 }
 
+/** PineScript math.avg of numbers: plain sum up to 2 values, Kahan sum with the correction flushed from 3. */
+function avgOf(nums: number[]): number {
+  if (nums.length <= 2) {
+    let sum = 0;
+    for (const n of nums) sum = sum + n;
+    return sum / nums.length;
+  }
+  let sum = 0;
+  let c = 0;
+  for (const n of nums) {
+    const y = n - c;
+    const t = sum + y;
+    c = t - sum - y;
+    sum = t;
+  }
+  return (sum - c) / nums.length;
+}
+
 /**
  * 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
@@ -355,6 +469,11 @@ export 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
@@ -362,14 +481,20 @@ export function avg(...values: (float | Series)[]): float | Series {
  * // Explanation: [NaN, NaN, 1+2+3, 2+3+4, 3+4+5]
  * ```
  */
-export function sum(source: Series, length: simple_int): Series;
-export function sum(source: series_float, length: simple_int): series_float;
-export function sum(source: series_float | Series, length: simple_int): series_float | Series {
+export function sum(source: Series, length: simple_int | ArrayLike<number> | Series): Series;
+export function sum(source: series_float, length: simple_int | ArrayLike<number> | Series): series_float;
+export function sum(
+  source: series_float | Series,
+  length: simple_int | ArrayLike<number> | Series
+): series_float | Series {
   // Handle Series objects - extract to array first
   const sourceArray = source instanceof Series ? source.toArray() : source;
   // PineScript: the sum of the last `length` non-na values (also +/-Infinity skipped); an na bar keeps the previous
   // result. A compensated running sum, bit for bit as PineScript.
-  const result: series_float = runningSum(sourceArray, length);
+  const result: series_float =
+    typeof length === 'number'
+      ? runningSum(sourceArray, length)
+      : runningSumSeries(sourceArray, length instanceof Series ? length.toArray() : length, 'math.sum');
 
   // If input was a Series, return a Series
   if (source instanceof Series) {
@@ -916,31 +1041,63 @@ export function todegrees(radians: float | Series): float | Series {
   return radians * (180 / Math.PI);
 }
 
+/**
+ * PineScript's seeded generator: Java's linear congruential generator (`java.util.Random`), `nextDouble()`.
+ * Each generator draws one number per call.
+ */
+export function seededRandom(seed: int): (min?: float, max?: float) => float {
+  const mask = (1n << 48n) - 1n;
+  let state = (BigInt(Math.trunc(seed)) ^ 0x5deece66dn) & mask;
+  const next = (bits: bigint): bigint => {
+    state = (0x5deece66dn * state + 11n) & mask;
+    return state >> (48n - bits);
+  };
+  return (min = 0, max = 1) => {
+    const hi = next(26n);
+    const lo = next(27n);
+    const unit = Number((hi << 27n) + lo) / 2 ** 53;
+    return min + unit * (max - min);
+  };
+}
+
+const seeded = new Map<number, (min?: float, max?: float) => float>();
+
+/** Starts every seeded sequence of `math.random` again (called at the start of a script run). */
+export function resetRandom(): void {
+  seeded.clear();
+}
+
 /**
  * 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 function random(min?: float, max?: float, _seed?: int): float {
-  // TODO: Implement deterministic seeding to match PineScript behavior
-  // Currently _seed parameter is ignored
+export function random(min?: float, max?: float, seed?: int): float {
+  if (seed !== undefined && seed !== null && !Number.isNaN(seed)) {
+    let gen = seeded.get(seed);
+    if (!gen) {
+      gen = seededRandom(seed);
+      seeded.set(seed, gen);
+    }
+    return gen(min ?? 0, max ?? 1);
+  }
   const rand = Math.random();
   if (min !== undefined && max !== undefined) {
     return min + rand * (max - min);
@@ -952,12 +1109,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 +1125,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 +1139,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;
 }
 
 /**
@@ -1001,9 +1160,14 @@ export function sign(value: float | Series): int | Series {
  * - **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
@@ -1021,35 +1185,19 @@ export function round_to_mintick(number: float | Series, mintick?: float): float
   if (number instanceof Series) {
     const bars = number.bars;
     const valueArray = number.toArray();
-    const length = bars.length;
-    
     if (mintick === undefined) {
       throw new Error(
         'math.round_to_mintick() requires mintick value. ' +
         'Either pass it explicitly or use createContext({ syminfo: { mintick } }) for implicit data.'
       );
     }
-    
     const result: number[] = [];
-    if (mintick === 0) {
-      // No rounding needed
-      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 === undefined || 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 Series.fromArray(bars, result);
   }
-  
+
   // Scalar case
   if (isNaN(number)) {
     return NaN;
@@ -1061,17 +1209,53 @@ export function round_to_mintick(number: float | Series, mintick?: float): float
       'Either pass it explicitly or use createContext({ syminfo: { mintick } }) for implicit data.'
     );
   }
+  return roundToTick(number, mintick);
+}
 
-  if (mintick === 0) {
-    return number;
+/** `[minmove, pricescale]` of a mintick: pricescale is the smallest power of 10 (up to 1e15) giving an integer. */
+function tickPair(mintick: number): [number, number] | null {
+  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;
+}
 
-  // Round to nearest tick
-  return Math.round(number / mintick) * mintick;
+/** PineScript math.round_to_mintick of one value (see `round_to_mintick`). */
+function roundToTick(number: number, mintick: number): number {
+  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) {
+    // A tick that is no decimal fraction: the grid of the double mintick, ties away from zero.
+    const scaled = magnitude / mintick;
+    let units = Math.trunc(scaled);
+    if (scaled - units >= 0.5) units++;
+    return (negative ? 0 - units : units) * 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 * 1.8e-15;
+  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;
 }
 
 // Constants
 export const pi = Math.PI;
 export const e = Math.E;
 export const phi = 1.618033988749895; // Golden ratio
-export const rphi = 0.618033988749895; // Reciprocal of golden ratio
+export const rphi = 0.6180339887498948; // Reciprocal of golden ratio: 1 / phi

package/src/matrix/index.ts

@@ -61,6 +61,8 @@ export function new_matrix<T>(
  * ```
  */
 export function get<T>(id: PineMatrix<T>, row: simple_int, column: simple_int): T {
+  // PineScript: an na index gives na
+  if (Number.isNaN(row) || Number.isNaN(column)) return NaN as T;
   if (row < 0 || row >= id.rows || column < 0 || column >= id.columns) {
     throw new Error(`Matrix index out of bounds: [${row}, ${column}] for matrix of size [${id.rows}, ${id.columns}]`);
   }
@@ -92,6 +94,8 @@ export function get<T>(id: PineMatrix<T>, row: simple_int, column: simple_int):
  * ```
  */
 export function set<T>(id: PineMatrix<T>, row: simple_int, column: simple_int, value: T): void {
+  // PineScript: an na index changes nothing
+  if (Number.isNaN(row) || Number.isNaN(column)) return;
   if (row < 0 || row >= id.rows || column < 0 || column >= id.columns) {
     throw new Error(`Matrix index out of bounds: [${row}, ${column}] for matrix of size [${id.rows}, ${id.columns}]`);
   }
@@ -1884,15 +1888,8 @@ export function det(id: PineMatrix<float>): float {
     return 1; // Empty matrix has determinant 1 by convention
   }
 
-  if (n === 1) {
-    return id.data[0]![0]!;
-  }
-
-  if (n === 2) {
-    return id.data[0]![0]! * id.data[1]![1]! - id.data[0]![1]! * id.data[1]![0]!;
-  }
-
-  // LU decomposition with partial pivoting
+  // LU decomposition with partial pivoting, for every size (as PineScript: det([[0.1, 0.2], [0.3, 0.4]]) is
+  // -0.019999999999999993, not the closed form's -0.01999999999999999)
   // Make a copy to work with
   const a: float[][] = id.data.map(row => [...row]);
   let determinant = 1;
@@ -1918,9 +1915,10 @@ export function det(id: PineMatrix<float>): float {
       swapCount++;
     }
 
-    // If pivot is zero, determinant is zero
+    // As PineScript (LU with an absolute singularity threshold of 1e-11): det(1e-11 * I3) is 1e-33, a pivot below
+    // 1e-11 makes the determinant 0 (det([[1, 1], [1, 1 + 1e-12]]) and det([[1..9]]) are 0)
     const pivot = a[col]![col]!;
-    if (Math.abs(pivot) < EPSILON) {
+    if (Math.abs(pivot) < 1e-11) {
       return 0;
     }
 
@@ -2161,51 +2159,53 @@ export function rank(id: PineMatrix<float>): int {
   if (id.rows === 0 || id.columns === 0) {
     return 0;
   }
+  // As PineScript: the number of singular values above max(rows, columns) * largest * 2^-52 (rank([[1..9]]) is 2,
+  // rank(1e-11 * I3) is 3, rank([[1, 1], [1, 1 + 1e-12]]) is 2)
+  const s = singularValues(id.data);
+  const largest = Math.max(...s);
+  if (!(largest > 0)) return 0;
+  const tol = Math.max(id.rows, id.columns) * largest * 2 ** -52;
+  return s.filter((v) => v > tol).length;
+}
 
-  // Make a copy to work with
-  const a: float[][] = id.data.map(row => [...row]);
-  const m = id.rows;
-  const n = id.columns;
-
-  let r = 0; // Current rank (and current pivot row)
-
-  for (let col = 0; col < n && r < m; col++) {
-    // Find pivot
-    let maxRow = r;
-    let maxVal = Math.abs(a[r]![col]!);
-    for (let row = r + 1; row < m; row++) {
-      const absVal = Math.abs(a[row]![col]!);
-      if (absVal > maxVal) {
-        maxVal = absVal;
-        maxRow = row;
-      }
-    }
-
-    // Skip column if all values below are effectively zero
-    if (maxVal < EPSILON) {
-      continue;
-    }
-
-    // Swap rows if needed
-    if (maxRow !== r) {
-      const temp = a[r]!;
-      a[r] = a[maxRow]!;
-      a[maxRow] = temp;
-    }
-
-    // Eliminate below pivot
-    const pivot = a[r]![col]!;
-    for (let row = r + 1; row < m; row++) {
-      const factor = a[row]![col]! / pivot;
-      for (let j = col; j < n; j++) {
-        a[row]![j] = a[row]![j]! - factor * a[r]![j]!;
+/** Singular values of a matrix (one-sided Jacobi rotations on the columns; accurate for small values). */
+function singularValues(data: float[][]): float[] {
+  // work on the orientation with at least as many rows as columns
+  const tall = data.length >= (data[0]?.length ?? 0);
+  const a: float[][] = tall ? data.map((row) => [...row]) : data[0]!.map((_, j) => data.map((row) => row[j]!));
+  const m = a.length;
+  const n = a[0]!.length;
+  for (let sweep = 0; sweep < 60; sweep++) {
+    let rotated = false;
+    for (let p = 0; p < n - 1; p++) {
+      for (let q = p + 1; q < n; q++) {
+        let alpha = 0;
+        let beta = 0;
+        let gamma = 0;
+        for (let i = 0; i < m; i++) {
+          const x = a[i]![p]!;
+          const y = a[i]![q]!;
+          alpha += x * x;
+          beta += y * y;
+          gamma += x * y;
+        }
+        if (gamma === 0 || Math.abs(gamma) <= 1e-15 * Math.sqrt(alpha * beta)) continue;
+        rotated = true;
+        const zeta = (beta - alpha) / (2 * gamma);
+        const tan = Math.sign(zeta || 1) / (Math.abs(zeta) + Math.sqrt(1 + zeta * zeta));
+        const cos = 1 / Math.sqrt(1 + tan * tan);
+        const sin = cos * tan;
+        for (let i = 0; i < m; i++) {
+          const x = a[i]![p]!;
+          const y = a[i]![q]!;
+          a[i]![p] = cos * x - sin * y;
+          a[i]![q] = sin * x + cos * y;
+        }
       }
     }
-
-    r++;
+    if (!rotated) break;
   }
-
-  return r;
+  return Array.from({ length: n }, (_, j) => Math.sqrt(a.reduce((sum, row) => sum + row[j]! * row[j]!, 0)));
 }
 
 /**