oakscriptjs 0.11.1 → 0.11.3

package/dist/esm/ta/index.js

@@ -111,8 +111,7 @@ export function rsi(source, length) {
                 return 100;
             if (eq(x, 0))
                 return 0;
-            const r = 100 - 100 / (1 + x / y);
-            return Number.isFinite(r) ? r : NaN;
+            return 100 - 100 / (1 + x / y);
         });
     }
     checkPositiveLength('rsi', length, 0, 'y');
@@ -228,14 +227,14 @@ export function stdev(source, length, biased = true) {
     return varianceOf(source, length, biased, 'ta.stdev').map((v) => (Number.isNaN(v) ? NaN : v > 0 ? Math.sqrt(v) : 0));
 }
 /**
- * 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, i, length) {
     const values = [];
     for (let j = i; j >= 0 && values.length < length; j--) {
         const x = source[j];
-        if (!Number.isNaN(x))
+        if (Number.isFinite(x))
             values.push(x);
     }
     return values.length === length ? values : null;
@@ -294,7 +293,7 @@ function windowExtremes(source, length, lowest, newest = false) {
 /**
  * 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) {
     const values = [];
@@ -302,7 +301,7 @@ function keptValues(source) {
     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);
         }
@@ -798,9 +797,9 @@ export function wma(source, length) {
  * @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`).
@@ -817,9 +816,9 @@ export function highest(source, length) {
  * @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, length) {
     return extremeValue(source, length, true);
@@ -905,7 +904,7 @@ function monotonic(source, length, step) {
     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))
+        if (Number.isFinite(v) && Number.isFinite(prev))
             count = step(v, prev) ? count + 1 : 0;
         result.push(count >= length);
     }
@@ -922,8 +921,8 @@ function monotonic(source, length, step) {
  * 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
@@ -947,8 +946,8 @@ export function rising(source, length) {
  * 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
@@ -1125,7 +1124,7 @@ function varianceOf(source, length, biased, name) {
  * @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)
@@ -1164,7 +1163,7 @@ export function median(source, length) {
     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
@@ -1468,8 +1467,9 @@ export function cci(source, length) {
  * - 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
@@ -1483,14 +1483,14 @@ export function stoch(source, high, low, length) {
     const result = [];
     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);
     }
     return result;
@@ -1738,8 +1738,8 @@ function pivot(source, leftbars, rightbars, isHigh) {
  * - 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
  *
@@ -1772,8 +1772,8 @@ export function pivothigh(sourceOrLeftbars, leftbarsOrRightbars, rightbars, high
  * - 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
@@ -2267,7 +2267,7 @@ export function kcw(source, length = 20, mult = 2, useTrueRange = true, high, lo
  * (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, length) {
@@ -2282,9 +2282,9 @@ export function range(source, length) {
  * -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, length) {
     return extremeOffset(source, length, false);
@@ -2294,9 +2294,9 @@ export function highestbars(source, length) {
  * -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, length) {
     return extremeOffset(source, length, true);
@@ -2305,13 +2305,13 @@ export function lowestbars(source, length) {
  * 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) {
     let best = NaN;
     return source.map((x) => {
-        if (!Number.isNaN(x) && !(x <= best))
+        if (Number.isFinite(x) && !(x <= best))
             best = x;
         return best;
     });
@@ -2320,13 +2320,13 @@ export function max(source) {
  * 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) {
     let best = NaN;
     return source.map((x) => {
-        if (!Number.isNaN(x) && !(x >= best))
+        if (Number.isFinite(x) && !(x >= best))
             best = x;
         return best;
     });
@@ -2383,8 +2383,8 @@ export function cog(source, length = 10) {
  *
  * @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
  */
@@ -2395,7 +2395,7 @@ export function mode(source, length) {
     const seen = []; // non-na values so far
     for (let i = 0; i < source.length; i++) {
         const v = source[i];
-        if (!Number.isNaN(v))
+        if (Number.isFinite(v))
             seen.push(v);
         if (seen.length < len) {
             result.push(NaN);