oakscriptjs 0.9.5 → 0.9.6

package/dist/cjs/ta/index.js

@@ -92,18 +92,13 @@ module.exports = __toCommonJS(ta_exports);
 var import_compare = require("../compare/index.js");
 var import_running_sum = require("./running-sum.js");
 function sma(source, length) {
+  if (typeof length !== "number") {
+    const sums = (0, import_running_sum.runningSumSeries)(source, length, "ta.sma");
+    return sums.map((sum, i) => sum / Math.floor(length[i]));
+  }
   const len = Math.floor(length);
   return (0, import_running_sum.runningSum)(source, len).map((sum) => sum / len);
 }
-function strictWindowMean(source, length) {
-  const len = Math.floor(length);
-  return Array.from({ length: source.length }, (_, i) => {
-    if (i < len - 1) return NaN;
-    let sum = 0;
-    for (let j = 0; j < len; j++) sum += source[i - j];
-    return sum / len;
-  });
-}
 function ema(source, length) {
   const result = [];
   const len = Math.floor(length);
@@ -185,7 +180,7 @@ function bb(series, length, mult) {
   return [basis, upper, lower];
 }
 function stdev(source, length, biased = true) {
-  return variance(source, length, biased).map((v) => Number.isNaN(v) ? NaN : v > 0 ? Math.sqrt(v) : 0);
+  return varianceOf(source, length, biased, "ta.stdev").map((v) => Number.isNaN(v) ? NaN : v > 0 ? Math.sqrt(v) : 0);
 }
 function lastValues(source, i, length) {
   const values = [];
@@ -365,20 +360,15 @@ function rma(source, length) {
   const len = Math.floor(length);
   let firstValidIndex = -1;
   let validCount = 0;
-  let initSum = 0;
   for (let i = 0; i < source.length; i++) {
     const val = source[i];
-    if (val !== void 0 && Number.isFinite(val)) {
-      initSum += val;
-      validCount++;
-      if (validCount === len) {
-        firstValidIndex = i;
-        break;
-      }
+    if (val !== void 0 && Number.isFinite(val) && ++validCount === len) {
+      firstValidIndex = i;
+      break;
     }
   }
-  let rmaValue = validCount > 0 ? initSum / validCount : NaN;
   const rmaInitialized = firstValidIndex >= 0;
+  let rmaValue = rmaInitialized ? (0, import_running_sum.runningSum)(source.slice(0, firstValidIndex + 1), len)[firstValidIndex] / len : NaN;
   for (let i = 0; i < source.length; i++) {
     if (!rmaInitialized || i < firstValidIndex) {
       result.push(NaN);
@@ -396,6 +386,10 @@ function rma(source, length) {
   }
   return result;
 }
+function wmaAdd(a, b) {
+  const sum = a + b;
+  return Math.abs(sum) <= 1e-10 * Math.max(1, Math.abs(a) + Math.abs(b)) ? 0 : sum;
+}
 function wma(source, length) {
   const result = [];
   const len = Math.floor(length);
@@ -418,7 +412,7 @@ function wma(source, length) {
     let weightSum = 0;
     for (let j = len - 1; j >= 0; j--) {
       const weight = len - j;
-      sum += filled[i - j] * weight;
+      sum = wmaAdd(sum, filled[i - j] * weight);
       weightSum += weight;
     }
     result.push(sum / weightSum);
@@ -440,18 +434,29 @@ function cum(source) {
   });
 }
 function cross(source1, source2) {
-  return crossTest(source1, source2, (a, b, pa, pb) => a > b && pa <= pb || a < b && pa >= pb);
+  const result = [];
+  let side = 0;
+  for (let i = 0; i < source1.length; i++) {
+    const a = source1[i];
+    const b = source2[i];
+    if (Number.isNaN(a) || Number.isNaN(b)) {
+      result.push(false);
+      continue;
+    }
+    result.push(side < 0 && a > b || side > 0 && a < b);
+    if (a < b) side = -1;
+    else if (a > b) side = 1;
+  }
+  return result;
 }
 function monotonic(source, length, step) {
   const result = [];
-  const values = [];
+  let count = 0;
   for (let i = 0; i < source.length; i++) {
     const v = source[i];
-    if (!Number.isNaN(v)) values.push(v);
-    const n = values.length;
-    let ok = n > length;
-    for (let j = 1; ok && j <= length; j++) ok = step(values[n - j], values[n - j - 1]);
-    result.push(ok);
+    const prev = i > 0 ? source[i - 1] : NaN;
+    if (!Number.isNaN(v) && !Number.isNaN(prev)) count = step(v, prev) ? count + 1 : 0;
+    result.push(count >= length);
   }
   return result;
 }
@@ -494,24 +499,22 @@ function mom(source, length) {
   return result;
 }
 function dev(source, length) {
-  const result = [];
-  const meanValues = strictWindowMean(source, length);
-  for (let i = 0; i < source.length; i++) {
-    if (i < length - 1 || isNaN(meanValues[i])) {
-      result.push(NaN);
-    } else {
-      let sum = 0;
-      for (let j = 0; j < length; j++) {
-        if (!isNaN(source[i - j])) {
-          sum += Math.abs(source[i - j] - meanValues[i]);
-        }
-      }
-      result.push(sum / length);
-    }
-  }
-  return result;
+  const len = Math.floor(length);
+  return sma(source, len).map((mean, i) => {
+    if (i < len - 1 || Number.isNaN(mean)) return NaN;
+    let sum = 0;
+    for (let k = 0; k < len; k++) sum += Math.abs(source[i - k] - mean);
+    return sum / len;
+  });
 }
 function variance(source, length, biased = true) {
+  return varianceOf(source, length, biased, "ta.variance");
+}
+function varianceOf(source, length, biased, name) {
+  if (typeof length !== "number") {
+    const result = (0, import_running_sum.runningVarianceSeries)(source, length, biased, name);
+    return biased ? result : result.map((v, i) => Math.floor(length[i]) > 1 ? v : NaN);
+  }
   const len = Math.floor(length);
   if ((biased ? len : len - 1) <= 0) return source.map(() => NaN);
   return (0, import_running_sum.runningVariance)(source, len, biased);
@@ -547,20 +550,10 @@ function median(source, length) {
   return out;
 }
 function swma(source) {
-  const result = [];
-  for (let i = 0; i < source.length; i++) {
-    if (i < 3) {
-      result.push(NaN);
-    } else {
-      if (isNaN(source[i]) || isNaN(source[i - 1]) || isNaN(source[i - 2]) || isNaN(source[i - 3])) {
-        result.push(NaN);
-      } else {
-        const value = source[i - 3] * (1 / 6) + source[i - 2] * (2 / 6) + source[i - 1] * (2 / 6) + source[i] * (1 / 6);
-        result.push(value);
-      }
-    }
-  }
-  return result;
+  return Array.from(
+    { length: source.length },
+    (_, i) => i < 3 ? NaN : (source[i] + 2 * source[i - 1] + 2 * source[i - 2] + source[i - 3]) / 6
+  );
 }
 function vwma(source, length, volume) {
   if (!volume) {
@@ -606,68 +599,39 @@ function linreg(source, length, offset = 0) {
         let sumXY = 0;
         let sumX2 = 0;
         for (let j = 0; j < len; j++) {
-          const x2 = j;
+          const x = j + 1;
           const y = source[i - (len - 1 - j)];
-          sumX += x2;
+          sumX += x;
           sumY += y;
-          sumXY += x2 * y;
-          sumX2 += x2 * x2;
+          sumXY += x * y;
+          sumX2 += x * x;
         }
         const slope = (len * sumXY - sumX * sumY) / (len * sumX2 - sumX * sumX);
-        const intercept = (sumY - slope * sumX) / len;
-        const x = len - 1 - offset;
-        result.push(intercept + slope * x);
+        const intercept = sumY / len - slope * sumX / len + slope;
+        result.push(intercept + slope * (len - 1 - offset));
       }
     }
   }
   return result;
 }
 function correlation(source1, source2, length) {
-  const result = [];
-  const span = length > 0 ? Math.ceil(length) : 0;
-  const a = new Float64Array(span);
-  const b = new Float64Array(span);
-  for (let i = 0; i < source1.length; i++) {
-    if (i < length - 1) {
-      result.push(NaN);
-      continue;
-    }
-    let m = 0;
-    for (let j = 0; j < length; j++) {
-      const v1 = source1[i - j];
-      const v2 = source2[i - j];
-      if (!isNaN(v1) && !isNaN(v2)) {
-        a[m] = v1;
-        b[m] = v2;
-        m++;
-      }
-    }
-    if (m === 0) {
-      result.push(NaN);
-      continue;
-    }
-    let sum1 = 0;
-    let sum2 = 0;
-    for (let k = 0; k < m; k++) {
-      sum1 += a[k];
-      sum2 += b[k];
-    }
-    const mean1 = sum1 / m;
-    const mean2 = sum2 / m;
-    let numerator = 0;
-    let sum1Sq = 0;
-    let sum2Sq = 0;
-    for (let k = 0; k < m; k++) {
-      const dev1 = a[k] - mean1;
-      const dev2 = b[k] - mean2;
-      numerator += dev1 * dev2;
-      sum1Sq += dev1 * dev1;
-      sum2Sq += dev2 * dev2;
-    }
-    const denominator = Math.sqrt(sum1Sq * sum2Sq);
-    result.push(denominator === 0 ? NaN : numerator / denominator);
-  }
-  return result;
+  const product = Array.from({ length: source1.length }, (_, i) => {
+    const v1 = source1[i];
+    const v2 = source2[i];
+    return v1 === null || v1 === void 0 || v2 === null || v2 === void 0 ? NaN : v1 * v2;
+  });
+  const meanXY = sma(product, length);
+  const meanX = sma(source1, length);
+  const meanY = sma(source2, length);
+  const varX = variance(source1, length);
+  const varY = variance(source2, length);
+  return meanXY.map((mxy, i) => {
+    const cov = mxy - meanX[i] * meanY[i];
+    if (Number.isNaN(cov)) return NaN;
+    if (Math.abs(cov) <= 1e-10) return 0;
+    const denominator = Math.sqrt(varX[i] * varY[i]);
+    return denominator === 0 ? NaN : cov / denominator;
+  });
 }
 function percentrank(source, length) {
   const result = [];
@@ -686,37 +650,27 @@ function percentrank(source, length) {
   return result;
 }
 function cci(source, length) {
-  const result = [];
   const smaValues = sma(source, length);
   const devValues = dev(source, length);
-  for (let i = 0; i < source.length; i++) {
-    if (isNaN(smaValues[i]) || isNaN(devValues[i])) {
-      result.push(NaN);
-    } else if ((0, import_compare.eq)(devValues[i], 0)) {
-      result.push(i > 0 ? result[i - 1] : NaN);
-    } else {
-      const cci2 = (source[i] - smaValues[i]) / (0.015 * devValues[i]);
-      result.push(cci2);
-    }
-  }
-  return result;
+  let last = 0;
+  return smaValues.map((mean, i) => {
+    const d = devValues[i];
+    if (Number.isNaN(mean) || Number.isNaN(d)) return NaN;
+    if (!(0, import_compare.eq)(d, 0)) last = (source[i] - mean) / (0.015 * d);
+    return last;
+  });
 }
 function stoch(source, high, low, length) {
   const result = [];
   const lowestValues = lowest(low, length);
   const highestValues = highest(high, length);
+  let previous = NaN;
   for (let i = 0; i < source.length; i++) {
-    if (isNaN(lowestValues[i]) || isNaN(highestValues[i])) {
-      result.push(NaN);
-    } else {
-      const range2 = highestValues[i] - lowestValues[i];
-      if (range2 === 0) {
-        result.push(NaN);
-      } else {
-        const stochValue = 100 * (source[i] - lowestValues[i]) / range2;
-        result.push(stochValue);
-      }
-    }
+    const value = source[i];
+    const lo = lowestValues[i];
+    const range2 = highestValues[i] - lo;
+    if (!Number.isNaN(value) && !Number.isNaN(range2) && range2 !== 0) previous = 100 * (value - lo) / range2;
+    result.push(previous);
   }
   return result;
 }
@@ -736,11 +690,14 @@ function mfi(source, length, volume) {
   }
   const upper = (0, import_running_sum.runningSum)(upperFlow, length);
   const lower = (0, import_running_sum.runningSum)(lowerFlow, length);
-  return upper.map((u, i) => {
-    const l = lower[i];
+  const zero = (x) => Math.abs(x) <= 1e-10 ? 0 : x;
+  return upper.map((sumUp, i) => {
+    const u = zero(sumUp);
+    const l = zero(lower[i]);
     if (Number.isNaN(u) || Number.isNaN(l)) return NaN;
     if (l === 0) return 100;
-    return 100 - 100 / (1 + u / l);
+    const ratio = 1 + u / l;
+    return ratio === 0 ? NaN : 100 - 100 / ratio;
   });
 }
 function hma(source, length) {
@@ -945,15 +902,10 @@ function tsi(source, shortLength, longLength) {
   const smoothedMomentum = ema(ema(momentum, longLength), shortLength);
   const absMomentum = momentum.map(Math.abs);
   const smoothedAbsMomentum = ema(ema(absMomentum, longLength), shortLength);
-  const result = [];
-  for (let i = 0; i < source.length; i++) {
-    if (smoothedAbsMomentum[i] === 0) {
-      result.push(0);
-    } else {
-      result.push(smoothedMomentum[i] / smoothedAbsMomentum[i] * 100);
-    }
-  }
-  return result;
+  return smoothedMomentum.map((m, i) => {
+    const d = smoothedAbsMomentum[i];
+    return d === 0 ? NaN : m / d;
+  });
 }
 function cmo(source, length) {
   const up = [];
@@ -1007,27 +959,13 @@ function bbw(source, length, mult) {
   return result;
 }
 function wpr(high, low, close, length = 14) {
-  const result = [];
-  for (let i = 0; i < close.length; i++) {
-    if (i < length - 1) {
-      result.push(NaN);
-      continue;
-    }
-    let highestHigh = high[i - length + 1];
-    let lowestLow = low[i - length + 1];
-    for (let j = i - length + 2; j <= i; j++) {
-      if (high[j] > highestHigh) highestHigh = high[j];
-      if (low[j] < lowestLow) lowestLow = low[j];
-    }
-    const range2 = highestHigh - lowestLow;
-    if (range2 === 0) {
-      result.push(NaN);
-    } else {
-      const wprValue = (highestHigh - close[i]) / range2 * -100;
-      result.push(wprValue);
-    }
-  }
-  return result;
+  const highs = highest(high, length);
+  const lows = lowest(low, length);
+  return Array.from({ length: close.length }, (_, i) => {
+    const hmax = highs[i];
+    const range2 = hmax - lows[i];
+    return range2 === 0 ? NaN : 100 * (close[i] - hmax) / range2;
+  });
 }
 function vwap(source, volume, anchor, stdev_mult) {
   if (source.length !== volume.length) {
@@ -1036,18 +974,17 @@ function vwap(source, volume, anchor, stdev_mult) {
   const mid = [];
   const upper = [];
   const lower = [];
-  let sumPV = 0;
-  let sumV = 0;
-  let sumPPV = 0;
+  let sumPV = NaN;
+  let sumV = NaN;
+  let sumPPV = NaN;
   for (let i = 0; i < source.length; i++) {
-    if (anchor && anchor[i]) {
-      sumPV = 0;
-      sumV = 0;
-      sumPPV = 0;
-    }
     const s = source[i];
     const v = volume[i];
-    if (!Number.isNaN(s) && !Number.isNaN(v)) {
+    if (anchor ? anchor[i] : i === 0) {
+      sumPV = s * v;
+      sumV = v;
+      sumPPV = s * s * v;
+    } else {
       sumPV += s * v;
       sumV += v;
       sumPPV += s * s * v;
@@ -1096,8 +1033,7 @@ function kcw(source, length = 20, mult = 2, useTrueRange = true, high, low, clos
     if (isNaN(basis[i]) || basis[i] === 0) {
       result.push(NaN);
     } else {
-      const width = (upper[i] - lower[i]) / basis[i] * 100;
-      result.push(width);
+      result.push((upper[i] - lower[i]) / basis[i]);
     }
   }
   return result;
@@ -1129,47 +1065,26 @@ function min(source) {
   });
 }
 function cog(source, length = 10) {
-  const result = [];
-  for (let i = 0; i < source.length; i++) {
-    if (i < length - 1) {
-      result.push(NaN);
-      continue;
-    }
-    let numerator = 0;
-    let denominator = 0;
-    for (let j = 0; j < length; j++) {
-      const weight = j + 1;
-      const price = source[i - length + 1 + j];
-      numerator += weight * price;
-      denominator += price;
-    }
-    if (denominator === 0) {
-      result.push(NaN);
-    } else {
-      const cog2 = -1 * (numerator / denominator) + (length + 1) / 2;
-      result.push(cog2);
-    }
-  }
-  return result;
+  const len = Math.floor(length);
+  return (0, import_running_sum.runningSum)(source, len).map((sum, i) => {
+    if (i < len - 1 || Number.isNaN(sum) || sum === 0) return NaN;
+    let num = 0;
+    for (let k = 0; k < len; k++) num += source[i - k] * (k + 1);
+    return -num / sum;
+  });
 }
 function mode(source, length) {
   const result = [];
+  const len = Math.floor(length);
+  const seen = [];
   for (let i = 0; i < source.length; i++) {
-    if (i < length - 1) {
-      result.push(NaN);
-      continue;
-    }
-    const values = [];
-    for (let j = 0; j < length; j++) {
-      const value = source[i - j];
-      if (!isNaN(value)) {
-        values.push(value);
-      }
-    }
-    if (values.length === 0) {
+    const v = source[i];
+    if (!Number.isNaN(v)) seen.push(v);
+    if (seen.length < len) {
       result.push(NaN);
       continue;
     }
+    const values = seen.slice(seen.length - len);
     const frequencyMap = /* @__PURE__ */ new Map();
     for (const value of values) {
       frequencyMap.set(value, (frequencyMap.get(value) || 0) + 1);
@@ -1223,64 +1138,54 @@ function percentile_nearest_rank(source, length, percentage) {
   return sortedWindow(source, length, (s) => s[rank - 1]);
 }
 function rci(source, length) {
+  const len = Math.floor(length);
   const result = [];
+  const ring = new Array(len + 1).fill(0);
   for (let i = 0; i < source.length; i++) {
-    if (i < length - 1) {
-      result.push(NaN);
+    const v = source[i];
+    if (Number.isNaN(v)) {
+      result.push(i > 0 ? result[i - 1] : NaN);
       continue;
     }
-    const values = [];
-    for (let j = 0; j < length; j++) {
-      values.push(source[i - length + 1 + j]);
-    }
-    if (values.some((v) => isNaN(v))) {
+    ring[i % (len + 1)] = v;
+    if (i < len) {
       result.push(NaN);
       continue;
     }
-    const indexed = values.map((value, index) => ({ value, index }));
-    const sorted = [...indexed].sort((a, b) => a.value - b.value);
-    const ranks = new Array(length).fill(0);
-    let currentRank = 1;
-    for (let j = 0; j < sorted.length; j++) {
-      let tieCount = 1;
-      while (j + tieCount < sorted.length && sorted[j].value === sorted[j + tieCount].value) {
-        tieCount++;
-      }
-      const avgRank = (currentRank + (currentRank + tieCount - 1)) / 2;
-      for (let k = 0; k < tieCount; k++) {
-        ranks[sorted[j + k].index] = avgRank;
-      }
-      j += tieCount - 1;
-      currentRank += tieCount;
-    }
-    let sumSquaredDiff = 0;
-    for (let j = 0; j < length; j++) {
-      const timeRank = j + 1;
-      const diff = ranks[j] - timeRank;
-      sumSquaredDiff += diff * diff;
-    }
-    const n = length;
-    const base = (n * n * n - n) / 12;
-    let tieCorrection = 0;
-    for (let j = 0; j < sorted.length; ) {
-      let tieCount = 1;
-      while (j + tieCount < sorted.length && sorted[j].value === sorted[j + tieCount].value) {
-        tieCount++;
-      }
-      if (tieCount > 1) {
-        tieCorrection += (tieCount * tieCount * tieCount - tieCount) / 12;
-      }
-      j += tieCount;
-    }
-    const A = base - tieCorrection;
-    const B = base;
-    let rho;
-    if (A === 0 || B === 0) {
-      rho = 0;
-    } else {
-      rho = (A + B - sumSquaredDiff) / (2 * Math.sqrt(A * B));
+    const values = Array.from({ length: len }, (_, j) => ring[(i - j) % (len + 1)]);
+    const order = values.map((_, j) => j).sort((a, b) => values[a] - values[b]);
+    const ranks = new Array(len);
+    for (let g = 0; g < len; ) {
+      const anchor = values[order[g]];
+      let end = g + 1;
+      while (end < len && values[order[end]] - anchor < 1e-10) end++;
+      const avgRank = len - 1 - (g + g + (end - g) - 1) / 2;
+      for (let k = g; k < end; k++) ranks[order[k]] = avgRank;
+      g = end;
+    }
+    let sumX = 0;
+    let sumY = 0;
+    let sumX2 = 0;
+    let sumY2 = 0;
+    for (let k = 0; k < len; k++) {
+      const y = ranks[k];
+      sumX += k;
+      sumY += y;
+      sumX2 += k * k;
+      sumY2 += y * y;
+    }
+    const meanX = sumX / len;
+    const meanY = sumY / len;
+    const varX = sumX2 / len - meanX * meanX;
+    const varY = sumY2 / len - meanY * meanY;
+    if (!(varX > 0) || !(varY > 0)) {
+      result.push(NaN);
+      continue;
     }
-    result.push(rho * 100);
+    let cov = 0;
+    for (let k = 0; k < len; k++) cov += (k - meanX) * (ranks[k] - meanY);
+    cov /= len;
+    result.push(100 * cov / (Math.sqrt(varX) * Math.sqrt(varY)));
   }
   return result;
 }
@@ -1627,13 +1532,14 @@ function pvt(close, volume) {
   );
 }
 function accdist(high, low, close, volume) {
-  return cum(
-    close.map((c, i) => {
-      const h = high[i];
-      const l = low[i];
-      return h === l ? 0 : (2 * c - l - h) / (h - l) * volume[i];
-    })
-  );
+  let ad = 0;
+  return close.map((c, i) => {
+    const h = high[i];
+    const l = low[i];
+    const mfv = (c - l - (h - c)) / (h - l) * volume[i];
+    if (Number.isFinite(mfv)) ad += mfv;
+    return ad;
+  });
 }
 function iii(high, low, close, volume) {
   return close.map((c, i) => {