ohlcv-indicators 3.5.52 → 3.5.54

package/src/moving-averages/heikenAshi.js

@@ -1,113 +1,137 @@
 import { FasterEMA } from 'trading-signals';
 
-export const heikenAshi = (main, index, smoothLength, afterSmoothLength, {lag}) => {
-    const { verticalOhlcv, instances, len } = main
-    const prefix = `heiken_ashi_${smoothLength}_${afterSmoothLength}`
-    const keys = ['open', 'high', 'low', 'close']
-
-    // ---- INIT ----
-    if (index === 0) {
-
-        // Initialize pre-smoothing EMA instances and buffers
-        instances[prefix] = {
-            emaPre: Object.fromEntries(keys.map(k => [k, new FasterEMA(smoothLength)])),
-            emaPost: Object.fromEntries(keys.map(k => [k, new FasterEMA(afterSmoothLength)])),
-            prevHaOpen: NaN,
-            prevHaClose: NaN,
-            isTrendUp: false,
-        };
-
-        const keyNames = keys.map(k => `${prefix}_${k}`)
-
-        const verticalOhlcvSetup = Object.fromEntries([...keyNames, `${prefix}_cross`].map(v => [v, new Float64Array(len).fill(NaN)]))
+export const heikenAshi = (main, index, smoothLength, afterSmoothLength, { lag = 0, bothNull = false } = {}) => {
+  const { verticalOhlcv, instances, len, priceBased } = main;
+  const prefix = (bothNull) ?  'heiken_ashi' : `heiken_ashi_${smoothLength}_${afterSmoothLength}`;
+  const keys = ['open', 'high', 'low', 'close'];
+
+  // ---- INIT ----
+  if (index === 0) {
+    // Initialize state
+    instances[prefix] = {
+      // Only allocate EMAs when smoothing is requested
+      emaPre: !bothNull
+        ? Object.fromEntries(keys.map(k => [k, new FasterEMA(smoothLength)]))
+        : null,
+      emaPost: !bothNull
+        ? Object.fromEntries(keys.map(k => [k, new FasterEMA(afterSmoothLength)]))
+        : null,
+      prevHaOpen: NaN,
+      prevHaClose: NaN,
+      isTrendUp: false,
+    };
+
+    const keyNames = keys.map(k => `${prefix}_${k}`);
+    const verticalOhlcvSetup = Object.fromEntries(
+      [...keyNames, `${prefix}_cross`].map(v => [v, new Float64Array(len).fill(NaN)])
+    );
+
+    for(const k of keyNames) {
+      priceBased.add(k)
+    }
 
-        Object.assign(verticalOhlcv, {...verticalOhlcvSetup})
+    Object.assign(verticalOhlcv, { ...verticalOhlcvSetup });
 
-        if(lag > 0)
-        {
-            main.lag(keyNames, lag)
-        }
+    if (lag > 0) {
+      main.lag(keyNames, lag);
     }
+  }
 
-    // ---- FETCH RAW INPUTS ----
-    const open = verticalOhlcv.open[index]
-    const high = verticalOhlcv.high[index]
-    const low = verticalOhlcv.low[index]
-    const close = verticalOhlcv.close[index]
-    const inst = instances[prefix]
+  // ---- FETCH RAW INPUTS ----
+  const open = verticalOhlcv.open[index];
+  const high = verticalOhlcv.high[index];
+  const low = verticalOhlcv.low[index];
+  const close = verticalOhlcv.close[index];
+  const inst = instances[prefix];
 
-    // ---- PRE-SMOOTHING (EMA) ----
-    inst.emaPre.open.update(open)
-    inst.emaPre.high.update(high)
-    inst.emaPre.low.update(low)
-    inst.emaPre.close.update(close)
+  let sOpen, sHigh, sLow, sClose;
 
-    let sOpen, sHigh, sLow, sClose
+  if (!bothNull) {
+    // ---- PRE-SMOOTHING (EMA) ----
+    inst.emaPre.open.update(open);
+    inst.emaPre.high.update(high);
+    inst.emaPre.low.update(low);
+    inst.emaPre.close.update(close);
 
     try {
-        sOpen = inst.emaPre.open.getResult()
-        sHigh = inst.emaPre.high.getResult()
-        sLow = inst.emaPre.low.getResult()
-        sClose = inst.emaPre.close.getResult()
+      sOpen = inst.emaPre.open.getResult();
+      sHigh = inst.emaPre.high.getResult();
+      sLow = inst.emaPre.low.getResult();
+      sClose = inst.emaPre.close.getResult();
     } catch {
-        return true; // skip if not enough data
+      return true; // skip if not enough data
     }
-
-    // ---- HEIKEN ASHI CORE ----
-    const haClose = (sOpen + sHigh + sLow + sClose) / 4
-    const haOpen = (Number.isNaN(inst.prevHaOpen) || Number.isNaN(inst.prevHaClose)) ? (sOpen + sClose) / 2 : (inst.prevHaOpen + inst.prevHaClose) / 2
-    const haHigh = Math.max(sHigh, haOpen, haClose)
-    const haLow = Math.min(sLow, haOpen, haClose)
-
-    // Store for next round
-    inst.prevHaOpen = haOpen
-    inst.prevHaClose = haClose
-
+  } else {
+    // No pre-smoothing: use raw OHLC
+    sOpen = open;
+    sHigh = high;
+    sLow = low;
+    sClose = close;
+  }
+
+  // ---- HEIKEN ASHI CORE (from s*) ----
+  const haClose = (sOpen + sHigh + sLow + sClose) / 4;
+  const haOpen = (Number.isNaN(inst.prevHaOpen) || Number.isNaN(inst.prevHaClose))
+    ? (sOpen + sClose) / 2
+    : (inst.prevHaOpen + inst.prevHaClose) / 2;
+  const haHigh = Math.max(sHigh, haOpen, haClose);
+  const haLow = Math.min(sLow, haOpen, haClose);
+
+  // Store for next round
+  inst.prevHaOpen = haOpen;
+  inst.prevHaClose = haClose;
+
+  let smOpen, smHigh, smLow, smClose;
+
+  if (!bothNull) {
     // ---- POST-SMOOTHING (EMA) ----
-    inst.emaPost.open.update(haOpen)
-    inst.emaPost.high.update(haHigh)
-    inst.emaPost.low.update(haLow)
-    inst.emaPost.close.update(haClose)
-
-    let smOpen, smHigh, smLow, smClose
+    inst.emaPost.open.update(haOpen);
+    inst.emaPost.high.update(haHigh);
+    inst.emaPost.low.update(haLow);
+    inst.emaPost.close.update(haClose);
 
     try {
-        smOpen = inst.emaPost.open.getResult()
-        smHigh = inst.emaPost.high.getResult()
-        smLow = inst.emaPost.low.getResult()
-        smClose = inst.emaPost.close.getResult()
+      smOpen = inst.emaPost.open.getResult();
+      smHigh = inst.emaPost.high.getResult();
+      smLow = inst.emaPost.low.getResult();
+      smClose = inst.emaPost.close.getResult();
     } catch {
-        return true
+      return true; // skip if not enough data
     }
-
-  // Cumulative cross counter: positive when uptrend, negative when downtrend
-    const prevCross = index > 0 ? verticalOhlcv[`${prefix}_cross`][index - 1] : 0
-    const prevHaOpen = index > 0 ? verticalOhlcv[`${prefix}_open`][index - 1] : NaN
-    const prevHaClose = index > 0 ? verticalOhlcv[`${prefix}_close`][index - 1] : NaN
-    const crossUp = !Number.isNaN(prevHaClose) && prevHaClose <= prevHaOpen && smClose > smOpen
-    const crossDown = !Number.isNaN(prevHaClose) && prevHaClose >= prevHaOpen && smClose < smOpen
-
-
-    if (crossUp) inst.isTrendUp = true;
-    if (crossDown) inst.isTrendUp = false;
-
-    let cross = 0
-
-    if (index > 0) {
-        if (inst.isTrendUp) {
-            cross = prevCross > 0 ? prevCross + 1 : 1
-        } else {
-            cross = prevCross < 0 ? prevCross - 1 : -1
-        }
+  } else {
+    // No post-smoothing: final values are plain HA
+    smOpen = haOpen;
+    smHigh = haHigh;
+    smLow = haLow;
+    smClose = haClose;
+  }
+
+  // ---- TREND/CROSS LOGIC (works for both modes) ----
+  const prevCross = index > 0 ? verticalOhlcv[`${prefix}_cross`][index - 1] : 0;
+  const prevHaOpenArr = index > 0 ? verticalOhlcv[`${prefix}_open`][index - 1] : NaN;
+  const prevHaCloseArr = index > 0 ? verticalOhlcv[`${prefix}_close`][index - 1] : NaN;
+
+  const crossUp = !Number.isNaN(prevHaCloseArr) && prevHaCloseArr <= prevHaOpenArr && smClose > smOpen;
+  const crossDown = !Number.isNaN(prevHaCloseArr) && prevHaCloseArr >= prevHaOpenArr && smClose < smOpen;
+
+  if (crossUp) inst.isTrendUp = true;
+  if (crossDown) inst.isTrendUp = false;
+
+  let cross = 0;
+  if (index > 0) {
+    if (inst.isTrendUp) {
+      cross = prevCross > 0 ? prevCross + 1 : 1;
+    } else {
+      cross = prevCross < 0 ? prevCross - 1 : -1;
     }
+  }
 
-    // ---- PUSH OUTPUTS ----
-    main.pushToMain({ index, key: `${prefix}_open`, value: smOpen })
-    main.pushToMain({ index, key: `${prefix}_high`, value: smHigh })
-    main.pushToMain({ index, key: `${prefix}_low`, value: smLow })
-    main.pushToMain({ index, key: `${prefix}_close`, value: smClose })
-    main.pushToMain({ index, key: `${prefix}_cross`, value: cross })
-
+  // ---- PUSH OUTPUTS ----
+  main.pushToMain({ index, key: `${prefix}_open`, value: smOpen });
+  main.pushToMain({ index, key: `${prefix}_high`, value: smHigh });
+  main.pushToMain({ index, key: `${prefix}_low`, value: smLow });
+  main.pushToMain({ index, key: `${prefix}_close`, value: smClose });
+  main.pushToMain({ index, key: `${prefix}_cross`, value: cross });
 
-  return true
-}
+  return true;
+};

package/src/moving-averages/macd.js

@@ -6,7 +6,7 @@ export const macd = (main, index, fast, slow, signal, {target, lag, precomputed}
 
   
 
-  const { verticalOhlcv, instances } = main
+  const { verticalOhlcv, instances, priceBased } = main
   const {instanceKey} = precomputed
 
   // Initialization on the first index.
@@ -52,6 +52,10 @@ export const macd = (main, index, fast, slow, signal, {target, lag, precomputed}
 
     const keyNames = [diffKey, deaKey, histogramKey]
 
+    for(const k of keyNames) {
+      priceBased.add(k)
+    }
+
     if(lag > 0)
     {
       main.lag(keyNames, lag)

package/src/moving-averages/movingAverages.js

@@ -10,7 +10,7 @@ export const movingAverages = (main, index, methodName, size, { target, lag }) =
 
   
 
-  const { verticalOhlcv, instances } = main
+  const { verticalOhlcv, instances, priceBased } = main
   const suffix = (target !== 'close') ?  `_${target}` : ''
   const keyName = `${methodName}_${size}${suffix}`
 
@@ -29,6 +29,10 @@ export const movingAverages = (main, index, methodName, size, { target, lag }) =
 
     verticalOhlcv[keyName] = new Float64Array(len).fill(NaN)
 
+    if(priceBased.has(target)){
+      priceBased.add(keyName)
+    }
+
     if(lag > 0)
     {
       main.lag([keyName], lag)

package/src/moving-averages/vidya.js

@@ -2,7 +2,7 @@ import { FasterSMA } from 'trading-signals';
 // Variable Index Dynamic Average (VIDYA) indicator with volume stats
 
 export const vidya = (main, index, size, momentum, options = {}) => {
-  const { verticalOhlcv, instances, len } = main;
+  const { verticalOhlcv, instances, len, priceBased } = main;
   const { target, lag, atrLength = 200, bandDistance = 2, liquidityLookback = 5 } = options
   const indicatorKey = `${size}_${momentum}`;
 
@@ -23,6 +23,12 @@ export const vidya = (main, index, size, momentum, options = {}) => {
       liquidity: `${prefix}_liquidity`,
     };
 
+    const priceBasedVidyaKeys = [keyBase, keys.upper, keys.lower, keys.liquidity]
+
+    for(const k of priceBasedVidyaKeys) {
+      priceBased.add(k)
+    }
+
     // Prepare instances container
     if (!instances.vidya) instances.vidya = { settings: {} };
     instances.vidya.settings[indicatorKey] = {

package/src/oscillators/volumeDelta.js

@@ -0,0 +1,74 @@
+export const volumeDelta = (main, index, { lag = 0 }) => {
+  const { verticalOhlcv, instances, len } = main;
+  const groupName = 'volume_delta';
+
+  if (index === 0) {
+    if (!instances[groupName]) instances[groupName] = { isBuyVolume: true, cross: 0 };
+
+    const keys = [
+      `${groupName}_open`,
+      `${groupName}_high`,
+      `${groupName}_low`,
+      `${groupName}_close`,
+      `${groupName}_cross`,
+    ];
+
+    // allocate outputs
+    for (const k of keys) verticalOhlcv[k] = new Float64Array(len).fill(NaN);
+
+    // optional lag
+    if (lag > 0) main.lag(keys, lag);
+  }
+
+  const inst = instances[groupName];
+
+  // inputs
+  const vol       = verticalOhlcv.volume[index];
+  const open      = verticalOhlcv.open[index];
+  const close     = verticalOhlcv.close[index];
+  const prevClose = index > 0 ? verticalOhlcv.close[index - 1] : NaN;
+
+  // TradingView tie-breaks:
+  // 1) close>open -> buy, 2) close<open -> sell,
+  // 3) equal: compare to prev close, 4) still equal: carry prior state
+  let isBuy = inst.isBuyVolume;
+  if (close > open) isBuy = true;
+  else if (close < open) isBuy = false;
+  else if (close > prevClose) isBuy = true;
+  else if (close < prevClose) isBuy = false;
+
+  inst.isBuyVolume = isBuy;
+
+  if(index < 1)
+  {
+    if(isBuy) inst.cross = 1
+    else inst.cross = -1
+  }
+  else {
+    if(isBuy)
+    {
+        if(inst.cross > 0) inst.cross = inst.cross + 1
+        else inst.cross = 1 //reset
+    } else {
+        if(inst.cross > 0) inst.cross = -1 //reset
+        else inst.cross = inst.cross - 1
+    }
+  }
+  
+
+  const delta = Number.isFinite(vol) ? (isBuy ? vol : -vol) : NaN;
+
+  // delta "candle"
+  const openVal  = Number.isNaN(delta) ? NaN : 0;
+  const closeVal = delta;
+  const highVal  = Number.isNaN(delta) ? NaN : Math.max(delta, 0);
+  const lowVal   = Number.isNaN(delta) ? NaN : Math.min(delta, 0);
+
+  main.pushToMain({ index, key: `${groupName}_open`,  value: openVal });
+  main.pushToMain({ index, key: `${groupName}_high`,  value: highVal });
+  main.pushToMain({ index, key: `${groupName}_low`,   value: lowVal });
+  main.pushToMain({ index, key: `${groupName}_close`, value: closeVal });
+  main.pushToMain({ index, key: `${groupName}_cross`, value: inst.cross });
+
+  return true;
+};

package/src/studies/findCrosses.js

@@ -1,5 +1,6 @@
 import { oneHotEncode } from "../machine-learning/ml-utilities.js"
 import { buildArray } from "../utilities/assignTypes.js"
+import { addPrecisionAsNumber } from "../utilities/precisionMultiplier.js"
 const eq = (fast, slow) => fast === slow
 const gt = (fast, slow) => fast > slow
 const lt = (fast, slow) => fast < slow
@@ -132,9 +133,9 @@ class CrossInstance {
 
 }
 
-export const crossPairs = (main, index, crossPairsList) => {
+export const crossPairs = (main, index, crossPairsList, {oneHot, limit}) => {
 
-  const {verticalOhlcv, verticalOhlcvTempCols, instances, len} = main
+  const {verticalOhlcv, verticalOhlcvTempCols, instances, len, precision, precisionMultiplier, priceBased} = main
 
   for (const { fast, slow } of crossPairsList) {
 
@@ -147,7 +148,15 @@ export const crossPairs = (main, index, crossPairsList) => {
 
             const col = slow.toString()
             verticalOhlcvTempCols.add(col)
-            verticalOhlcv[col] =  buildArray('Int16Array', len, slow)
+
+            const requiresPrecision = precision && (fast === 'price' || priceBased.has(fast))
+
+            const slowVal = requiresPrecision
+                ? addPrecisionAsNumber(col, precisionMultiplier) 
+                : slow
+
+            const numArrType = (slow >= -125 && slow <= 125 && requiresPrecision === false) ? 'Int8Array' : 'Float64Array'
+            verticalOhlcv[col] =  buildArray(numArrType, len, slowVal)
         }
 
         if(!instances.hasOwnProperty('crossPairs'))
@@ -162,10 +171,15 @@ export const crossPairs = (main, index, crossPairsList) => {
             max: -Infinity
         }
 
-        const crossArrType = 'Int16Array'
+        const crossArrType = (limit !== null && limit <= 125) ? 'Int8Array' : 'Float64Array'
 
         verticalOhlcv[crossName] = buildArray(crossArrType, len, 0)
 
+        if(oneHot)
+        {
+            verticalOhlcv[`one_hot_${crossName}`] = buildArray('Array', len, null)
+        }
+
     }  else if(index + 1 === len) {
         // sanity checks
         if (fast !== "price" && !verticalOhlcv.hasOwnProperty(fast)) {
@@ -197,9 +211,21 @@ export const crossPairs = (main, index, crossPairsList) => {
       run.update(index, { fast: fastVal, slow: slowVal })
     }
 
-    const value = run.getResult()
+    const rawValue = run.getResult()
+    const value = (limit !== null) ? Math.min(Math.max(rawValue, -limit), limit) : rawValue
     main.pushToMain({index, key: crossName, value})
 
+    if(oneHot)
+    {
+        const oneHotIdx = value + limit;
+        const oneHotSize = 2 * limit + 1;
+        main.pushToMain({
+            index,
+            key: `one_hot_${crossName}`,
+            value: oneHotEncode(oneHotIdx, oneHotSize)
+        });
+    }
+
   }
 
   return true

package/src/studies/lag.js

@@ -4,32 +4,37 @@ export const lag = (main, index, colKeys, lookback) => {
 
   
   
-  const { verticalOhlcv, len } = main
+  const { verticalOhlcv, len, priceBased } = main
 
   if(index === 0)
   {
-    for (const colKey of colKeys) {
-      if (!verticalOhlcv.hasOwnProperty(colKey)) {
-          throw new Error(
-          `Lag processing invoked by col "${colKey}" was not found in "verticalOhlcv".`
-          )
+    for (const targetKey of colKeys) {
+      if (!verticalOhlcv.hasOwnProperty(targetKey)) {
+        throw new Error(
+        `Lag processing invoked by col "${targetKey}" was not found in "verticalOhlcv".`
+        )
       }
 
+      const addToPriceBased = priceBased.has(targetKey)
+
       for (let step = 1; step <= lookback; step++) {
-          const key = `${colKey}_lag_${step}`
-          const thisArrType = getArrayType(colKey, verticalOhlcv[colKey])
+        const key = `${targetKey}_lag_${step}`
+
+        if(addToPriceBased) priceBased.add(key)
+
+        const thisArrType = getArrayType(targetKey, verticalOhlcv[targetKey])
 
-          verticalOhlcv[key] = buildArray(thisArrType, len)
+        verticalOhlcv[key] = buildArray(thisArrType, len)
       }   
     }
   }
 
-  for (const colKey of colKeys) {
-    const currentColumn = verticalOhlcv[colKey]
+  for (const targetKey of colKeys) {
+    const currentColumn = verticalOhlcv[targetKey]
 
     // Populate the lagged values each tick:
     for (let step = 1; step <= lookback; step++) {
-      const key = `${colKey}_lag_${step}`
+      const key = `${targetKey}_lag_${step}`
       const laggedIndex = index - step
       const value =
         laggedIndex < 0 || currentColumn[laggedIndex] === undefined

package/src/utilities/assignTypes.js

@@ -1,8 +1,6 @@
 import { classifyNum } from "./numberUtilities.js";
 import { selectDateFormatter } from "./dateUtilities.js";
 
-const numberKeys = new Set(['open', 'high', 'low', 'close'])
-
 export const buildArray = (arrayType, len, fallbackValue) => {
   const ctorMap = {
     Array:        Array,
@@ -35,7 +33,7 @@ export const buildArray = (arrayType, len, fallbackValue) => {
 }
 
 export const assignTypes = main => {
-  const {firstRow} = main
+  const {firstRow, precision, initialPriceBased} = main
   const inputTypes  = {}
   const arrayTypes  = {}
 
@@ -50,12 +48,12 @@ export const assignTypes = main => {
       inputTypes[colName] = classifyNum(cellValue, true)
       arrayTypes[colName] = 'Int32Array'
     }
-    else if(numberKeys.has(colName))
+    else if(initialPriceBased.has(colName))
     {
-      inputTypes[colName] = classifyNum(cellValue, true)
+      inputTypes[colName] = classifyNum(cellValue, true, precision)
       arrayTypes[colName] = 'Float64Array'
     } else {
-      const thisType = classifyNum(cellValue, false)
+      const thisType = classifyNum(cellValue, false, precision)
       inputTypes[colName] = thisType
       arrayTypes[colName] = (thisType === 'number') ? 'Float64Array' : 'Array'
     }

package/src/utilities/numberUtilities.js

@@ -1,52 +1,35 @@
-// Helper to clean non-numeric characters (except "-" at the start and decimal point)
-export const sanitizeDirtyNumberString = str => str.replace(/(?!^-)[^0-9.]/g, '');
+import { addPrecisionAsNumber, revertPrecisionAsNumber } from "./precisionMultiplier.js";
 
-export const numberFormater = {
+export const inputNumberFormatter = {
   number: n => n,
   numberCleanString: n => Number(n),
-  numberDirtyString: n => Number(sanitizeDirtyNumberString(n))
+  precisionNumberCleanString: (strNum, multiplier) => addPrecisionAsNumber(strNum, multiplier)
 }
 
+export const outputNumberFormatter = {
+  number: n => n,
+  numberCleanString: n => n,
+  precisionNumberCleanString: (strNum, multiplier) => revertPrecisionAsNumber(strNum, multiplier)
+}
 
-export const classifyNum = (num, throwError = false) => {
-  // 1) true numbers
-  if (typeof num === 'number' && !Number.isNaN(num)) {
-    return 'number';
-  }
+export const classifyNum = (num, throwError = false, precision = false) => {
 
-  // 2) strings
-  if (typeof num === 'string') {
-    const str = num.trim();
-    const cleanRe = /^-?\d+(\.\d+)?$/;
+  const cleanRe = /^-?\d+(\.\d+)?$/;
+  const isNumber = typeof num === 'number' && !Number.isNaN(num)
+  const isString = typeof num === 'string'
+  const isCleanString = isString && cleanRe.test(num)
 
-    // a) clean numeric string: only digits and an optional single period
-    if (cleanRe.test(str)) {
-      return 'numberCleanString';
-    }
+  if(precision === true) {
+    if(isCleanString) return 'precisionNumberCleanString'
 
-    // b) dirty numeric string: contains non-digits (dollar, commas, letters, etc.)
-    //    but once you strip those out, you're left with a valid number
-    const stripped = str.replace(/[^0-9.]/g, '');
-    if (stripped && cleanRe.test(stripped)) {
-      return 'numberDirtyString';
-    }
+    if(throwError) throw new Error('Invalid number forma')
+    return typeof num
   }
-
-
-  if(throwError)
-  {
-    throw new TypeError(
-      'Invalid input: expected a number or numeric string'
-    );
+  else {
+    if(isNumber) return 'number'
+    else if(isCleanString) return 'numberCleanString'
   }
 
+  if(throwError) throw new TypeError('Invalid input: expected a number or numeric string')
   return typeof num
-};
-
-
-export const roundDecimalPlaces = (value, decimals) => {
-
-  const factor = 10 ** decimals
-  // add a tiny epsilon to mitigate floating-point quirks around .5
-  return Math.round((value + Number.EPSILON) * factor) / factor
-};
+}