ohlcv-indicators 3.5.4 → 3.5.42

package/src/moving-averages/vidya.js

@@ -0,0 +1,181 @@
+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, arrayTypes, lag } = main;
+  const { target = 'close', atrLength = 200, bandDistance = 2, liquidityLookback = 20 } = options
+  const indicatorKey = `${size}_${momentum}`;
+
+  // Initialization on the first bar
+  if (index === 0) {
+    if (!(target in verticalOhlcv)) {
+      throw new Error(`VIDYA could not find target "${target}"`);
+    }
+
+    const prefix = `vidya_${indicatorKey}`;
+    const keyBase = target === 'close' ? prefix : `${prefix}_${target}`;
+    const keys = {
+      vidya: keyBase,
+      upper: `${prefix}_upper`, 
+      lower: `${prefix}_lower`,
+      delta_vol: `${prefix}_delta_vol`,
+      cross: `${prefix}_cross`,
+      liquidity: `${prefix}_liquidity`,
+    };
+
+    // Prepare instances container
+    if (!instances.vidya) instances.vidya = { settings: {} };
+    instances.vidya.settings[indicatorKey] = {
+      momentumBuffer: [], prevVidya: NaN,
+      sma: new FasterSMA(15), atrBuffer: [],
+      isTrendUp: false, upVol: 0, downVol: 0,
+      liquidity: {
+        high: [],
+        low: []
+      }
+    };
+
+    // Allocate output arrays
+    Object.values(keys).forEach(key => {
+      verticalOhlcv[key] = new Float64Array(len).fill(NaN);
+      arrayTypes[key] = 'Float64Array';
+    });
+    if (lag > 0) main.lag(Object.values(keys), lag);
+  }
+
+  // Per-bar computation
+  const inst = instances.vidya.settings[indicatorKey];
+  const prefix = `vidya_${indicatorKey}`;
+  const keyBase = target === 'close' ? prefix : `${prefix}_${target}`;
+  const keys = {
+    vidya: keyBase,
+    upper: `${prefix}_upper`, 
+    lower: `${prefix}_lower`,
+    delta_vol: `${prefix}_delta_vol`,
+    cross: `${prefix}_cross`,
+    liquidity: `${prefix}_liquidity`,
+  };
+
+  // Series inputs
+  const price = verticalOhlcv[target][index];
+  const high  = verticalOhlcv.high[index];
+  const low   = verticalOhlcv.low[index];
+  const close = verticalOhlcv.close[index];
+  const open  = verticalOhlcv.open[index];
+  const vol   = verticalOhlcv.volume[index];
+  const prevCross = index > 0 ? verticalOhlcv[keys.cross][index - 1] : 0;
+
+  const highest = (inst.liquidity.high.length === liquidityLookback) ? Math.max(...inst.liquidity.high) : NaN
+  const lowest = (inst.liquidity.low.length === liquidityLookback) ? Math.min(...inst.liquidity.low) : NaN
+
+  // Compute ATR (Wilder's RMA)
+  if (index > 0) {
+    const prevClose = verticalOhlcv.close[index - 1];
+    const tr = Math.max(
+      high - low,
+      Math.abs(high - prevClose),
+      Math.abs(low - prevClose)
+    );
+    inst.atrBuffer.push(tr);
+    if (inst.atrBuffer.length > atrLength) inst.atrBuffer.shift();
+  }
+  const atr = inst.atrBuffer.length === atrLength
+    ? inst.atrBuffer.reduce((a, b) => a + b, 0) / atrLength
+    : NaN;
+
+  // Compute raw VIDYA
+  let rawVidya = NaN;
+  let mom = NaN;
+  if (index > 0) mom = price - verticalOhlcv[target][index - 1];
+  inst.momentumBuffer.push(mom);
+  if (inst.momentumBuffer.length > momentum) inst.momentumBuffer.shift();
+  if (inst.momentumBuffer.length === momentum) {
+    let sumPos = 0, sumNeg = 0;
+    inst.momentumBuffer.forEach(m => m >= 0 ? sumPos += m : sumNeg += -m);
+    const denom = sumPos + sumNeg;
+    const cmo = denom === 0 ? 0 : Math.abs((sumPos - sumNeg) / denom) * 100;
+    const alpha = 2 / (size + 1);
+    const a = alpha * (cmo / 100);
+    rawVidya = isNaN(inst.prevVidya) ? price : (a * price + (1 - a) * inst.prevVidya);
+    inst.prevVidya = rawVidya;
+  }
+
+  // Smooth VIDYA using fixed 15-bar SMA
+  inst.sma.update(rawVidya);
+  let smoothedVidya = NaN;
+  try { smoothedVidya = inst.sma.getResult(); } catch {}
+
+  // Bands
+  const upper = (!isNaN(atr) && !isNaN(smoothedVidya))
+    ? smoothedVidya + atr * bandDistance
+    : NaN;
+  const lower = (!isNaN(atr) && !isNaN(smoothedVidya))
+    ? smoothedVidya - atr * bandDistance
+    : NaN;
+
+  // Detect crosses
+  const prevPrice = index > 0 ? verticalOhlcv[target][index - 1] : NaN;
+  const prevUpper = index > 0 ? verticalOhlcv[keys.upper][index - 1] : NaN;
+  const prevLower = index > 0 ? verticalOhlcv[keys.lower][index - 1] : NaN;
+  const crossUp   = index > 0 && prevPrice <= prevUpper && price > upper;
+  const crossDown = index > 0 && prevPrice >= prevLower && price < lower;
+
+  // Update trend state
+  if (crossUp) inst.isTrendUp = true;
+  if (crossDown) inst.isTrendUp = false;
+
+  // Cumulative cross counter: positive when uptrend, negative when downtrend
+  let cross = 0;
+  if (index > 0) {
+    if (inst.isTrendUp) {
+      cross = prevCross > 0 ? prevCross + 1 : 1;
+    } else {
+      cross = prevCross < 0 ? prevCross - 1 : -1;
+    }
+  }
+
+  // Volume accumulation
+  if (crossUp || crossDown) {
+    inst.upVol = inst.downVol = 0;
+  } else {
+    inst.upVol   += (close > open ? vol : 0);
+    inst.downVol += (close < open ? vol : 0);
+  }
+  const avgVol = (inst.upVol + inst.downVol) / 2 || 1;
+  const deltaPct = (inst.upVol - inst.downVol) / avgVol;
+
+  // Trend-based boundary (reset on crossover)
+  const trendValue = (!crossUp && !crossDown)
+    ? (inst.isTrendUp ? lower : upper)
+    : NaN;
+
+
+  let liquidity = NaN
+
+  if(cross > 0)
+  {
+    liquidity = lowest
+  }
+  else if(cross < 0)
+  {
+    liquidity = highest
+  }
+
+  console.log(keys.liquidity, liquidity)
+
+  // Push outputs
+  main.pushToMain({ index, key: keys.vidya, value: trendValue });
+  main.pushToMain({ index, key: keys.upper, value: upper });
+  main.pushToMain({ index, key: keys.lower, value: lower });
+  main.pushToMain({ index, key: keys.delta_vol, value: deltaPct });
+  main.pushToMain({ index, key: keys.cross, value: cross });
+  main.pushToMain({ index, key: keys.liquidity, value: liquidity });
+
+  inst.liquidity.high.push(high)
+  inst.liquidity.low.push(low)
+
+  if(inst.liquidity.high.length > liquidityLookback) inst.liquidity.high.shift()
+  if(inst.liquidity.low.length > liquidityLookback) inst.liquidity.low.shift()
+
+  return true;
+};

package/src/oscillators/rsi.js

@@ -2,41 +2,52 @@ import { FasterRSI } from 'trading-signals';
 import { FasterSMA } from 'trading-signals';
 
 const defaultTarget = 'close'
-export const rsi = (main, index, size, { target, lag }) => {
+export const rsi = (main, index, size, { target, lag, parser, prefix, minmax }) => {
+
+  
+  
   const { verticalOhlcv, instances } = main;
 
   const suffix = target === defaultTarget ? '' : `_${target}`;
-  const rsiKey = `rsi_${size}${suffix}`;
-  const rsiSmaKey = `rsi_sma_${size}${suffix}`;
+  const rsiKey = `${prefix}rsi_${size}${suffix}`;
+  const rsiSmaKey = `${prefix}rsi_sma_${size}${suffix}`;
 
   // Initialization on the first index.
   if (index === 0) {
 
-    const { crossPairsList, len, arrayTypes } = main;
+    const {len, arrayTypes } = main;
 
     if (!verticalOhlcv.hasOwnProperty(target)) {
       throw new Error(`Target property ${target} not found in verticalOhlcv for rsi.`);
     }
 
-    crossPairsList.push({ fast: rsiKey, slow: rsiSmaKey, isDefault: true });
-
     Object.assign(instances, {
       [rsiKey]: new FasterRSI(size),
       [rsiSmaKey]: new FasterSMA(size)
-    });
+    })
 
     Object.assign(verticalOhlcv, {
       [rsiKey]: new Float64Array(len).fill(NaN),
       [rsiSmaKey]: new Float64Array(len).fill(NaN),
-    });
-
+    })
 
+    const baseKeys = [rsiKey, rsiSmaKey]
 
-    const keyNames = [rsiKey, rsiSmaKey]
+    if (lag > 0) {
+      main.lag(baseKeys, lag);
+    }
 
-    if(lag > 0)
-    {
-      main.lag(keyNames, lag)
+    //[key, key_lag_1, …, key_lag_n] for each key
+    const keyNames = lag > 0
+      ? baseKeys.flatMap(key => [
+          key,
+          ...Array.from({ length: lag }, (_, i) => `${key}_lag_${i + 1}`)
+        ])
+      : baseKeys;
+
+    if (Array.isArray(minmax)) {
+      const group = main.scaledGroups.minmax_rsi ??= [];
+      group.push(...keyNames);
     }
 
     for(const key of keyNames)
@@ -61,7 +72,7 @@ export const rsi = (main, index, size, { target, lag }) => {
 
 
   // Always push the RSI value, using NaN as a fallback.
-  main.pushToMain({ index, key: rsiKey, value: currentRsi });
+  main.pushToMain({ index, key: rsiKey, value: (Number.isNaN(currentRsi)) ? NaN : parser(currentRsi) });
 
   // Update the SMA indicator only if a valid RSI value is available.
   if (!Number.isNaN(currentRsi)) {
@@ -75,5 +86,5 @@ export const rsi = (main, index, size, { target, lag }) => {
   }
 
   // Always push the smoothed RSI value.
-  main.pushToMain({ index, key: rsiSmaKey, value: smoothedRsi });
+  main.pushToMain({ index, key: rsiSmaKey, value: (Number.isNaN(smoothedRsi)) ? NaN : parser(smoothedRsi) });
 };

package/src/oscillators/stochastic.js

@@ -0,0 +1,74 @@
+import { FasterStochasticOscillator } from 'trading-signals';
+
+const defaultTarget = 'close'
+export const stochastic = (main, index, kPeriod, kSlowingPeriod, dPeriod, {minmax, prefix, lag, parser}) => {
+
+    
+
+    const { verticalOhlcv, instances, scaledGroups } = main;
+
+    const paramsKey = (kPeriod === 14 && kSlowingPeriod === 3 && dPeriod === 3) ? '' : `${kPeriod}_${kSlowingPeriod}_${dPeriod}`
+    const stochD = `${prefix}stoch_d${paramsKey}`;
+    const stochK = `${prefix}stoch_k${paramsKey}`;
+    const instanceKey = `${prefix}${paramsKey}`
+
+  // Initialization on the first index.
+    if (index === 0) {
+
+        const {len, arrayTypes } = main;
+
+        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);
+        }
+
+        //[key, key_lag_1, …, key_lag_n] for each key
+        const keyNames = lag > 0
+            ? baseKeys.flatMap(key => [
+                key,
+                ...Array.from({ length: lag }, (_, i) => `${key}_lag_${i + 1}`)
+            ])
+            : baseKeys;
+
+        if (Array.isArray(minmax)) {
+            const group = main.scaledGroups.minmax_rsi ??= [];
+            group.push(...keyNames)
+        }
+
+        for(const key of keyNames)
+        {
+            arrayTypes[key] = 'Float64Array'
+        }
+    }
+
+    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 kVal = stockObj ? parser(stockObj.stochK) : NaN
+    const dVal = stockObj ? parser(stockObj.stochD) : NaN
+
+    main.pushToMain({ index, key: stochK, value: kVal })
+    main.pushToMain({ index, key: stochD, value: dVal })
+
+}

package/src/oscillators/volumeOscillator.js

@@ -2,13 +2,15 @@ import { FasterEMA } from 'trading-signals';
 
 export const volumeOscillator = (main, index, fast, slow, {lag}) => {
 
+    
+
     const {verticalOhlcv, instances} = main
     const value = verticalOhlcv.volume[index]
     const key = `volume_oscillator_${fast}_${slow}`
 
     if (index === 0) {
 
-        const {crossPairsList, len, arrayTypes} = main
+        const {len, arrayTypes} = main
         Object.assign(instances, {
             [key]: {
                 fastEMA: new FasterEMA(fast),
@@ -17,7 +19,6 @@ export const volumeOscillator = (main, index, fast, slow, {lag}) => {
         })
 
         verticalOhlcv[key] = new Float64Array(len).fill(NaN)
-        crossPairsList.push({ fast: key, slow: 0, isDefault: true })
 
         if(lag > 0)
         {

package/src/studies/dateTime.js

@@ -1,96 +1,89 @@
-export const dateTime = (main, index, {lag}) => {
+import {oneHotEncode} from '../machine-learning/ml-utilities.js'
+
+export const dateTime = (main, index, {lag, oneHot, precompute}) => {
+
+    
+
+    const {instances, verticalOhlcv, notNumberKeys} = main
+    const {prefix} = precompute
 
-    const {instances, verticalOhlcv} = main
- 
     if(index === 0)
     {
         const {len, dateType, arrayTypes} = main
         if(!dateType) throw Error('dateTime method found and invalid "date" in input ohlcv')
 
+        const startYear = verticalOhlcv.date[0].getUTCFullYear()
+        const currentYear = new Date().getUTCFullYear()
+
         Object.assign(instances, {
             dateTime: {
-                prevDateStr: verticalOhlcv.date[0],
-                sessionDailyIndexCount: 0,
-                sessionIntradayIndexCount: 0,
-                cachedDayInfo: verticalOhlcv.date[0]
+                colKeys: [...precompute.colKeys, `${prefix}year`],
+                colKeySizes: {
+                    ...precompute.colKeySizes,
+                    [`${prefix}year`]: (currentYear - startYear) + 1
+                }
+                ,startYear
             }
         })
 
-        const colKeys = ['day_of_the_week', 'day_of_the_month', 'week_of_the_month', 'minute', 'hour', 'month', 'year', 'session_daily_index', 'session_intraday_index']
+        const { colKeys } = instances.dateTime
 
-        for(const key of colKeys)
-        {
-            arrayTypes[key] = 'Int32Array'
-        }
+        // choose your ctor, fill-value and type-name once
+        const ctor     = oneHot ? Array     : Int16Array
+        const fillVal  = oneHot ? null      : NaN
+        const typeName = oneHot ? 'Array'   : 'Int16Array'
+
+        // single loop instead of three
+        for (const key of colKeys) {
+        // 1) set the arrayType
+        arrayTypes[key] = typeName
 
-        Object.assign(verticalOhlcv, {...Object.fromEntries(colKeys.map(k => [k, new Int32Array(len).fill(NaN)]))})
+        // 2) allocate and fill the backing array
+        verticalOhlcv[key] = new ctor(len).fill(fillVal)
 
-        if(lag > 0)
-        {
-            main.lag(colKeys, lag)
+        // 3) mark as non-numeric
+        notNumberKeys.add(key)
+        }
+
+        // finally, apply lag once
+        if (lag > 0) {
+        main.lag(colKeys, lag)
         }
     }
 
+    const {colKeySizes, startYear} = instances.dateTime
 
     const currDate = verticalOhlcv.date[index]
 
-    const {
-        day_of_the_week,
-        day_of_the_month,
-        week_of_the_month,
-        month,
-        year,
-        hour,
-        minute
-    } = getDateInfo(currDate)
-
+    const dateInfo = getDateInfo(currDate, oneHot, colKeySizes, prefix, startYear)
 
-    const currDateStr = currDate
-
-    if(currDateStr !== instances.dateTime.prevDateStr)
+    for(const [key, value] of Object.entries(dateInfo))
     {
-        instances.dateTime.prevDateStr = currDateStr
-        instances.dateTime.sessionDailyIndexCount++
-        instances.dateTime.sessionIntradayIndexCount = 0
+        main.pushToMain({index, key, value})
     }
+}
 
-    
 
-    main.pushToMain({index, key: 'session_daily_index', value:  instances.dateTime.sessionDailyIndexCount})
-    main.pushToMain({index, key: 'session_intraday_index', value: instances.dateTime.sessionIntradayIndexCount})
-    main.pushToMain({index, key: 'day_of_the_week', value: day_of_the_week})
-    main.pushToMain({index, key: 'day_of_the_month', value: day_of_the_month})
-    main.pushToMain({index, key: 'week_of_the_month', value: week_of_the_month})
-    main.pushToMain({index, key: 'month', value: month})
-    main.pushToMain({index, key: 'year', value: year})
-    main.pushToMain({index, key: 'hour', value: hour})
-    main.pushToMain({index, key: 'minute', value: minute})
 
+const getDateInfo = (date, oneHot, colKeySizes, prefix, startYear) => {
 
-    instances.dateTime.sessionIntradayIndexCount++
+    const encode = (value, size) => (oneHot) ? oneHotEncode(value, size) : value
 
-}
+    const output = {
+        [`${prefix}year`]: date.getUTCFullYear(),
+        [`${prefix}month`]: date.getUTCMonth(),
+        [`${prefix}hour`]: date.getUTCHours(),
+        [`${prefix}minute`]: date.getUTCMinutes(),
+        [`${prefix}day_of_the_week`]: date.getUTCDay(),
+        [`${prefix}day_of_the_month`]: date.getUTCDate() - 1,
+    }
 
+    for(const [key, size] of Object.entries(colKeySizes))
+    {
+        const value = (key === `${prefix}year`) ? output[key] - startYear: output[key]
+        output[key] = encode(value, size)
+    }
 
+    return output
+}
 
-const getDateInfo = date => {
-    const month = date.getMonth()
-    const year = date.getFullYear()
-    const hour = date.getHours()
-    const minute = date.getMinutes()
-    const day_of_the_week = date.getDay();
-    const day_of_the_month = date.getDate();
-    const firstDayOfMonth = new Date(date.getFullYear(), date.getMonth(), 1)
-    const dayOffset = firstDayOfMonth.getDay();
-    const week_of_the_month = Math.ceil((day_of_the_month + dayOffset) / 7)
-
-    return {
-        month,
-        year,
-        hour,
-        minute,
-        day_of_the_week,
-        day_of_the_month,
-        week_of_the_month,
-    }
-}

package/src/studies/findCrosses.js

@@ -1,3 +1,5 @@
+import { oneHotEncode } from "../machine-learning/ml-utilities.js"
+import { buildArray } from "../utilities/assignTypes.js"
 const eq = (fast, slow) => fast === slow
 const gt = (fast, slow) => fast > slow
 const lt = (fast, slow) => fast < slow
@@ -130,77 +132,113 @@ class CrossInstance {
 
 }
 
-export const crossPairs = (main, index) => {
+export const crossPairs = (main, index, crossPairsList, {limit, oneHot}) => {
 
-    const {verticalOhlcv, instances, len, arrayTypes, verticalOhlcvTempCols} = main
+  const {verticalOhlcv, verticalOhlcvTempCols, instances, len, arrayTypes, notNumberKeys} = main
 
-    if(index === 0)
-    {
-        const {inputParams} = main
+  for (const { fast, slow } of crossPairsList) {
 
-        instances.crossPairsList = inputParams.reduce((acc, { key, params }) => {
-            if (key === 'crossPairs') {
-              for (const group of params) {
-                for (const pair of group) {
-                  acc.push(pair)
-                }
-              }
-            }
-            return acc;
-          }, [])
-    }
-
-    const {crossPairsList} = instances
+    const crossName = `${fast}_x_${slow}`
 
-    for (const { fast, slow } of crossPairsList)
+    if(index === 0)
     {
-        if (fast == null || slow == null) continue;
+        // allow numeric 'slow' as a constant column
+        if (typeof slow === 'number') {
 
-        let crossName = `${fast}_x_${slow}`
+            const col = slow.toString()
+            verticalOhlcvTempCols.add(col)
+            notNumberKeys.add(col)
 
-        if(index === 0)
-        {
-            if(typeof slow === 'number')
+            let slowNumArrType = 'Int16Array'
+
+            if(slow === 0 || slow === 1)
+            {
+                slowNumArrType = 'Uint8Array'
+            } else if(slow >= -125 && slow <= 125)
             {
-                verticalOhlcvTempCols.add(slow.toString())
-                verticalOhlcv[slow.toString()] = new Int32Array(len).fill(slow)
+                slowNumArrType = 'Int8Array'
             }
-            
-            if(fast !== 'price' && !verticalOhlcv.hasOwnProperty(fast)) throw Error(`fast "${fast} not found in crossPairs"`)
-            if(!verticalOhlcv.hasOwnProperty(slow)) throw Error(`slow "${slow} not found in crossPairs"`)
 
+            verticalOhlcv[col] =  buildArray(slowNumArrType, len)
+            arrayTypes[col] = 'slowNumArrType'
+        }
 
-            instances[crossName] = new CrossInstance()
-
-            verticalOhlcv[crossName] = new Int32Array(len).fill(NaN)
+        if(!instances.hasOwnProperty('crossPairs'))
+        {
+            instances.crossPairs = {}
+        }
 
-            arrayTypes[crossName] = 'Int32Array'
+        // create instance + output buffer
+        instances.crossPairs[crossName] = {
+            run: new CrossInstance(),
+            min: Infinity,
+            max: -Infinity
         }
 
-        let fastValue
-        let closeValue
-        let highValue
-        let lowValue
-        let slowValue
+        let crossArrType = 'Int16Array'
 
-        if(fast === 'price')
+        if(limit <= 125)
         {
-            closeValue = verticalOhlcv.close[index]
-            highValue = verticalOhlcv.high[index]
-            lowValue = verticalOhlcv.low[index]
-            slowValue = verticalOhlcv[slow][index]
-
-            instances[crossName].update(index, {fast: closeValue, slow: slowValue, high: highValue, low: lowValue})
+            crossArrType = 'Int8Array'
+        }
 
-        } else
+        verticalOhlcv[crossName] = buildArray(crossArrType, len)
+        
+        if(oneHot)
         {
-            fastValue = verticalOhlcv[fast][index]
-            slowValue = verticalOhlcv[slow][index]
+            verticalOhlcv[`one_hot_${crossName}`] = buildArray('Array', len)
+            notNumberKeys.add(`one_hot_${crossName}`)
+        }
 
-            instances[crossName].update(index, {fast: fastValue, slow: slowValue})
+        notNumberKeys.add(crossName)
+        
+        arrayTypes[crossName] = 'crossArrType'
+
+    }  else if(index + 1 === len) {
+        // sanity checks
+        if (fast !== "price" && !verticalOhlcv.hasOwnProperty(fast)) {
+            throw new Error(`crossPairs invalid param: fast "${fast}" not found in "verticalOhlcv": ${JSON.stringify(Object.keys(verticalOhlcv))}`)
+        }
+        if (!verticalOhlcv.hasOwnProperty(slow)) {
+            throw new Error(`crossPairs invalid param: slow "${slow}" not found in "verticalOhlcv": ${JSON.stringify(Object.keys(verticalOhlcv))}`)
         }
+    }
+    
+    if (fast !== "price" && !verticalOhlcv.hasOwnProperty(fast)) return
+    if (!verticalOhlcv.hasOwnProperty(slow)) return
+
+    const {run} = instances.crossPairs[crossName]
+
+    // ——— Per-bar update ———
+    if (fast === 'price') {
+      const fastVal = verticalOhlcv.close[index]
+      const slowVal = verticalOhlcv[slow][index]
+      run.update(index, {
+        fast: fastVal,
+        slow: slowVal,
+        high: verticalOhlcv.high[index],
+        low: verticalOhlcv.low[index],
+      });
+    } else {
+      const fastVal = verticalOhlcv[fast][index]
+      const slowVal = verticalOhlcv[slow][index]
+      run.update(index, { fast: fastVal, slow: slowVal })
+    }
+
+    const rawValue = run.getResult()
+
+    const value = Math.max(-limit, Math.min(limit, rawValue))
 
-        main.pushToMain({index, key: crossName, value: instances[crossName].getResult()})
+    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
 }