ohlcv-indicators 3.5.78 → 3.5.79

package/src/moving-averages/heikenAshi.js

@@ -1,4 +1,6 @@
-import { FasterEMA } from 'trading-signals';
+import { FasterEMA } from '../core-indicators/index.js';
+import { validateInputValues } from '../utilities/validators.js';
+import { initializeColumns } from '../core-functions/initializeColumns.js';
 
 const isBadNumber = v => v == null || !Number.isFinite(v);
 
@@ -9,7 +11,7 @@ export const heikenAshi = (
   afterSmoothLength,
   { lag = 0, bothNull = false, retLogs = true } = {}
 ) => {
-  const { verticalOhlcv, instances, len, scaledGroups } = main;
+  const { verticalOhlcv, instances, scaledGroups } = main;
   const indicatorKey = `${smoothLength}_${afterSmoothLength}`;
   const ohlcKeys = ['open', 'high', 'low', 'close'];
 
@@ -40,6 +42,8 @@ export const heikenAshi = (
 
   // ---- INIT ----
   if (index === 0) {
+    validateInputValues({ open: true, high: true, low: true, close: true }, verticalOhlcv, index, 'heikenAshi');
+
     instances[instanceKey] = {
       emaPre: !bothNull
         ? Object.fromEntries(ohlcKeys.map(k => [k, new FasterEMA(smoothLength)]))
@@ -56,19 +60,11 @@ export const heikenAshi = (
 
     const keyNames = featureKeys.map(getKey);
 
-    const verticalOhlcvSetup = Object.fromEntries(
-      [...keyNames, crossKey].map(k => [k, new Float64Array(len).fill(NaN)])
-    );
-
-    Object.assign(verticalOhlcv, verticalOhlcvSetup);
+    initializeColumns(main, [...keyNames, crossKey].map(key => ({ key })), { lag });
 
     if (scaledGroups) {
       scaledGroups.heikenAshi = keyNames;
     }
-
-    if (lag > 0) {
-      main.lag(keyNames, lag);
-    }
   }
 
   // ---- FETCH RAW INPUTS ----
@@ -84,7 +80,7 @@ export const heikenAshi = (
     isBadNumber(low) ||
     isBadNumber(close)
   ) {
-    return true;
+    return;
   }
 
   let sOpen, sHigh, sLow, sClose;
@@ -96,14 +92,12 @@ export const heikenAshi = (
     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();
-    } catch {
-      return true;
-    }
+    if (!inst.emaPre.open.isStable || !inst.emaPre.high.isStable ||
+        !inst.emaPre.low.isStable || !inst.emaPre.close.isStable) return;
+    sOpen = inst.emaPre.open.getResult();
+    sHigh = inst.emaPre.high.getResult();
+    sLow = inst.emaPre.low.getResult();
+    sClose = inst.emaPre.close.getResult();
   } else {
     sOpen = open;
     sHigh = high;
@@ -117,7 +111,7 @@ export const heikenAshi = (
     isBadNumber(sLow) ||
     isBadNumber(sClose)
   ) {
-    return true;
+    return;
   }
 
   // ---- HEIKEN ASHI CORE ----
@@ -145,14 +139,12 @@ export const heikenAshi = (
     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();
-    } catch {
-      return true;
-    }
+    if (!inst.emaPost.open.isStable || !inst.emaPost.high.isStable ||
+        !inst.emaPost.low.isStable || !inst.emaPost.close.isStable) return;
+    smOpen = inst.emaPost.open.getResult();
+    smHigh = inst.emaPost.high.getResult();
+    smLow = inst.emaPost.low.getResult();
+    smClose = inst.emaPost.close.getResult();
   } else {
     smOpen = haOpen;
     smHigh = haHigh;
@@ -170,7 +162,7 @@ export const heikenAshi = (
     smLow <= 0 ||
     smClose <= 0
   ) {
-    return true;
+    return;
   }
 
   // ---- TREND/CROSS LOGIC ----
@@ -229,6 +221,4 @@ export const heikenAshi = (
 
   // Do not add return logs to cross.
   main.pushToMain({ index, key: crossKey, value: cross });
-
-  return true;
-};
+};

package/src/moving-averages/macd.js

@@ -1,14 +1,18 @@
-import { FasterEMA, FasterMACD } from 'trading-signals'
+import { FasterEMA, FasterMACD } from '../core-indicators/index.js'
+import { validateInputValues } from '../utilities/validators.js'
+import { initializeColumns } from '../core-functions/initializeColumns.js'
 
 const defaultTarget = 'close'
 
 export const macd = (main, index, fast, slow, signal, { target, lag, precomputed }) => {
-  const { verticalOhlcv, instances, priceBased, useFullNames } = main
+  const { verticalOhlcv, instances, useFullNames } = main
   const { instanceKey } = precomputed
 
   // Initialization on the first index.
   if (index === 0) {
-    const { inputParams, len } = main
+    validateInputValues({ [target]: true }, verticalOhlcv, index, 'macd')
+
+    const { inputParams } = main
 
     if (!verticalOhlcv.hasOwnProperty(target)) {
       throw new Error(`Target property ${target} not found in verticalOhlcv for macd.`)
@@ -53,21 +57,8 @@ export const macd = (main, index, fast, slow, signal, { target, lag, precomputed
       new FasterEMA(signal)
     )
 
-    Object.assign(verticalOhlcv, {
-      [diffKey]: new Float64Array(len).fill(NaN),
-      [deaKey]: new Float64Array(len).fill(NaN),
-      [histogramKey]: new Float64Array(len).fill(NaN),
-    })
-
     const keyNames = [diffKey, deaKey, histogramKey]
-
-    for (const k of keyNames) {
-      priceBased.add(k)
-    }
-
-    if (lag > 0) {
-      main.lag(keyNames, lag)
-    }
+    initializeColumns(main, keyNames.map(key => ({ key, priceBased: true })), { lag })
   }
 
   const { numberOfIndicators, settings } = instances.macd
@@ -94,17 +85,10 @@ export const macd = (main, index, fast, slow, signal, { target, lag, precomputed
   const value = verticalOhlcv[target][index]
   macdInstance.update(value)
 
-  let macdResult = {}
-  try {
-    macdResult = macdInstance.getResult()
-  } catch (err) {
-    // If the result is unavailable, macdResult remains NaN.
-  }
+  const macdResult = macdInstance.isStable ? macdInstance.getResult() : null
 
   // Always push values; use NaN as fallback when macdResult is missing.
   main.pushToMain({ index, key: diffKey, value: macdResult ? macdResult.macd : NaN })
   main.pushToMain({ index, key: deaKey, value: macdResult ? macdResult.signal : NaN })
   main.pushToMain({ index, key: histogramKey, value: macdResult ? macdResult.histogram : NaN })
-
-  return true
-}
+}

package/src/moving-averages/movingAverages.js

@@ -1,5 +1,7 @@
 
-import {FasterEMA, FasterSMA} from 'trading-signals';
+import {FasterEMA, FasterSMA} from '../core-indicators/index.js';
+import { validateInputValues } from '../utilities/validators.js';
+import { initializeColumns } from '../core-functions/initializeColumns.js';
 
 const indicatorClasses = {
   ema: FasterEMA, 
@@ -13,8 +15,7 @@ export const movingAverages = (main, index, methodName, size, { target, lag }) =
   const keyName = `${methodName}_${size}${suffix}`
 
   if (index === 0) {
-
-    const {len} = main
+    validateInputValues({ [target]: true }, verticalOhlcv, index, methodName)
 
     if (!verticalOhlcv.hasOwnProperty(target)) {
       throw new Error(
@@ -25,16 +26,7 @@ export const movingAverages = (main, index, methodName, size, { target, lag }) =
     // Create the main moving average instance.
     instances[keyName] = new indicatorClasses[methodName](size)
 
-    verticalOhlcv[keyName] = new Float64Array(len).fill(NaN)
-
-    if(priceBased.has(target)){
-      priceBased.add(keyName)
-    }
-
-    if(lag > 0)
-    {
-      main.lag([keyName], lag)
-    }
+    initializeColumns(main, [{ key: keyName, priceBased: priceBased.has(target) }], { lag })
   }
 
   // Retrieve the current price value
@@ -44,16 +36,8 @@ export const movingAverages = (main, index, methodName, size, { target, lag }) =
   // Update the moving average instance.
   instance.update(value)
 
-  let currMa = NaN
-
-  try {
-    currMa = instance.getResult()
-  } catch (err) {
-
-  }
+  const currMa = instance.isStable ? instance.getResult() : NaN
 
   // Always push the MA value (even if NaN).
   main.pushToMain({ index, key: keyName, value: currMa })
-
-  return true
-}
+}

package/src/moving-averages/relativeVolume.js

@@ -1,48 +1,50 @@
-import { FasterSMA } from 'trading-signals';
+import { FasterSMA } from '../core-indicators/index.js';
+import { isPositiveInteger } from '../utilities/numberUtilities.js';
+import { validateInputValues } from '../utilities/validators.js';
+import { initializeColumns } from '../core-functions/initializeColumns.js';
+
 
 export const relativeVolume = (main, index, size, {lag}) => {
 
   const key = `relative_volume_${size}`;
   const { instances, verticalOhlcv } = main;
+  
 
   if (index === 0) {
-    const { len } = main;
+    validateInputValues({ volume: true }, verticalOhlcv, index, 'relativeVolume');
 
     instances[key] = {
       instance: new FasterSMA(size),
       prevRelativeVolumeSma: NaN
     };
     
-    verticalOhlcv[key] = new Float64Array(len).fill(NaN);
-
-    if(lag > 0)
-    {
-      main.lag([key], lag)
-    }
+    initializeColumns(main, [{ key }], { lag });
 
   }
 
-  const value = verticalOhlcv.volume[index];
-  const smaInstance = instances[key].instance;
-  smaInstance.update(value);
-
-  let smaValue = NaN;
-  try {
-    smaValue = smaInstance.getResult();
-  } catch (err) {
+  const volume = verticalOhlcv.volume[index];
 
+  if(volume === 0) {
+    return;
   }
+  
+  const smaInstance = instances[key].instance;
+  smaInstance.update(volume);
+
+  const smaValue = smaInstance.isStable ? smaInstance.getResult() : NaN;
 
   const prevSma = instances[key].prevRelativeVolumeSma;
-  let currRelativeVolume = NaN;
 
-  // Only calculate relative volume if both current SMA and previous SMA are valid numbers and prevSma is not zero.
-  if (!Number.isNaN(smaValue) && !Number.isNaN(prevSma)) {
-    currRelativeVolume = value / prevSma;
+  // Save the current SMA for the next nonzero-volume row.
+  instances[key].prevRelativeVolumeSma = smaValue;
+
+  if(Number.isNaN(smaValue) || Number.isNaN(prevSma)) {
+    return
   }
 
+  let currRelativeVolume =  volume / prevSma;
+
   main.pushToMain({ index, key, value: currRelativeVolume });
   instances[key].prevRelativeVolumeSma = smaValue;
 
-  return true;
 };

package/src/oscillators/rsi.js

@@ -1,6 +1,7 @@
-import { FasterRSI } from 'trading-signals';
-import { FasterSMA } from 'trading-signals';
+import { FasterRSI, FasterSMA } from '../core-indicators/index.js';
 import { mathLog } from '../utilities/math.js';
+import { validateInputValues } from '../utilities/validators.js';
+import { initializeColumns } from '../core-functions/initializeColumns.js';
 
 const defaultTarget = 'close'
 export const rsi = (main, index, size, { target, lag, retLogs }) => {
@@ -15,8 +16,7 @@ export const rsi = (main, index, size, { target, lag, retLogs }) => {
 
   // Initialization on the first index.
   if (index === 0) {
-
-    const {len } = main;
+    validateInputValues({ [target]: true }, verticalOhlcv, index, 'rsi');
 
     if (!verticalOhlcv.hasOwnProperty(target)) {
       throw new Error(`Target property ${target} not found in verticalOhlcv for rsi.`);
@@ -27,32 +27,17 @@ export const rsi = (main, index, size, { target, lag, retLogs }) => {
       [rsiSmaKey]: new FasterSMA(size)
     })
 
-    Object.assign(verticalOhlcv, {
-      [rsiKey]: new Float64Array(len).fill(NaN),
-      [rsiSmaKey]: new Float64Array(len).fill(NaN),
-    })
-
-    const baseKeys = [rsiKey, rsiSmaKey]
-
-    if (lag > 0) {
-      main.lag(baseKeys, lag);
-    }
+    initializeColumns(main, [{ key: rsiKey }, { key: rsiSmaKey }], { lag });
 
 
   }
 
   const value = verticalOhlcv[target][index];
-  let currentRsi = NaN;
-  let smoothedRsi = NaN;
 
   // Update the RSI indicator.
   instances[rsiKey].update(value);
 
-  try {
-    currentRsi = instances[rsiKey].getResult();
-  } catch (err) {
-    currentRsi = NaN;
-  }
+  const currentRsi = instances[rsiKey].isStable ? instances[rsiKey].getResult() : NaN;
 
 
     const rsiVal = Number.isNaN(currentRsi) ? NaN : (retLogs ? mathLog(currentRsi, 50) : currentRsi)
@@ -63,11 +48,7 @@ export const rsi = (main, index, size, { target, lag, retLogs }) => {
       instances[rsiSmaKey].update(currentRsi);
     }
 
-    try {
-      smoothedRsi = instances[rsiSmaKey].getResult();
-    } catch (err) {
-      smoothedRsi = NaN;
-    }
+    const smoothedRsi = instances[rsiSmaKey].isStable ? instances[rsiSmaKey].getResult() : NaN;
 
     const smoothedRsiVal = Number.isNaN(smoothedRsi) ? NaN : (retLogs ? mathLog(smoothedRsi, 50) : smoothedRsi)
 

package/src/oscillators/stochastic.js

@@ -1,5 +1,7 @@
-import { FasterStochasticOscillator } from 'trading-signals';
+import { FasterStochasticOscillator } from '../core-indicators/index.js';
 import { mathLog } from '../utilities/math.js';
+import { validateInputValues } from '../utilities/validators.js';
+import { initializeColumns } from '../core-functions/initializeColumns.js';
 
 export const stochastic = (main, index, kPeriod, kSlowingPeriod, dPeriod, {lag, retLogs}) => {
 
@@ -13,39 +15,24 @@ export const stochastic = (main, index, kPeriod, kSlowingPeriod, dPeriod, {lag,
 
   // Initialization on the first index.
     if (index === 0) {
-
-        const {len } = main;
+        validateInputValues({ high: true, low: true, close: true }, verticalOhlcv, index, 'stochastic');
 
         Object.assign(instances, {
             [instanceKey]: new FasterStochasticOscillator(kPeriod, kSlowingPeriod, dPeriod)
         })
 
-        Object.assign(verticalOhlcv, {
-            [stochD]: new Float64Array(len).fill(NaN),
-            [stochK]: new Float64Array(len).fill(NaN),
-        })
-
-        const baseKeys = [stochD, stochK]
-
-        if (lag > 0) {
-            main.lag(baseKeys, lag);
-        }
+        initializeColumns(main, [{ key: stochD }, { key: stochK }], { lag });
 
     }
 
     const close = verticalOhlcv['close'][index]
     const low = verticalOhlcv['low'][index]
     const high = verticalOhlcv['high'][index]
-    let stockObj = null
 
   // Update the stochastic indicator.
     instances[instanceKey].update({close, low, high})
 
-    try {
-        stockObj = instances[instanceKey].getResult()
-    } catch (err) {
-        stockObj = null
-    }
+    const stockObj = instances[instanceKey].isStable ? instances[instanceKey].getResult() : null
 
     const kVal = stockObj ? (retLogs ? mathLog(stockObj.stochK, 50) : stockObj.stochK) : NaN
     const dVal = stockObj ? (retLogs ? mathLog(stockObj.stochD, 50) : stockObj.stochD) : NaN

package/src/oscillators/volumeDelta.js

@@ -1,29 +1,41 @@
+import { isPositiveInteger } from '../utilities/numberUtilities.js';
+import { validateInputValues } from '../utilities/validators.js';
+import { initializeColumns } from '../core-functions/initializeColumns.js';
+
+
 export const volumeDelta = (main, index, { lag = 0 }) => {
-  const { verticalOhlcv, instances, len } = main;
-  const groupName = 'volume_delta';
+  const { verticalOhlcv, instances } = main;
+  const key = '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`,
-    ];
+    validateInputValues({ open: true, close: true, volume: true }, verticalOhlcv, index, 'volumeDelta');
 
-    // allocate outputs
-    for (const k of keys) verticalOhlcv[k] = new Float64Array(len).fill(NaN);
+    if (!instances[key]) {
+      instances[key] = { isBuyVolume: true, cross: 0};
+    }
+
+    const keyNames = [
+      `${key}_high`,
+      `${key}_low`,
+      `${key}_close`,
+      `${key}_cross`,
+    ];
 
-    // optional lag
-    if (lag > 0) main.lag(keys, lag);
+    initializeColumns(main, keyNames.map(key => ({ key })), { lag });
   }
 
-  const inst = instances[groupName];
+  const inst = instances[key];
+
+  const {hasInvalidInputValue} = inst
 
   // inputs
-  const vol       = verticalOhlcv.volume[index];
+  const volume = verticalOhlcv.volume[index];
+
+  if(volume === 0) {
+    return;
+  }
+
+
   const open      = verticalOhlcv.open[index];
   const close     = verticalOhlcv.close[index];
   const prevClose = index > 0 ? verticalOhlcv.close[index - 1] : NaN;
@@ -55,20 +67,16 @@ export const volumeDelta = (main, index, { lag = 0 }) => {
     }
   }
   
-
-  const delta = Number.isFinite(vol) ? (isBuy ? vol : -vol) : NaN;
+  const delta = isBuy ? volume : -volume;
 
   // 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);
+  const highVal  = Math.max(delta, 0);
+  const lowVal   = 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 });
+  main.pushToMain({ index, key: `${key}_high`,  value: highVal });
+  main.pushToMain({ index, key: `${key}_low`,   value: lowVal });
+  main.pushToMain({ index, key: `${key}_close`, value: closeVal });
+  main.pushToMain({ index, key: `${key}_cross`, value: inst.cross });
 
-  return true;
 };

package/src/oscillators/volumeOscillator.js

@@ -1,59 +1,57 @@
-import { FasterEMA } from 'trading-signals';
+import { FasterEMA } from '../core-indicators/index.js';
+import { mathLog } from '../utilities/math.js';
+import { isPositiveInteger } from '../utilities/numberUtilities.js';
+import { validateInputValues } from '../utilities/validators.js';
+import { initializeColumns } from '../core-functions/initializeColumns.js';
 
-export const volumeOscillator = (main, index, fast, slow, {lag}) => {
-
-    
+export const volumeOscillator = (main, index, fast, slow, {lag, retLogs}) => {
 
     const {verticalOhlcv, instances} = main
-    const value = verticalOhlcv.volume[index]
     const key = `volume_oscillator_${fast}_${slow}`
 
     if (index === 0) {
+        validateInputValues({ volume: true }, verticalOhlcv, index, 'volumeOscillator');
 
-        const {len} = main
         Object.assign(instances, {
             [key]: {
                 fastEMA: new FasterEMA(fast),
-                slowEMA: new FasterEMA(slow)
+                slowEMA: new FasterEMA(slow),
             }
         })
 
-        verticalOhlcv[key] = new Float64Array(len).fill(NaN)
-
-        if(lag > 0)
-        {
-            main.lag([key], lag)
-        }
+        initializeColumns(main, [
+            { key },
+            { key: `ret_log_${key}`, enabled: retLogs }
+        ], { lag });
     }
 
     const { fastEMA, slowEMA } = instances[key];
 
-    fastEMA.update(value);
-    slowEMA.update(value);
+    const volume = verticalOhlcv.volume[index];
 
-    let fastValue = NaN;
-    let slowValue = NaN;
-
-    try {
-        fastValue = fastEMA.getResult();
-    } catch (err) {
-        
+    if(volume === 0) {
+        return;
     }
 
-    try {
-        slowValue = slowEMA.getResult();
-    } catch (err) {
+    fastEMA.update(volume);
+    slowEMA.update(volume);
 
-    }
+    const fastValue = fastEMA.isStable ? fastEMA.getResult() : NaN;
+    const slowValue = slowEMA.isStable ? slowEMA.getResult() : NaN;
 
     let volumeOscValue = NaN
+    let volumeOscRetLog = NaN
 
-    if(!Number.isNaN(fastValue) && !Number.isNaN(slowValue))
-    {
-        volumeOscValue = 100 * (fastValue - slowValue) / slowValue
+    if(Number.isNaN(fastValue) || Number.isNaN(slowValue)) {
+        return;
     }
 
-    main.pushToMain({index, key, value:  volumeOscValue})
+    volumeOscValue = 100 * (fastValue - slowValue) / slowValue
+
+    if(retLogs) {
+        volumeOscRetLog = mathLog(fastValue, slowValue)
+        main.pushToMain({index, key: `ret_log_${key}`, value:  volumeOscRetLog})
+    }
 
-    return true;
+    main.pushToMain({index, key, value:  volumeOscValue})
 };

package/src/studies/candleFeatures.js

@@ -1,4 +1,5 @@
-
+import { validateInputValues } from '../utilities/validators.js'
+import { initializeColumns } from '../core-functions/initializeColumns.js'
 
 const isBadNumber = (v) => v == null || !Number.isFinite(v)
 
@@ -9,19 +10,16 @@ export const candleFeatures  = (main, index, {lag, colKeys, retLogs}) => {
     const prefix = (retLogs) ? 'ret_log_' : 'ret_'
 
     if(index === 0) {
-        const {len} = main
-        
-        const newCols = {
-            [`${prefix}change`]: new Float64Array(len).fill(NaN),
-            [`${prefix}mid_price_change`]: new Float64Array(len).fill(NaN),
-            [`${prefix}upper_wick`]: new Float64Array(len).fill(NaN),
-            [`${prefix}lower_wick`]: new Float64Array(len).fill(NaN),
-            [`${prefix}gap`]: new Float64Array(len).fill(NaN),
-            [`${prefix}body`]: new Float64Array(len).fill(NaN),
-            [`${prefix}range`]: new Float64Array(len).fill(NaN)
-        }
+        validateInputValues({ open: true, high: true, low: true, close: true }, verticalOhlcv, index, 'candleFeatures')
+
+        const columns = [
+            'change', 'mid_price_change', 'upper_wick', 'lower_wick',
+            'gap', 'body', 'range'
+        ].map(name => ({ key: `${prefix}${name}` }))
 
         for(const target of colKeys) {
+            validateInputValues({ [target]: true }, verticalOhlcv, index, 'candleFeatures')
+
             if(!verticalOhlcv.hasOwnProperty(target)) {
                 throw new Error(
                     `Target property in "options.colKey" array "${target}" not found in verticalOhlcv for "candleFeatures".`
@@ -34,16 +32,10 @@ export const candleFeatures  = (main, index, {lag, colKeys, retLogs}) => {
                 );               
             }
 
-            newCols[`${prefix}${target}`] = new Float64Array(len).fill(NaN)
+            columns.push({ key: `${prefix}${target}` })
         }
 
-        Object.assign(verticalOhlcv, newCols)
-
-        scaledGroups.candleFeatures = Object.keys(newCols)
-
-        if(lag) {
-            main.lag(Object.keys(newCols), lag)
-        }
+        scaledGroups.candleFeatures = initializeColumns(main, columns, { lag })
     }
 
     const prevClose = verticalOhlcv.close[index - 1]