oakscriptjs 0.9.5 → 0.10.0

package/dist/esm/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,29 +528,36 @@ 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.
  *
@@ -545,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
@@ -564,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/esm/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/esm/math/index.js

@@ -8,14 +8,15 @@
  *
  * 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 { Series } from '../runtime/series.js';
-import { runningSum } from '../ta/running-sum.js';
+import { runningSum, runningSumSeries } from '../ta/running-sum.js';
 export function abs(value) {
     if (value instanceof Series) {
         const bars = value.bars;
@@ -62,28 +63,118 @@ export function round(value, precision) {
     if (value instanceof Series) {
         const bars = value.bars;
         const valueArray = value.toArray();
-        const length = bars.length;
         const result = [];
-        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);
-    }
-    const multiplier = Math.pow(10, precision);
-    return Math.round(value * multiplier) / multiplier;
+    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) {
+    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, den, units) {
+    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) {
+    return Number.isInteger(p) ? Number(`1e-${p}`) : Math.pow(10, -p);
+}
+/** PineScript math.round of one value (see `round`). */
+function roundValue(value, precision) {
+    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 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) {
+    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;
 }
 /**
  * Returns the maximum value from the arguments.
@@ -175,6 +266,8 @@ export function min(...values) {
  * - 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
@@ -188,8 +281,7 @@ export function avg(...values) {
     // Check if any value is a Series
     const hasSeries = values.some(v => v instanceof Series);
     if (!hasSeries) {
-        // All scalars - calculate simple average
-        return values.reduce((a, b) => a + b, 0) / values.length;
+        return avgOf(values);
     }
     // At least one Series - return a Series
     const firstSeries = values.find(v => v instanceof Series);
@@ -200,17 +292,36 @@ export function avg(...values) {
     const result = [];
     for (let i = 0; i < length; i++) {
         const nums = values.map((v, idx) => valueArrays[idx] ? valueArrays[idx][i] ?? NaN : v);
-        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) {
+    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;
+}
 export function sum(source, length) {
     // 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 = runningSum(sourceArray, length);
+    const result = 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) {
         return Series.fromArray(source.bars, result);
@@ -405,31 +516,60 @@ export function todegrees(radians) {
     }
     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) {
+    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 (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();
+/** Starts every seeded sequence of `math.random` again (called at the start of a script run). */
+export function resetRandom() {
+    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, max, _seed) {
-    // TODO: Implement deterministic seeding to match PineScript behavior
-    // Currently _seed parameter is ignored
+export function random(min, max, seed) {
+    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);
@@ -454,28 +594,13 @@ export function round_to_mintick(number, mintick) {
     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 = [];
-        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);
     }
@@ -487,15 +612,56 @@ export function round_to_mintick(number, mintick) {
         throw new Error('math.round_to_mintick() requires mintick value. ' +
             'Either pass it explicitly or use createContext({ syminfo: { mintick } }) for implicit data.');
     }
-    if (mintick === 0) {
+    return roundToTick(number, mintick);
+}
+/** `[minmove, pricescale]` of a mintick: pricescale is the smallest power of 10 (up to 1e15) giving an integer. */
+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;
+}
+/** PineScript math.round_to_mintick of one value (see `round_to_mintick`). */
+function roundToTick(number, mintick) {
+    if (!Number.isFinite(number))
+        return NaN;
+    if (mintick === 0)
         return number;
-    }
-    // Round to nearest tick
-    return Math.round(number / mintick) * mintick;
+    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
 //# sourceMappingURL=index.js.map