ohlcv-indicators 3.5.4 → 3.5.42

package/src/machine-learning/scaler.js

@@ -1,39 +1,36 @@
-import { roundDecimalPlaces } from "../utilities/numberUtilities.js";
-
-/* General scaler: supports "minmax" and "zscore" types */
-
+import { normalizeMinMax, normalizeZScore } from "./ml-utilities.js";
+  
+export const scaler = (main, index, size, colKeys, {type, group, range, lag, precomputed, secondaryLoop}) => {
 
+    
 
-const normalizeMinMax = (value, min, max, [validMin, validMax]) => {
-    const clamped = Math.min(Math.max(value, min), max);
-    return ((clamped - min) / (max - min)) * (validMax - validMin) + validMin;
-  };
-  
-  const normalizeZScore = (value, mean, std) => {
-    return std === 0 ? 0 : (value - mean) / std;
-  };
-  
-export const scaler = (main, index, size, colKeys, {type, group, range, lag, precomputed, decimals}) => {
     const {groupKey, groupKeyLen} = precomputed
-    const { verticalOhlcv, instances, arrayTypes } = main;
+    const { verticalOhlcv, instances, arrayTypes, invalidValueIndex } = main;
     const prefix = `${type}_${size}`;
   
-    if (index === 0) {
-      const { len, scaledLabels } = main;
+    if(index === 0) {
+      const { len, isAlreadyComputed } = main
 
-      if(scaledLabels.has(prefix))
+      if(isAlreadyComputed.has(prefix))
       {
-        throw new Error(`Method "scaler" cannot have both "size" and "options.type" parameters specified together.`)
+        throw new Error(`In scaler method can not repeat params "size" and "options.type" together between indicators.`)
       }
-      scaledLabels.add(prefix)
+
+      isAlreadyComputed.add(prefix)
   
-      if(!instances.hasOwnProperty('scaler'))
+      if(!instances.hasOwnProperty('scaler')) {
+        instances.scaler = {}
+      }
+
+      if(!instances.scaler.hasOwnProperty(prefix))
       {
-        instances.scaler = {
+        instances.scaler[prefix] = {
           windows: {}
         }
       }
 
+      const features = []
+
       for (const target of colKeys) {
         if (!verticalOhlcv.hasOwnProperty(target)) {
           throw new Error(`Target property "${target}" not found in verticalOhlcv`);
@@ -44,66 +41,102 @@ export const scaler = (main, index, size, colKeys, {type, group, range, lag, pre
         arrayTypes[key] = 'Float64Array'
   
         const winKey = group ? groupKey : target;
-        instances.scaler.windows[winKey] = [];
+        instances.scaler[prefix].windows[winKey] = [];
   
-        if (group) {
-          if (!main.scaledGroups[groupKey]) main.scaledGroups[groupKey] = [];
-          main.scaledGroups[groupKey].push(key);
-        }
+        if (!main.scaledGroups[groupKey]) main.scaledGroups[groupKey] = [];
+        main.scaledGroups[groupKey].push(key);
   
         if (lag > 0) {
-          if (group) {
-            const lags = Array.from({ length: lag }).map((_, i) => `${key}_lag_${i + 1}`);
-            main.scaledGroups[groupKey].push(...lags);
-          }
-          main.lag([key], lag);
+          const lags = Array.from({ length: lag }).map((_, i) => `${key}_lag_${i + 1}`)
+          main.scaledGroups[groupKey].push(...lags)
+          features.push(key)
         }
       }
+
+      if(lag > 0)
+      {
+        main.lag(features, lag)
+      }
     }
+
+    if(secondaryLoop === true && index <= invalidValueIndex) true
   
-    const { windows } = instances.scaler
-  
+    const { windows } = instances.scaler[prefix]
+    
+    let hasInvalidVal = false
+
     // update windows with current values
-    for (const target of colKeys) {
-      const val = verticalOhlcv[target][index];
-      const winKey = group ? groupKey : target;
-      const win = windows[winKey];
+    for (let x = 0; x < colKeys.length; x++) {
+      const target = colKeys[x]
+      const col = verticalOhlcv[target]
+
+      if(typeof col === 'undefined')
+      {
+        hasInvalidVal = true
+        break     
+      }
+
+      const val = col[index]
+
+      if(Number.isNaN(val) || val === null)
+      {
+        hasInvalidVal = true
+        break
+      }
+
+      const winKey = group ? groupKey : target
+      const win = windows[winKey]
   
-      win.push(val);
+      win.push(val)
       
       if (win.length > (group ? size * groupKeyLen : size)) {
-        win.shift();
+        win.shift()
       }
 
     }
+
+    if(hasInvalidVal) return
   
-    const ready = index + 1 >= size;
+    const ready = index + 1 >= size
+
+    if(!ready) return
   
     // scale values once enough data
-    for (const target of colKeys) {
-      const val = verticalOhlcv[target][index];
-      const key = `${prefix}_${target}`;
-      let scaled = null;
-  
-      if (ready) {
-        const winKey = group ? groupKey : target;
-        const win = windows[winKey];
-  
-        if (type === 'minmax') {
-          const mn = Math.min(...win);
-          const mx = Math.max(...win);
-          scaled = normalizeMinMax(val, mn, mx, range);
-        } else if (type === 'zscore') {
-          const mean = win.reduce((sum, x) => sum + x, 0) / win.length;
-          const variance = win.reduce((sum, x) => sum + Math.pow(x - mean, 2), 0) / win.length;
-          const std = Math.sqrt(variance);
-          scaled = normalizeZScore(val, mean, std);
-        } else {
-          throw new Error(`Unknown scaler type "${type}"`);
-        }
+    for (let x = 0; x < colKeys.length; x++) {
+      const target = colKeys[x]
+      const col = verticalOhlcv[target]
+
+      if(typeof col === 'undefined')
+      {
+        break     
+      }     
+
+      const val = col[index]
+
+      if(Number.isNaN(val) || val === null)
+      {
+        break
+      }
+
+      const key = `${prefix}_${target}`
+      let scaled = null
+      const winKey = group ? groupKey : target
+      const win = windows[winKey]
+
+      if (type === 'minmax') {
+        const mn = Math.min(...win)
+        const mx = Math.max(...win)
+        scaled = normalizeMinMax(val, mn, mx, range)
+      } else if (type === 'zscore') {
+        const mean = win.reduce((sum, x) => sum + x, 0) / win.length;
+        const variance = win.reduce((sum, x) => sum + Math.pow(x - mean, 2), 0) / win.length
+        const std = Math.sqrt(variance);
+        scaled = normalizeZScore(val, mean, std)
+      } else {
+        throw new Error(`Unknown scaler type "${type}"`)
       }
   
-      main.pushToMain({ index, key, value: (decimals === null) ? scaled : roundDecimalPlaces(scaled, decimals)})
+      main.pushToMain({ index, key, value: scaled})
     }
-  };
+}
   

package/src/machine-learning/trainX.js

@@ -0,0 +1,73 @@
+/**
+ * Builds a flattened lookback feature vector or returns null if any value is non‐finite.
+ *
+ * @param {string[]} featureCols                – list of feature column keys
+ * @param {Object}   instances                  – your instances object (with crossPairs)
+ * @param {number}   flatFeaturesColLen         – total number of flattened feature slots
+ * @param {string}   type                       – a string used only for error reporting
+ * @param {number}   index                      – current time index
+ * @param {number}   lookbackAbs                – number of lags to include
+ * @param {Object}   verticalOhlcv              – an object mapping each key to its time series array
+ * @returns {number[]\|null}                    – the feature vector or null if exiting early
+ */
+export const buildTrainX = ({
+  featureCols,
+  flatFeaturesColLen,
+  type,
+  index,
+  lookbackAbs,
+  main
+}) => {
+
+  const {verticalOhlcv} = main
+
+  let shouldExit = false
+
+  // --- BUILD A FLATTENED LIST OF “COLUMN SLOTS” ---
+  const slots = [];
+  for (const key of featureCols) {
+    if (key.startsWith('one_hot_') || key.startsWith('pca_')) {
+
+      const colSize = verticalOhlcv[key][index].length
+
+      for (let bit = 0; bit < colSize; bit++) {
+        slots.push({ key, bit });
+      }
+    } else {
+      slots.push({ key });
+    }
+  }
+
+  if (slots.length !== flatFeaturesColLen) {
+    throw new Error(
+      `slots (${slots.length}) ≠ flatFeaturesColLen (${flatFeaturesColLen}) in ${type} index ${index}`
+    );
+  }
+
+  // --- ALLOCATE AND FILL trainX ---
+  const trainX = new Array(flatFeaturesColLen * lookbackAbs).fill(NaN);
+
+  for (let lag = 0; lag < lookbackAbs; lag++) {
+    const tIdx = index - lag;
+
+    for (let s = 0; s < slots.length; s++) {
+      const { key, bit } = slots[s];
+      const cell = verticalOhlcv[key][tIdx];
+      const value = (bit != null) ? cell[bit] : cell;
+
+      if (!Number.isFinite(value)) {
+        shouldExit = true;
+        break;
+      }
+      trainX[lag * flatFeaturesColLen + s] = value;
+    }
+
+    if (shouldExit) break;
+  }
+
+  if (shouldExit) {
+    return null;
+  }
+
+  return trainX;
+};

package/src/moving-averages/bollingerBands.js

@@ -4,15 +4,17 @@ import { roundDecimalPlaces } from '../utilities/numberUtilities.js';
 const defaultTarget = 'close'
 
 export const bollingerBands = (main, index, size, stdDev, { height, range = [], target, lag, decimals }) => {
+
+  
+
   const { verticalOhlcv, instances } = main;
-  const suffix = target === defaultTarget ? '' : `_${target}`;
-  const indicatorKey = `${size}_${stdDev}${suffix}`;
-  let prefix;
+  const indicatorKey = `${size}_${stdDev}`;
+  const prefix = 'bollinger_bands'
 
   // Initialization on the first call.
   if (index === 0) {
 
-    const { priceBased, inputParams, verticalOhlcv, len, arrayTypes } = main;
+    const {inputParams, verticalOhlcv, len, arrayTypes } = main;
 
     if (!(target in verticalOhlcv)) {
       throw new Error(`bollingerBands could not find target "${target}"`);
@@ -24,10 +26,6 @@ export const bollingerBands = (main, index, size, stdDev, { height, range = [],
       if (o.key === 'bollingerBands') numberOfIndicators++;
     }
 
-    prefix = numberOfIndicators > 1
-      ? `bollinger_bands_${indicatorKey}`
-      : `bollinger_bands${suffix}`;
-
     // Only create the container if it doesn't already exist.
     if (!instances.bollinger_bands) {
       instances.bollinger_bands = {
@@ -38,23 +36,29 @@ export const bollingerBands = (main, index, size, stdDev, { height, range = [],
     // Add (or override) the indicator instance keyed by indicatorKey.
     instances.bollinger_bands.settings[indicatorKey] = new FasterBollingerBands(size, stdDev);
 
+    let suffix = ''
+    if((numberOfIndicators > 1)) suffix += `_${indicatorKey}`
+    if(target !== defaultTarget) suffix += `_${target}`
+
     const keyNames = [
       `${prefix}_upper`,
       `${prefix}_middle`,
       `${prefix}_lower`,
-    ]
+    ].map(v => `${v}${suffix}`)
 
 
     if (height) {
-      keyNames.push(`${prefix}_height`)
+      keyNames.push(
+        `${prefix}_height${suffix}`
+      )
     }
 
     // Set up additional arrays for each range property.
     for (const rangeKey of range) {
-      if (!(rangeKey in verticalOhlcv) || !priceBased.has(rangeKey)) {
-        throw new Error(`Invalid range item value "${rangeKey}" property for bollingerBands. Only price based key names are accepted:\n${JSON.stringify(priceBased)}`);
+      if (!(rangeKey in verticalOhlcv)) {
+        throw new Error(`Invalid range item value "${rangeKey}" property for bollingerBands.`);
       }
-      keyNames.push(`${prefix}_range_${rangeKey}`)
+      keyNames.push(`${prefix}_range_${rangeKey}${suffix}`)
 
     }
 
@@ -66,27 +70,22 @@ export const bollingerBands = (main, index, size, stdDev, { height, range = [],
       main.lag(keyNames, lag)
     }
 
-    [`${prefix}_upper`, `${prefix}_middle`, `${prefix}_lower`].forEach(v => {
-      priceBased.add(v)
-    })
-
     for(const key of keyNames)
     {
       arrayTypes[key] = 'Float64Array'
     }
   }
 
-  // Derive prefix for subsequent calls if not set.
-  if (!prefix) {
-    const num = instances.bollinger_bands.numberOfIndicators;
-    prefix = num > 1 ? `bollinger_bands_${indicatorKey}` : `bollinger_bands${suffix}`;
-  }
-  const subPrefix = prefix;
+  const {numberOfIndicators} = instances.bollinger_bands
 
+  let suffix = ''
+  if((numberOfIndicators > 1)) suffix += `_${indicatorKey}`
+  if(target !== defaultTarget) suffix += `_${target}`
+  
   // Update the indicator with the current value.
-  const instance = instances.bollinger_bands.settings[indicatorKey];
-  const value = verticalOhlcv[target][index];
-  instance.update(value);
+  const instance = instances.bollinger_bands.settings[indicatorKey]
+  const value = verticalOhlcv[target][index]
+  instance.update(value)
 
   // Attempt to retrieve the result.
   let result = {};
@@ -102,9 +101,9 @@ export const bollingerBands = (main, index, size, stdDev, { height, range = [],
   const lower = result?.lower ?? NaN;
 
   // Always push the indicator outputs.
-  main.pushToMain({ index, key: `${subPrefix}_upper`, value: upper });
-  main.pushToMain({ index, key: `${subPrefix}_middle`, value: middle });
-  main.pushToMain({ index, key: `${subPrefix}_lower`, value: lower });
+  main.pushToMain({ index, key: `${prefix}_upper${suffix}`, value: upper });
+  main.pushToMain({ index, key: `${prefix}_middle${suffix}`, value: middle });
+  main.pushToMain({ index, key: `${prefix}_lower${suffix}`, value: lower });
 
   // Process height if requested.
   if (height) {
@@ -112,7 +111,7 @@ export const bollingerBands = (main, index, size, stdDev, { height, range = [],
     if (!Number.isNaN(lower) && !Number.isNaN(upper)) {
       heightValue = ((upper - lower) / lower)
     }
-    main.pushToMain({ index, key: `${subPrefix}_height`, value: (decimals === null) ? heightValue : roundDecimalPlaces(heightValue, decimals) });
+    main.pushToMain({ index, key: `${prefix}_height${suffix}`, value: (decimals === null) ? heightValue : roundDecimalPlaces(heightValue, decimals) });
   }
 
   // Process each range property.
@@ -122,7 +121,7 @@ export const bollingerBands = (main, index, size, stdDev, { height, range = [],
     if (!Number.isNaN(priceValue) && !Number.isNaN(lower) && !Number.isNaN(upper)) {
       rangeValue = (priceValue - lower) / (upper - lower)
     }
-    main.pushToMain({ index, key: `${subPrefix}_range_${rangeKey}`, value: (decimals === null) ? rangeValue : roundDecimalPlaces(rangeValue, decimals) });
+    main.pushToMain({ index, key: `${prefix}_range_${rangeKey}${suffix}`, value: (decimals === null) ? rangeValue : roundDecimalPlaces(rangeValue, decimals) });
   }
 
   return true;

package/src/moving-averages/donchianChannel.js

@@ -2,7 +2,10 @@
 import { roundDecimalPlaces } from "../utilities/numberUtilities.js";
 
 export const donchianChannels = (main, index, size, offset, options) => {
-  const {verticalOhlcv, instances, len, inputParams, priceBased, arrayTypes, lag} = main
+
+  
+
+  const {verticalOhlcv, instances, len, inputParams, arrayTypes, lag} = main
   const { height: includeHeight, range: rangeKeys, decimals } = options
   const indicatorKey = `${size}_${offset}`
 
@@ -19,9 +22,9 @@ export const donchianChannels = (main, index, size, offset, options) => {
     const keys = ['upper', 'basis', 'lower'].map(n => `${prefix}_${n}`);
     if (includeHeight) keys.push(`${prefix}_height`);
     for (const rk of rangeKeys) {
-      if (!(rk in verticalOhlcv) || !priceBased.has(rk)) {
+      if (!(rk in verticalOhlcv)) {
         throw new Error(
-          `Invalid range key "${rk}". Only price-based keys are allowed: ${[...priceBased]}`
+          `Invalid range key "${rk}".`
         );
       }
       keys.push(`${prefix}_range_${rk}`);
@@ -44,7 +47,6 @@ export const donchianChannels = (main, index, size, offset, options) => {
     if (lag > 0) main.lag(keys, lag);
 
     // mark price-based outputs
-    ['upper','basis','lower'].forEach(n => priceBased.add(`${prefix}_${n}`));
     keys.forEach(k => arrayTypes[k] = 'Float64Array');
   }
 

package/src/moving-averages/macd.js

@@ -4,12 +4,14 @@ const defaultTarget = 'close';
 
 export const macd = (main, index, fast, slow, signal, {target, lag, precomputed}) => {
 
+  
+
   const { verticalOhlcv, instances } = main
   const {instanceKey} = precomputed
 
   // Initialization on the first index.
   if (index === 0) {
-    const { inputParams, crossPairsList, priceBased, len , arrayTypes} = main
+    const { inputParams, len , arrayTypes} = main
 
     if (!verticalOhlcv.hasOwnProperty(target)) {
       throw new Error(`Target property ${target} not found in verticalOhlcv for macd.`)
@@ -29,8 +31,6 @@ export const macd = (main, index, fast, slow, signal, {target, lag, precomputed}
     const deaKey = target === defaultTarget ? `${displayPrefix}_dea` : `${displayPrefix}_dea_${target}`
     const histogramKey = target === defaultTarget ? `${displayPrefix}_histogram` : `${displayPrefix}_histogram_${target}`
 
-    crossPairsList.push({ fast: diffKey, slow: deaKey, isDefault: true })
-
     if (!instances.hasOwnProperty('macd')) {
       instances.macd = {
         numberOfIndicators,
@@ -50,10 +50,6 @@ export const macd = (main, index, fast, slow, signal, {target, lag, precomputed}
       [histogramKey]: new Float64Array(len).fill(NaN),
     })
 
-    [diffKey, deaKey, histogramKey].forEach(v => {
-      priceBased.add(v)
-    })
-
     const keyNames = [diffKey, deaKey, histogramKey]
 
     if(lag > 0)

package/src/moving-averages/movingAverages.js

@@ -4,59 +4,56 @@ import {FasterEMA, FasterSMA} from 'trading-signals';
 const indicatorClasses = {
   ema: FasterEMA, 
   sma: FasterSMA
-} 
+}
+
+export const movingAverages = (main, index, methodName, size, { target, lag }) => {
+
+  
 
-export const movingAverages = (main, index, indicatorName, size, { target, lag, precomputed }) => {
   const { verticalOhlcv, instances } = main
-  const {keyName} = precomputed
+  const suffix = (target !== 'close') ?  `_${target}` : ''
+  const keyName = `${methodName}_${size}${suffix}`
 
   if (index === 0) {
 
+    const {arrayTypes, len} = main
+
     if (!verticalOhlcv.hasOwnProperty(target)) {
       throw new Error(
-        `Target property ${target} not found in verticalOhlcv for ${indicatorName}.`
+        `Target property ${target} not found in verticalOhlcv for ${methodName}.`
       );
     }
+
+    // Create the main moving average instance.
+    instances[keyName] = new indicatorClasses[methodName](size)
+
+    verticalOhlcv[keyName] = new Float64Array(len).fill(NaN)
+
+    if(lag > 0)
+    {
+      main.lag([keyName], lag)
+    }
+
+    arrayTypes[keyName] = 'Float64Array'
   }
 
-  // Retrieve the current price value.
+  // Retrieve the current price value
   const value = verticalOhlcv[target][index]
   const instance = instances[keyName]
 
   // Update the moving average instance.
-  instance.update(value);
-  let currMa = NaN;
+  instance.update(value)
+
+  let currMa = NaN
+
   try {
-    currMa = instance.getResult();
+    currMa = instance.getResult()
   } catch (err) {
 
   }
 
   // Always push the MA value (even if NaN).
-  main.pushToMain({ index, key: keyName, value: currMa });
-
-  return true;
-}
-
-export const precomputeMovingAverages = ({main, size, target, lag, methodName}) => {
-
-  const {instances, verticalOhlcv, priceBased, arrayTypes, len} = main
-  const suffix = (target !== 'close') ?  `_${target}` : ''
-  const keyName = `${methodName}_${size}${suffix}`
-
-    // Create the main moving average instance.
-    instances[keyName] = new indicatorClasses[methodName](size)
+  main.pushToMain({ index, key: keyName, value: currMa })
 
-    verticalOhlcv[keyName] = new Float64Array(len).fill(NaN)
-
-    priceBased.add(keyName)
-
-    if(lag > 0)
-    {
-      main.lag([keyName], lag)
-    }
-
-    arrayTypes[keyName] = 'Float64Array'
-  
-  return {keyName}
+  return true
 }

package/src/moving-averages/relativeVolume.js

@@ -2,6 +2,8 @@ import { FasterSMA } from 'trading-signals';
 
 export const relativeVolume = (main, index, size, {lag}) => {
 
+  
+
   const key = `relative_volume_${size}`;
   const { instances, verticalOhlcv } = main;