oakscriptjs 0.11.0 → 0.11.2

package/src/ta/index.ts

@@ -11,7 +11,7 @@
 import type { series_float, series_bool, series_int, int, Source, simple_int, simple_float, simple_bool } from '../types/index.js';
 import { eq, ge, gt, le, lt } from '../compare/index.js';
 import { runningSum, runningSumSeries, runningVariance, runningVarianceSeries } from './running-sum.js';
-import { checkSumLength, checkWindowLength } from './limits.js';
+import { checkPositiveLength, checkSumLength, checkWindowLength } from './limits.js';
 
 /**
  * Simple Moving Average - returns the moving average (sum of last y values divided by y).
@@ -68,6 +68,7 @@ export function sma(source: Source, length: simple_int | ArrayLike<number>): ser
  * ```
  */
 export function ema(source: Source, length: simple_int): series_float {
+  checkPositiveLength('ema', length, 0);
   const result: series_float = [];
   const len = Math.floor(length);
   const multiplier = 2 / (len + 1);
@@ -133,7 +134,25 @@ export function ema(source: Source, length: simple_int): series_float {
  * const oversold = rsi14.map(v => v < 30);
  * ```
  */
-export function rsi(source: Source, length: simple_int): series_float {
+export function rsi(source: Source, length: simple_int): series_float;
+/**
+ * PineScript v4 `rsi(x, y)` with two series (#180): `x` and `y` are the averages of the upward and downward changes,
+ * already computed. As in PineScript: 100 when `y` is within 1e-10 of zero (also with an na `x`), else 0 when `x` is,
+ * else `100 - 100 / (1 + x / y)`: -Infinity when `x == -y` (#182), which `na()` and `nz()` treat as na while comparisons
+ * see it (`r < 30` is true). Versions 5 and 6 have the length form only.
+ */
+export function rsi(x: Source, y: Source): series_float;
+export function rsi(source: Source, length: simple_int | Source): series_float {
+  if (typeof length !== 'number') {
+    return Array.from(source, (xv, i) => {
+      const x = xv ?? NaN;
+      const y = length[i] ?? NaN;
+      if (eq(y, 0)) return 100;
+      if (eq(x, 0)) return 0;
+      return 100 - 100 / (1 + x / y);
+    });
+  }
+  checkPositiveLength('rsi', length, 0, 'y');
   const result: series_float = [];
 
   // Calculate price changes
@@ -274,14 +293,14 @@ export function stdev(
 }
 
 /**
- * The last `length` non-na values up to bar `i` (the bar itself may be na), or null when fewer exist.
- * `isNa` tells which values are skipped (NaN by default).
+ * The last `length` non-na values up to bar `i` (the bar itself may be na), or null when fewer exist. +/-Infinity
+ * counts as na (#183).
  */
 function lastValues(source: Source, i: number, length: number): number[] | null {
   const values: number[] = [];
   for (let j = i; j >= 0 && values.length < length; j--) {
     const x = source[j]!;
-    if (!Number.isNaN(x)) values.push(x);
+    if (Number.isFinite(x)) values.push(x);
   }
   return values.length === length ? values : null;
 }
@@ -342,7 +361,7 @@ function windowExtremes(
 /**
  * The non-na values of `source` with their bars, and for each bar the position of its last non-na value (-1 when
  * there is none yet). PineScript's ta.highest / ta.lowest / ta.highestbars / ta.lowestbars / ta.pivothigh /
- * ta.pivotlow keep the non-na values they receive and nothing else.
+ * ta.pivotlow keep the non-na values they receive and nothing else; +/-Infinity is skipped like na (#183).
  */
 function keptValues(source: Source): { values: number[]; bars: number[]; last: Int32Array } {
   const values: number[] = [];
@@ -350,7 +369,7 @@ function keptValues(source: Source): { values: number[]; bars: number[]; last: I
   const last = new Int32Array(source.length);
   for (let i = 0; i < source.length; i++) {
     const x = source[i]!;
-    if (!Number.isNaN(x)) {
+    if (Number.isFinite(x)) {
       values.push(x);
       bars.push(i);
     }
@@ -506,6 +525,7 @@ export function crossunder(series1: Source, series2: Source): series_bool {
  * ```
  */
 export function change(source: Source, length: simple_int = 1): series_float {
+  checkPositiveLength('change', length, 0);
   const result: series_float = [];
 
   for (let i = 0; i < source.length; i++) {
@@ -618,6 +638,7 @@ export function tr(
  * ```
  */
 export function atr(length: simple_int, high?: Source, low?: Source, close?: Source): series_float {
+  checkPositiveLength('atr->rma', length, 0);
   if (!high || !low || !close) {
     throw new Error(
       'ta.atr() requires high, low, and close series. ' +
@@ -763,6 +784,7 @@ export function supertrend(
  * ```
  */
 export function rma(source: Source, length: simple_int): series_float {
+  checkPositiveLength('rma', length, 0);
   const result: series_float = [];
   // Floor the length to match PineScript's auto-truncation of float to int
   const len = Math.floor(length);
@@ -846,6 +868,7 @@ export function wma(source: Source, length: simple_int | ArrayLike<number>): ser
   const result: series_float = [];
   // Floor the length to match PineScript's auto-truncation of float to int
   const fixed = typeof length === 'number' ? Math.floor(length) : NaN;
+  if (typeof length === 'number') checkPositiveLength('wma', fixed, 0);
   // PineScript: na on a bar with an na source (also +/-Infinity) and until `len` non-na values were received;
   // otherwise the last `len` bars, each na replaced by the previous non-na value
   const filled: number[] = [];
@@ -861,6 +884,7 @@ export function wma(source: Source, length: simple_int | ArrayLike<number>): ser
     filled.push(last);
     // a series length: the window of this bar's length (the result of ta.wma with that fixed length)
     const len = typeof length === 'number' ? fixed : Math.floor(length[i]!);
+    if (typeof length !== 'number') checkPositiveLength('wma', len, i);
     if (isNa || !(len >= 1) || count < len) {
       result.push(NaN);
       continue;
@@ -886,9 +910,9 @@ export function wma(source: Source, length: simple_int | ArrayLike<number>): ser
  * @returns Highest value series (na on the first `length - 1` bars)
  *
  * @remarks
- * As in PineScript: `na` values are skipped. The result is the highest of the last `length` non-na values (of all
- * of them when there are fewer), also on a bar whose own value is `na`; `na` before bar `length - 1` and while no
- * value was received. A fractional length is truncated (7.5 is 7 bars).
+ * As in PineScript: `na` values (also +/-Infinity, #183) are skipped. The result is the highest of the last `length`
+ * non-na values (of all of them when there are fewer), also on a bar whose own value is `na`; `na` before bar
+ * `length - 1` and while no value was received. A fractional length is truncated (7.5 is 7 bars).
  * `length` can be an array (a length per bar, PineScript series length), also for `ta.lowest`, `ta.highestbars`
  * and `ta.lowestbars`: each bar uses its own length.
  * A length above 15,000 throws the PineScript runtime error (also `ta.lowest`, `ta.highestbars`, `ta.lowestbars`).
@@ -906,9 +930,9 @@ export function highest(source: Source, length: simple_int | ArrayLike<number>):
  * @returns Lowest value series (na on the first `length - 1` bars)
  *
  * @remarks
- * As in PineScript: `na` values are skipped. The result is the lowest of the last `length` non-na values (of all
- * of them when there are fewer), also on a bar whose own value is `na`; `na` before bar `length - 1` and while no
- * value was received.
+ * As in PineScript: `na` values (also +/-Infinity, #183) are skipped. The result is the lowest of the last `length`
+ * non-na values (of all of them when there are fewer), also on a bar whose own value is `na`; `na` before bar
+ * `length - 1` and while no value was received.
  */
 export function lowest(source: Source, length: simple_int | ArrayLike<number>): series_float {
   return extremeValue(source, length, true);
@@ -994,7 +1018,7 @@ function monotonic(source: Source, length: simple_int, step: (newer: number, old
   for (let i = 0; i < source.length; i++) {
     const v = source[i]!;
     const prev = i > 0 ? source[i - 1]! : NaN;
-    if (!Number.isNaN(v) && !Number.isNaN(prev)) count = step(v, prev) ? count + 1 : 0;
+    if (Number.isFinite(v) && Number.isFinite(prev)) count = step(v, prev) ? count + 1 : 0;
     result.push(count >= length);
   }
   return result;
@@ -1011,8 +1035,8 @@ function monotonic(source: Source, length: simple_int, step: (newer: number, old
  * PineScript rules:
  * - a counter of rises from the previous bar (a rise is larger than the 1e-10 tolerance); a step that is not a rise
  *   resets it to 0
- * - a step from or to an `na` bar leaves the counter unchanged (so an `na` bar, and the bar after it, keep the
- *   result of the bar before the `na`)
+ * - a step from or to an `na` (or +/-Infinity) bar leaves the counter unchanged (so an `na` bar, and the bar after
+ *   it, keep the result of the bar before the `na`)
  * - true when the counter is at least `length` (false at the start)
  *
  * @example
@@ -1022,6 +1046,7 @@ function monotonic(source: Source, length: simple_int, step: (newer: number, old
  * ```
  */
 export function rising(source: Source, length: simple_int): series_bool {
+  checkPositiveLength('rising', length, 0);
   return monotonic(source, length, gt);
 }
 
@@ -1036,8 +1061,8 @@ export function rising(source: Source, length: simple_int): series_bool {
  * PineScript rules:
  * - a counter of falls from the previous bar (a fall is larger than the 1e-10 tolerance); a step that is not a fall
  *   resets it to 0
- * - a step from or to an `na` bar leaves the counter unchanged (so an `na` bar, and the bar after it, keep the
- *   result of the bar before the `na`)
+ * - a step from or to an `na` (or +/-Infinity) bar leaves the counter unchanged (so an `na` bar, and the bar after
+ *   it, keep the result of the bar before the `na`)
  * - true when the counter is at least `length` (false at the start)
  *
  * @example
@@ -1047,6 +1072,7 @@ export function rising(source: Source, length: simple_int): series_bool {
  * ```
  */
 export function falling(source: Source, length: simple_int): series_bool {
+  checkPositiveLength('falling', length, 0);
   return monotonic(source, length, lt);
 }
 
@@ -1072,6 +1098,7 @@ export function falling(source: Source, length: simple_int): series_bool {
  * ```
  */
 export function roc(source: Source, length: simple_int): series_float {
+  checkPositiveLength('roc', length, 0);
   const result: series_float = [];
 
   for (let i = 0; i < source.length; i++) {
@@ -1112,6 +1139,7 @@ export function roc(source: Source, length: simple_int): series_float {
  * ```
  */
 export function mom(source: Source, length: simple_int): series_float {
+  checkPositiveLength('mom', length, 0);
   const result: series_float = [];
 
   for (let i = 0; i < source.length; i++) {
@@ -1151,6 +1179,7 @@ export function mom(source: Source, length: simple_int): series_float {
  * ```
  */
 export function dev(source: Source, length: simple_int): series_float {
+  checkPositiveLength('dev', length, 0);
   const len = Math.floor(length);
   return sma(source, len).map((mean, i) => {
     if (i < len - 1 || Number.isNaN(mean)) return NaN;
@@ -1222,7 +1251,7 @@ function varianceOf(
  * @remarks
  * - Returns the middle value when values are sorted
  * - For an even length, returns the average of the two middle values
- * - As in PineScript: `na` values are skipped, the window holds the last `length` non-na values
+ * - As in PineScript: `na` values (also +/-Infinity) are skipped, the window holds the last `length` non-na values
  *   (going back as many bars as needed), and a bar whose own value is `na` still gets a result
  * - Returns NaN until `length` non-na values exist
  * - More robust to outliers than mean (SMA)
@@ -1234,6 +1263,7 @@ function varianceOf(
  * ```
  */
 export function median(source: Source, length: simple_int): series_float {
+  checkPositiveLength('median', length, 0);
   const len = Math.floor(length);
   const n = source.length;
   const out: series_float = new Array<number>(n).fill(NaN);
@@ -1257,7 +1287,7 @@ export function median(source: Source, length: simple_int): series_float {
   const mid = Math.floor(len / 2);
   for (let i = 0; i < n; i++) {
     const x = source[i]!;
-    if (!Number.isNaN(x)) {
+    if (Number.isFinite(x)) {
       kept[count++] = x;
       sorted.splice(bound(x, false), 0, x); // before the equal values: the newest first
       // the value leaving the window is the oldest, so the last of its equal values
@@ -1321,6 +1351,7 @@ export function swma(source: Source): series_float {
  * ```
  */
 export function vwma(source: Source, length: simple_int, volume?: Source): series_float {
+  checkPositiveLength('vwma->sma', length, 0);
   if (!volume) {
     throw new Error(
       'ta.vwma() requires volume series. ' +
@@ -1374,6 +1405,7 @@ export function vwma(source: Source, length: simple_int, volume?: Source): serie
  * ```
  */
 export function linreg(source: Source, length: simple_int, offset: simple_int = 0): series_float {
+  checkPositiveLength('linreg', length, 0);
   const result: series_float = [];
     // Floor the length to match PineScript's auto-truncation of float to int
     const len = Math.floor(length);
@@ -1443,6 +1475,7 @@ export function linreg(source: Source, length: simple_int, offset: simple_int =
  * ```
  */
 export function correlation(source1: Source, source2: Source, length: simple_int): series_float {
+  checkPositiveLength('correlation', length, 0);
   // PineScript: from compensated running sums, cov = sma(x * y) - sma(x) * sma(y), r = cov / sqrt(var(x) * var(y))
   // (biased variances); each running sum skips its own na values
   const product = Array.from({ length: source1.length }, (_, i) => {
@@ -1481,8 +1514,8 @@ export function correlation(source1: Source, source2: Source, length: simple_int
  *
  * PineScript rules:
  * - 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
+ * - a value from bar `length` on; an `na` value in the window counts as not `<=` the current value, and an `na`
+ *   current value gives 0 (#177)
  * - the comparison uses the 1e-10 tolerance
  *
  * @example
@@ -1493,15 +1526,16 @@ export function correlation(source1: Source, source2: Source, length: simple_int
  * ```
  */
 export function percentrank(source: Source, length: simple_int): series_float {
+  checkPositiveLength('percentrank', length, 0);
   const result: series_float = [];
 
   for (let i = 0; i < source.length; i++) {
     const currentValue = source[i]!;
-    if (i < length || Number.isNaN(currentValue)) {
+    if (i < length) {
       result.push(NaN);
       continue;
     }
-    // le() is false for an na value in the window
+    // le() is false for an na value in the window, and for all of them when the current value is na (0)
     let countLessOrEqual = 0;
     for (let j = 1; j <= length; j++) {
       if (le(source[i - j]!, currentValue)) countLessOrEqual++;
@@ -1541,6 +1575,7 @@ export function percentrank(source: Source, length: simple_int): series_float {
  * \`\`\`
  */
 export function cci(source: Source, length: simple_int): series_float {
+  checkPositiveLength('cci', length, 0);
   const smaValues = sma(source, length);
   const devValues = dev(source, length);
   let last = 0;
@@ -1566,8 +1601,9 @@ export function cci(source: Source, length: simple_int): series_float {
  * - Measures where close is relative to the high-low range
  * - Values above 80 typically indicate overbought
  * - Values below 20 typically indicate oversold
- * - As PineScript: when the source, \`highest(high, length)\` or \`lowest(low, length)\` is \`na\`, or the range is 0, the
- *   result is the previous result of the call (\`na\` until a first value)
+ * - As PineScript: when the source, \`highest(high, length)\` or \`lowest(low, length)\` is \`na\`, or the range and
+ *   \`source - lowest\` are both 0, the result is the previous result of the call (\`na\` until a first value); a zero
+ *   range with another source value gives +/-Infinity (plotted as \`na\`)
  *
  * @example
  * \`\`\`typescript
@@ -1577,17 +1613,18 @@ export function cci(source: Source, length: simple_int): series_float {
  * \`\`\`
  */
 export function stoch(source: Source, high: Source, low: Source, length: simple_int): series_float {
+  checkPositiveLength('stoch->highest', length, 0);
   const result: series_float = [];
   const lowestValues = lowest(low, length);
   const highestValues = highest(high, length);
 
-  // PineScript: an na input or a zero range keeps the previous result
+  // PineScript: an na (NaN) result keeps the previous one: an na input, or 0 / 0 on a zero range; a non-zero value
+  // over a zero range gives +/-Infinity (#183)
   let previous = NaN;
   for (let i = 0; i < source.length; i++) {
-    const value = source[i]!;
     const lo = lowestValues[i]!;
-    const range = highestValues[i]! - lo;
-    if (!Number.isNaN(value) && !Number.isNaN(range) && range !== 0) previous = (100 * (value - lo)) / range;
+    const k = (100 * (source[i]! - lo)) / (highestValues[i]! - lo);
+    if (!Number.isNaN(k)) previous = k;
     result.push(previous);
   }
 
@@ -1629,6 +1666,7 @@ export function stoch(source: Source, high: Source, low: Source, length: simple_
  * ```
  */
 export function mfi(source: Source, length: simple_int, volume?: Source): series_float {
+  checkPositiveLength('mfi', length, 0);
   if (!volume) {
     throw new Error(
       'ta.mfi() requires volume series. ' +
@@ -1687,6 +1725,7 @@ export function mfi(source: Source, length: simple_int, volume?: Source): series
  * ```
  */
 export function hma(source: Source, length: simple_int): series_float {
+  checkPositiveLength('hma', length, 0);
   const halfLength = Math.floor(length / 2);
   const sqrtLength = Math.floor(Math.sqrt(length));
 
@@ -1860,8 +1899,8 @@ function pivot(source: Source, leftbars: PivotLength, rightbars: PivotLength, is
  * - As in PineScript, the value appears `rightbars` bars after the pivot bar: the pivot bar
  *   index is `i - rightbars`
  * - A pivot high may equal values on its left but must be higher than all values on its right
- * - `na` values are skipped: the window is the last `leftbars + rightbars + 1` non-na values, and the highest of
- *   them must be on the bar `rightbars` bars back
+ * - `na` values (also +/-Infinity) are skipped: the window is the last `leftbars + rightbars + 1` non-na values,
+ *   and the highest of them must be on the bar `rightbars` bars back
  * - `leftbars` / `rightbars` can be arrays (a length per bar, PineScript series length), also for `ta.pivotlow`:
  *   each bar uses its own lengths
  *
@@ -1900,8 +1939,8 @@ export function pivothigh(
  * - As in PineScript, the value appears `rightbars` bars after the pivot bar: the pivot bar
  *   index is `i - rightbars`
  * - A pivot low may equal values on its left but must be lower than all values on its right
- * - `na` values are skipped: the window is the last `leftbars + rightbars + 1` non-na values, and the lowest of
- *   them must be on the bar `rightbars` bars back
+ * - `na` values (also +/-Infinity) are skipped: the window is the last `leftbars + rightbars + 1` non-na values,
+ *   and the lowest of them must be on the bar `rightbars` bars back
  *
  * @example
  * ```typescript
@@ -2093,6 +2132,7 @@ export function dmi(
  * ```
  */
 export function tsi(source: Source, shortLength: simple_int, longLength: simple_int): series_float {
+  checkPositiveLength('tsi->ema', shortLength, 0);
   const momentum: series_float = [];
 
   // Calculate momentum (price change)
@@ -2142,6 +2182,7 @@ export function tsi(source: Source, shortLength: simple_int, longLength: simple_
  * ```
  */
 export function cmo(source: Source, length: simple_int): series_float {
+  checkPositiveLength('cmo', length, 0);
   // 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.
@@ -2191,6 +2232,7 @@ export function kc(
   low?: Source,
   close?: Source
 ): [series_float, series_float, series_float] {
+  checkPositiveLength('kc', length, 0);
   // Calculate middle band (EMA of source)
   const middle = ema(source, length);
 
@@ -2250,6 +2292,7 @@ export function kc(
  * ```
  */
 export function bbw(source: Source, length: simple_int, mult: simple_float): series_float {
+  checkPositiveLength('bbw', length, 0);
   const [basis, upper, lower] = bb(source, length, mult);
   const result: series_float = [];
 
@@ -2293,6 +2336,7 @@ export function bbw(source: Source, length: simple_int, mult: simple_float): ser
  * ```
  */
 export function wpr(high: Source, low: Source, close: Source, length: simple_int = 14): series_float {
+  checkPositiveLength('wpr', length, 0);
   const highs = highest(high, length);
   const lows = lowest(low, length);
   return Array.from({ length: close.length }, (_, i) => {
@@ -2393,6 +2437,7 @@ export function alma(
   sigma: simple_float = 6,
   floor: boolean = false
 ): series_float {
+  checkPositiveLength('alma', length, 0);
   const result: series_float = [];
     const m = floor ? Math.floor(offset * (length - 1)) : offset * (length - 1);
   const s = length / sigma;
@@ -2485,10 +2530,11 @@ export function kcw(
  * (PineScript `ta.range(source, length)`).
  *
  * @remarks
- * As in PineScript: `na` values are skipped (the window holds the last `length` non-na
+ * As in PineScript: `na` values (also +/-Infinity) are skipped (the window holds the last `length` non-na
  * values), and a bar whose own value is `na` still gets a result.
  */
 export function range(source: Source, length: simple_int): series_float {
+  checkPositiveLength('range', length, 0);
   return source.map((_, i) => {
     const values = lastValues(source, i, length);
     return values ? Math.max(...values) - Math.min(...values) : NaN;
@@ -2500,9 +2546,9 @@ export function range(source: Source, length: simple_int): series_float {
  * -1 for the previous bar, and so on (as in PineScript, the offset is negative).
  *
  * @remarks
- * As in PineScript: the best of the last `length` non-na values, the newest one on equal values; the offset is the
- * distance in bars to its bar, so it is below `-(length - 1)` when `na` values were skipped. `na` before bar
- * `length - 1` and while no value was received; a fractional length is truncated.
+ * As in PineScript: the best of the last `length` non-na values (+/-Infinity skipped), the newest one on equal
+ * values; the offset is the distance in bars to its bar, so it is below `-(length - 1)` when `na` values were
+ * skipped. `na` before bar `length - 1` and while no value was received; a fractional length is truncated.
  */
 export function highestbars(source: Source, length: simple_int | ArrayLike<number>): series_int {
   return extremeOffset(source, length, false);
@@ -2513,9 +2559,9 @@ export function highestbars(source: Source, length: simple_int | ArrayLike<numbe
  * -1 for the previous bar, and so on (as in PineScript, the offset is negative).
  *
  * @remarks
- * As in PineScript: the best of the last `length` non-na values, the newest one on equal values; the offset is the
- * distance in bars to its bar, so it is below `-(length - 1)` when `na` values were skipped. `na` before bar
- * `length - 1` and while no value was received; a fractional length is truncated.
+ * As in PineScript: the best of the last `length` non-na values (+/-Infinity skipped), the newest one on equal
+ * values; the offset is the distance in bars to its bar, so it is below `-(length - 1)` when `na` values were
+ * skipped. `na` before bar `length - 1` and while no value was received; a fractional length is truncated.
  */
 export function lowestbars(source: Source, length: simple_int | ArrayLike<number>): series_int {
   return extremeOffset(source, length, true);
@@ -2525,13 +2571,13 @@ export function lowestbars(source: Source, length: simple_int | ArrayLike<number
  * All-time highest value of `source` up to each bar (PineScript `ta.max(source)`).
  *
  * @remarks
- * As in PineScript: `na` values are skipped, the value carries over `na` bars, and the
+ * As in PineScript: `na` values (also +/-Infinity) are skipped, the value carries over `na` bars, and the
  * result is `na` until the first non-na value.
  */
 export function max(source: Source): series_float {
   let best = NaN;
   return source.map((x) => {
-    if (!Number.isNaN(x) && !(x <= best)) best = x;
+    if (Number.isFinite(x) && !(x <= best)) best = x;
     return best;
   });
 }
@@ -2540,13 +2586,13 @@ export function max(source: Source): series_float {
  * All-time lowest value of `source` up to each bar (PineScript `ta.min(source)`).
  *
  * @remarks
- * As in PineScript: `na` values are skipped, the value carries over `na` bars, and the
+ * As in PineScript: `na` values (also +/-Infinity) are skipped, the value carries over `na` bars, and the
  * result is `na` until the first non-na value.
  */
 export function min(source: Source): series_float {
   let best = NaN;
   return source.map((x) => {
-    if (!Number.isNaN(x) && !(x >= best)) best = x;
+    if (Number.isFinite(x) && !(x >= best)) best = x;
     return best;
   });
 }
@@ -2574,6 +2620,7 @@ export function min(source: Source): series_float {
  * ```
  */
 export function cog(source: Source, length: simple_int = 10): series_float {
+  checkPositiveLength('cog', length, 0);
   const len = Math.floor(length);
   return runningSum(source, len).map((sum, i) => {
     if (i < len - 1 || Number.isNaN(sum) || sum === 0) return NaN;
@@ -2601,19 +2648,20 @@ export function cog(source: Source, length: simple_int = 10): series_float {
  *
  * @remarks
  * PineScript rules:
- * - the window is the last `length` non-`na` values (an `na` bar does not enter it, and gets the mode of the
- *   window it keeps)
+ * - the window is the last `length` non-`na` values (an `na` or +/-Infinity bar does not enter it, and gets the mode
+ *   of the window it keeps)
  * - NaN until `length` non-`na` values exist
  * - If no mode exists, returns the smallest value
  */
 export function mode(source: Source, length: simple_int): series_float {
+  checkPositiveLength('mode', length, 0);
   const result: series_float = [];
   const len = Math.floor(length);
   const seen: number[] = []; // non-na values so far
 
   for (let i = 0; i < source.length; i++) {
     const v = source[i]!;
-    if (!Number.isNaN(v)) seen.push(v);
+    if (Number.isFinite(v)) seen.push(v);
     if (seen.length < len) {
       result.push(NaN);
       continue;
@@ -2684,6 +2732,7 @@ export function percentile_linear_interpolation(
   length: simple_int,
   percentage: number
 ): series_float {
+  checkPositiveLength('percentile_linear_interpolation', length, 0);
   return sortedWindow(source, length, (s) => {
     const pos = (percentage / 100) * length - 0.5;
     if (pos <= 0) return s[0]!;
@@ -2753,6 +2802,7 @@ export function percentile_nearest_rank(
   length: simple_int,
   percentage: number
 ): series_float {
+  checkPositiveLength('percentile_nearest_rank', length, 0);
   const rank = Math.min(length, Math.max(1, Math.ceil((percentage / 100) * length)));
   return sortedWindow(source, length, (s) => s[rank - 1]!);
 }
@@ -2789,6 +2839,7 @@ export function percentile_nearest_rank(
  *   where the `na` was
  */
 export function rci(source: Source, length: simple_int): series_float {
+  checkPositiveLength('rci', length, 0);
   const len = Math.floor(length);
   const result: series_float = [];
   // PineScript keeps the values in a ring of `length + 1` slots indexed by the bar index, filled with 0 at the start
@@ -2852,31 +2903,42 @@ export function rci(source: Source, length: simple_int): series_float {
 }
 
 /**
- * Pivot Point Levels
+ * Pivot Point Levels (PineScript `ta.pivot_point_levels`).
  *
- * Calculates pivot point levels using various calculation methods.
- * Returns an array containing: [P, R1, S1, R2, S2, R3, S3, R4, S4, R5, S5]
+ * Returns 11 series: [P, R1, S1, R2, S2, R3, S3, R4, S4, R5, S5] (one value per bar in each).
  *
  * @param type - Calculation type: "Traditional", "Fibonacci", "Woodie", "Classic", "DM", "Camarilla"
- * @param anchor - Condition that triggers reset of calculations
- * @param developing - If true, pivots recalculate continuously; if false, use last anchor values
- * @param high - High price series (optional, uses context if not provided)
- * @param low - Low price series (optional, uses context if not provided)
- * @param close - Close price series (optional, uses context if not provided)
- * @param open - Open price series (optional, uses context if not provided)
- * @returns Array of 11 pivot levels
+ * @param anchor - Condition that starts a new period (`timeframe.change("W")`...)
+ * @param developing - false: the levels of the previous period, constant until the next anchor; true: the levels of
+ *   the current period so far, recalculated on each bar
+ * @param high - High price series
+ * @param low - Low price series
+ * @param close - Close price series
+ * @param open - Open price series (Woodie and DM)
+ * @returns 11 series of levels
  *
  * @example
  * ```typescript
  * const weekChange = [false, false, false, false, true, false, ...]; // Weekly anchor
- * const pivots = ta.pivot_point_levels("Traditional", weekChange, false, high, low, close);
- * // pivots[i]! = [P, R1, S1, R2, S2, R3, S3, R4, S4, R5, S5]
+ * const levels = ta.pivot_point_levels("Traditional", weekChange, false, high, low, close, open);
+ * // levels[0]![i] is P on bar i, levels[5]![i] is R3
  * ```
  *
  * @remarks
- * - Woodie type cannot use developing=true (will error in PineScript)
- * - DM type only calculates P, R1, S1 (other levels are NaN)
- * - All calculations follow PineScript v6 specifications
+ * As in PineScript (#177):
+ * - a period runs from an anchor bar to the bar before the next anchor; the bars before the first anchor are a
+ *   period too (from bar 0). The fixed levels use the high and low of the previous period and the close of the bar
+ *   before the anchor (na with an anchor on bar 0), and are na until the first anchor; the developing levels use
+ *   the current period's high and low and the bar's close, from bar 0
+ * - Traditional: R3 = P * 2 + (H - 2 * L), S3 = P * 2 - (2 * H - L), R4 = P * 3 + (H - 3 * L), S4 = P * 3 - (3 * H - L),
+ *   R5 = P * 4 + (H - 4 * L), S5 = P * 4 - (4 * H - L)
+ * - Fibonacci: P +- 0.382 / 0.618 / 1 * (H - L); R4 to S5 na
+ * - Classic: R3 / S3 = P +- 2 * (H - L), R4 / S4 = P +- 3 * (H - L); R5 / S5 na
+ * - Woodie: P = (H + L + 2 * open of the current period) / 4, R3 = H + 2 * (P - L), S3 = L - 2 * (H - P), R4 / S4 =
+ *   R3 + (H - L) / S3 - (H - L); R5 / S5 na. `developing` true throws (RE10128)
+ * - DM: x = H + 2 * L + C (C < open of the period), 2 * H + L + C (C > O) or H + L + 2 * C; P = x / 4,
+ *   R1 = x / 2 - L, S1 = x / 2 - H; the other levels na
+ * - Camarilla: C +- (H - L) * 1.1 / 12, / 6, / 4, / 2 for R1 to S4, R5 = (H / L) * C, S5 = 2 * C - R5
  */
 export function pivot_point_levels(
   type: series_float | string,
@@ -2887,183 +2949,96 @@ export function pivot_point_levels(
   close?: Source,
   open?: Source
 ): series_float[] {
-  // For simplicity, we need to handle the case where type is a string array
-  // But according to the docs, type is "series string", meaning it can change per bar
-  // For this implementation, we'll support constant type strings
-
   const typeStr = typeof type === 'string' ? type : String(type[0]);
-  const isDeveloping = typeof developing === 'boolean' ? developing : developing[0];
-
-  // Woodie cannot be developing
+  const isDeveloping = typeof developing === 'boolean' ? developing : Boolean(developing[0]);
   if (typeStr === 'Woodie' && isDeveloping) {
-    throw new Error('ta.pivot_point_levels: Woodie type cannot use developing=true');
+    throw new Error(
+      'Error on bar 0: The `developing` parameter of the `ta.pivot_point_levels()` cannot be `true` when `type` is "Woodie".'
+    );
   }
-
-  // Ensure all series have the same length
-  const length = anchor.length;
-  if (high && high.length !== length) throw new Error('High series length mismatch');
-  if (low && low.length !== length) throw new Error('Low series length mismatch');
-  if (close && close.length !== length) throw new Error('Close series length mismatch');
-  if (open && open.length !== length) throw new Error('Open series length mismatch');
-
-  // Initialize result arrays for all 11 levels
-  const results: series_float[] = Array.from({ length: 11 }, () => []);
-
-  // Track the last anchor point data
-  let lastH = NaN, lastL = NaN, lastC = NaN, lastO = NaN;
-  let lastAnchorIndex = -1;
-
-  for (let i = 0; i < length; i++) {
-    // Check if anchor triggered
-    if (anchor[i]!) {
-      lastAnchorIndex = i;
-      // Store OHLC at anchor point (these will be used for calculations)
-      lastH = high ? high[i]! : NaN;
-      lastL = low ? low[i]! : NaN;
-      lastC = close ? close[i]! : NaN;
-      lastO = open ? open[i]! : NaN;
-    }
-
-    // Calculate data to use
-    let h: number, l: number, c: number, o: number;
-
-    if (isDeveloping && lastAnchorIndex >= 0) {
-      // Developing: use max/min/last since anchor
-      h = high ? Math.max(...high.slice(lastAnchorIndex, i + 1).filter(v => !isNaN(v))) : NaN;
-      l = low ? Math.min(...low.slice(lastAnchorIndex, i + 1).filter(v => !isNaN(v))) : NaN;
-      c = close ? close[i]! : NaN;
-      o = open && lastAnchorIndex >= 0 ? open[lastAnchorIndex]! : NaN;
-    } else {
-      // Not developing: use last anchor values
-      h = lastH;
-      l = lastL;
-      c = lastC;
-      o = lastO;
-    }
-
-    // Calculate pivot levels based on type
-    const levels = calculatePivotLevels(typeStr, h, l, c, o);
-
-    // Push to results
-    for (let j = 0; j < 11; j++) {
-      results[j]!.push(levels[j]!);
-    }
+  const n = anchor.length;
+  for (const [s, name] of [[high, 'High'], [low, 'Low'], [close, 'Close'], [open, 'Open']] as const) {
+    if (s && s.length !== n) throw new Error(`${name} series length mismatch`);
+  }
+  const at = (s: Source | undefined, i: number): number => (s ? (s[i] ?? NaN) : NaN);
+  const results: series_float[] = Array.from({ length: 11 }, () => new Array<number>(n));
+  // the current period (from bar 0 until the first anchor) and the previous one
+  let curH = NaN, curL = NaN, curO = NaN;
+  let prevH = NaN, prevL = NaN, prevC = NaN, prevO = NaN;
+  let anchored = false;
+  for (let i = 0; i < n; i++) {
+    const h = at(high, i), l = at(low, i);
+    if (i === 0) {
+      // the first period starts on bar 0: an anchor there makes bar 0 its own previous period
+      curH = h;
+      curL = l;
+      curO = at(open, i);
+    }
+    if (anchor[i]) {
+      prevH = curH;
+      prevL = curL;
+      prevC = i > 0 ? at(close, i - 1) : NaN;
+      prevO = curO;
+      curH = h;
+      curL = l;
+      curO = at(open, i);
+      anchored = true;
+    } else if (i > 0) {
+      if (h > curH || Number.isNaN(curH)) curH = h;
+      if (l < curL || Number.isNaN(curL)) curL = l;
+    }
+    const levels = isDeveloping
+      ? pivotLevels(typeStr, curH, curL, at(close, i), curO, at(close, i))
+      : anchored
+        ? pivotLevels(typeStr, prevH, prevL, prevC, prevO, curO)
+        : NA_LEVELS;
+    for (let k = 0; k < 11; k++) results[k]![i] = levels[k]!;
   }
-
   return results;
 }
 
+const NA_LEVELS: readonly number[] = new Array<number>(11).fill(NaN);
+
 /**
- * Helper function to calculate pivot levels
+ * The 11 levels of one bar, in PineScript's operation order (bit for bit). `o` is the open of the period (DM),
+ * `wo` the close term of Woodie (the open of the current period, or the bar's close while developing).
  */
-function calculatePivotLevels(
-  type: string,
-  h: number,
-  l: number,
-  c: number,
-  o: number
-): number[] {
-  // Return NaN array if data is insufficient
-  if (isNaN(h) || isNaN(l) || isNaN(c)) {
-    return Array(11).fill(NaN);
-  }
-
-  const levels: number[] = Array(11).fill(NaN);
-
-  // Calculate pivot point (P)
-  let P: number;
-
-  switch (type) {
-    case 'Traditional':
-    case 'Fibonacci':
-    case 'Classic':
-      P = (h + l + c) / 3;
-      break;
-    case 'Woodie':
-      P = (h + l + 2 * c) / 4;
-      break;
-    case 'DM':
-      P = (h + l + c) / 3;
-      break;
-    case 'Camarilla':
-      P = (h + l + c) / 3;
-      break;
-    default:
-      P = (h + l + c) / 3;
-  }
-
-  levels[0] = P; // P is at index 0
-
-  // Calculate resistance and support levels based on type
+function pivotLevels(type: string, h: number, l: number, c: number, o: number, wo: number): readonly number[] {
+  const N = NaN;
+  const r = h - l;
   switch (type) {
-    case 'Traditional':
-    case 'Classic':
-      levels[1] = 2 * P - l;  // R1
-      levels[2] = 2 * P - h;  // S1
-      levels[3] = P + (h - l);  // R2
-      levels[4] = P - (h - l);  // S2
-      levels[5] = h + 2 * (P - l);  // R3
-      levels[6] = l - 2 * (h - P);  // S3
-      levels[7] = levels[5] + (h - l);  // R4
-      levels[8] = levels[6] - (h - l);  // S4
-      levels[9] = levels[7] + (h - l);  // R5
-      levels[10] = levels[8] - (h - l);  // S5
-      break;
-
-    case 'Fibonacci':
-      levels[1] = P + 0.382 * (h - l);  // R1
-      levels[2] = P - 0.382 * (h - l);  // S1
-      levels[3] = P + 0.618 * (h - l);  // R2
-      levels[4] = P - 0.618 * (h - l);  // S2
-      levels[5] = P + (h - l);  // R3
-      levels[6] = P - (h - l);  // S3
-      levels[7] = levels[5] + 0.618 * (h - l);  // R4
-      levels[8] = levels[6] - 0.618 * (h - l);  // S4
-      levels[9] = levels[7] + 0.382 * (h - l);  // R5
-      levels[10] = levels[8] - 0.382 * (h - l);  // S5
-      break;
-
-    case 'Woodie':
-      levels[1] = 2 * P - l;  // R1
-      levels[2] = 2 * P - h;  // S1
-      levels[3] = P + (h - l);  // R2
-      levels[4] = P - (h - l);  // S2
-      levels[5] = h + 2 * (P - l);  // R3
-      levels[6] = l - 2 * (h - P);  // S3
-      levels[7] = levels[5] + (h - l);  // R4
-      levels[8] = levels[6] - (h - l);  // S4
-      levels[9] = levels[7] + (h - l);  // R5
-      levels[10] = levels[8] - (h - l);  // S5
-      break;
-
+    case 'Traditional': {
+      const p = (h + l + c) / 3;
+      return [p, 2 * p - l, 2 * p - h, p + r, p - r, p * 2 + (h - 2 * l), p * 2 - (2 * h - l), p * 3 + (h - 3 * l),
+        p * 3 - (3 * h - l), p * 4 + (h - 4 * l), p * 4 - (4 * h - l)];
+    }
+    case 'Fibonacci': {
+      const p = (h + l + c) / 3;
+      return [p, p + 0.382 * r, p - 0.382 * r, p + 0.618 * r, p - 0.618 * r, p + 1 * r, p - 1 * r, N, N, N, N];
+    }
+    case 'Classic': {
+      const p = (h + l + c) / 3;
+      return [p, 2 * p - l, 2 * p - h, p + r, p - r, p + 2 * r, p - 2 * r, p + 3 * r, p - 3 * r, N, N];
+    }
+    case 'Woodie': {
+      const p = (h + l + 2 * wo) / 4;
+      const r3 = h + 2 * (p - l);
+      const s3 = l - 2 * (h - p);
+      return [p, 2 * p - l, 2 * p - h, p + r, p - r, r3, s3, r3 + r, s3 - r, N, N];
+    }
     case 'DM': {
-      // DM (Demark) only calculates P, R1, S1
-      const x = h + l + (c * 2) + (isNaN(o) ? c : o);
-      const newP = x / (isNaN(o) ? 4 : 5);
-      levels[0] = newP;
-      levels[1] = x / 2 - l;  // R1
-      levels[2] = x / 2 - h;  // S1
-      // R2-S5 remain NaN
-      break;
+      const x = c < o ? h + 2 * l + c : c > o ? 2 * h + l + c : h + l + 2 * c;
+      return [x / 4, x / 2 - l, x / 2 - h, N, N, N, N, N, N, N, N];
     }
-
     case 'Camarilla': {
-      const range = h - l;
-      levels[1] = c + range * 1.1 / 12;  // R1
-      levels[2] = c - range * 1.1 / 12;  // S1
-      levels[3] = c + range * 1.1 / 6;   // R2
-      levels[4] = c - range * 1.1 / 6;   // S2
-      levels[5] = c + range * 1.1 / 4;   // R3
-      levels[6] = c - range * 1.1 / 4;   // S3
-      levels[7] = c + range * 1.1 / 2;   // R4
-      levels[8] = c - range * 1.1 / 2;   // S4
-      levels[9] = h;  // R5 (high)
-      levels[10] = l; // S5 (low)
-      break;
+      const p = (h + l + c) / 3;
+      const r5 = (h / l) * c;
+      return [p, c + (r * 1.1) / 12, c - (r * 1.1) / 12, c + (r * 1.1) / 6, c - (r * 1.1) / 6, c + (r * 1.1) / 4,
+        c - (r * 1.1) / 4, c + (r * 1.1) / 2, c - (r * 1.1) / 2, r5, 2 * c - r5];
     }
+    default:
+      return NA_LEVELS;
   }
-
-  return levels;
 }
 
 /**