ohlcv-indicators 3.5.79 → 3.5.82

package/src/moving-averages/heikenAshi.js

@@ -1,65 +1,53 @@
 import { FasterEMA } from '../core-indicators/index.js';
 import { validateInputValues } from '../utilities/validators.js';
 import { initializeColumns } from '../core-functions/initializeColumns.js';
-
+import { mathLog } from '../utilities/math.js';
 const isBadNumber = v => v == null || !Number.isFinite(v);
+const arithmeticReturn = (next, prev) => (next - prev) / prev;
+
 
 export const heikenAshi = (
   main,
   index,
   smoothLength,
   afterSmoothLength,
-  { lag = 0, bothNull = false, retLogs = true } = {}
+  { lag = 0, noSmoothing = false, retLogs = false } = {}
 ) => {
   const { verticalOhlcv, instances, scaledGroups } = main;
-  const indicatorKey = `${smoothLength}_${afterSmoothLength}`;
-  const ohlcKeys = ['open', 'high', 'low', 'close'];
-
-  const getRet = (next, prev) => retLogs
-    ? Math.log(next / prev)
-    : (next - prev) / prev;
-
-  const prefix = retLogs ? 'ret_log_' : 'ret_';
-
-  const paramsKey = bothNull ? '' : `_${indicatorKey}`;
-
-  const getKey = key => `${prefix}heiken_ashi_${key}${paramsKey}`;
-
-  const featureKeys = [
-    'body',
-    'upper_wick',
-    'lower_wick',
-    'range'
-  ];
-
-  const crossKey = bothNull
-    ? 'heiken_ashi_cross'
-    : `heiken_ashi_cross_${indicatorKey}`;
-
-  const instanceKey = bothNull
+  const instanceKey = noSmoothing
     ? 'heiken_ashi'
-    : `heiken_ashi_${indicatorKey}`;
+    : `heiken_ashi_${smoothLength}_${afterSmoothLength}`;
 
   // ---- INIT ----
   if (index === 0) {
     validateInputValues({ open: true, high: true, low: true, close: true }, verticalOhlcv, index, 'heikenAshi');
+    const ohlcKeys = ['open', 'high', 'low', 'close'];
+    const featureKeys = ['body', 'upper_wick', 'lower_wick', 'range'];
+    const paramsKey = noSmoothing ? '' : `_${smoothLength}_${afterSmoothLength}`;
+    const prefix = retLogs ? 'ret_log_' : 'ret_';
+    const outputKeys = Object.fromEntries(
+      featureKeys.map(key => [key, `${prefix}heiken_ashi_${key}${paramsKey}`])
+    );
+    const crossKey = `heiken_ashi_cross${paramsKey}`;
+    const keyNames = Object.values(outputKeys);
 
     instances[instanceKey] = {
-      emaPre: !bothNull
+      emaPre: !noSmoothing
         ? Object.fromEntries(ohlcKeys.map(k => [k, new FasterEMA(smoothLength)]))
         : null,
-      emaPost: !bothNull
+      emaPost: !noSmoothing
         ? Object.fromEntries(ohlcKeys.map(k => [k, new FasterEMA(afterSmoothLength)]))
         : null,
       prevHaOpen: NaN,
       prevHaClose: NaN,
       prevSmOpen: NaN,
       prevSmClose: NaN,
-      isTrendUp: false,
+      trendDirection: 0,
+      getRet: retLogs ? mathLog : arithmeticReturn,
+      outputKeys,
+      crossKey
     };
 
-    const keyNames = featureKeys.map(getKey);
-
     initializeColumns(main, [...keyNames, crossKey].map(key => ({ key })), { lag });
 
     if (scaledGroups) {
@@ -73,6 +61,7 @@ export const heikenAshi = (
   const low = verticalOhlcv.low[index];
   const close = verticalOhlcv.close[index];
   const inst = instances[instanceKey];
+  const { crossKey, emaPre, emaPost, getRet, outputKeys } = inst;
 
   if (
     isBadNumber(open) ||
@@ -85,19 +74,19 @@ export const heikenAshi = (
 
   let sOpen, sHigh, sLow, sClose;
 
-  if (!bothNull) {
+  if (emaPre !== null) {
     // ---- PRE-SMOOTHING EMA ----
-    inst.emaPre.open.update(open);
-    inst.emaPre.high.update(high);
-    inst.emaPre.low.update(low);
-    inst.emaPre.close.update(close);
-
-    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();
+    emaPre.open.update(open);
+    emaPre.high.update(high);
+    emaPre.low.update(low);
+    emaPre.close.update(close);
+
+    if (!emaPre.open.isStable || !emaPre.high.isStable ||
+        !emaPre.low.isStable || !emaPre.close.isStable) return;
+    sOpen = emaPre.open.getResult();
+    sHigh = emaPre.high.getResult();
+    sLow = emaPre.low.getResult();
+    sClose = emaPre.close.getResult();
   } else {
     sOpen = open;
     sHigh = high;
@@ -132,19 +121,19 @@ export const heikenAshi = (
 
   let smOpen, smHigh, smLow, smClose;
 
-  if (!bothNull) {
+  if (emaPost !== null) {
     // ---- POST-SMOOTHING EMA ----
-    inst.emaPost.open.update(haOpen);
-    inst.emaPost.high.update(haHigh);
-    inst.emaPost.low.update(haLow);
-    inst.emaPost.close.update(haClose);
-
-    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();
+    emaPost.open.update(haOpen);
+    emaPost.high.update(haHigh);
+    emaPost.low.update(haLow);
+    emaPost.close.update(haClose);
+
+    if (!emaPost.open.isStable || !emaPost.high.isStable ||
+        !emaPost.low.isStable || !emaPost.close.isStable) return;
+    smOpen = emaPost.open.getResult();
+    smHigh = emaPost.high.getResult();
+    smLow = emaPost.low.getResult();
+    smClose = emaPost.close.getResult();
   } else {
     smOpen = haOpen;
     smHigh = haHigh;
@@ -167,57 +156,49 @@ export const heikenAshi = (
 
   // ---- TREND/CROSS LOGIC ----
   // Cross uses raw smoothed HA values, not the returned log/return features.
-  const prevCross = index > 0 ? verticalOhlcv[crossKey][index - 1] : 0;
-  const prevSmOpen = inst.prevSmOpen;
-  const prevSmClose = inst.prevSmClose;
-
-  const crossUp = (
-    Number.isFinite(prevSmOpen) &&
-    Number.isFinite(prevSmClose) &&
-    prevSmClose <= prevSmOpen &&
-    smClose > smOpen
-  );
-
-  const crossDown = (
-    Number.isFinite(prevSmOpen) &&
-    Number.isFinite(prevSmClose) &&
-    prevSmClose >= prevSmOpen &&
-    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;
-    }
+  const hasPrevious = (
+    Number.isFinite(inst.prevSmOpen) &&
+    Number.isFinite(inst.prevSmClose)
+  )
+
+  const prevCross = index > 0
+    ? verticalOhlcv[crossKey][index - 1]
+    : NaN
+
+  // A doji preserves the established direction.
+  // Before any direction exists, it remains neutral.
+  const direction = smClose > smOpen
+    ? 1
+    : smClose < smOpen
+      ? -1
+      : inst.trendDirection
+
+  let cross = 0
+
+  if (hasPrevious && direction !== 0) {
+    cross = Number.isFinite(prevCross) &&
+            Math.sign(prevCross) === direction
+      ? prevCross + direction
+      : direction
   }
 
-  // Store previous raw smoothed HA values after cross calculation.
-  inst.prevSmOpen = smOpen;
-  inst.prevSmClose = smClose;
+  inst.trendDirection = direction
+  inst.prevSmOpen = smOpen
+  inst.prevSmClose = smClose
 
   // ---- HEIKEN ASHI STRUCTURE RETURNS ----
   const bodyTop = Math.max(smOpen, smClose);
   const bodyBottom = Math.min(smOpen, smClose);
 
-  const row = {
-    [getKey('body')]: getRet(smClose, smOpen),
-    [getKey('upper_wick')]: getRet(smHigh, bodyTop),
-    [getKey('lower_wick')]: getRet(bodyBottom, smLow),
-    [getKey('range')]: getRet(smHigh, smLow),
-  };
+  const body = getRet(smClose, smOpen);
+  const upperWick = getRet(smHigh, bodyTop);
+  const lowerWick = getRet(bodyBottom, smLow);
+  const range = getRet(smHigh, smLow);
 
-  for (const [key, value] of Object.entries(row)) {
-    if (!isBadNumber(value)) {
-      main.pushToMain({ index, key, value });
-    }
-  }
+  if (!isBadNumber(body)) main.pushToMain({ index, key: outputKeys.body, value: body });
+  if (!isBadNumber(upperWick)) main.pushToMain({ index, key: outputKeys.upper_wick, value: upperWick });
+  if (!isBadNumber(lowerWick)) main.pushToMain({ index, key: outputKeys.lower_wick, value: lowerWick });
+  if (!isBadNumber(range)) main.pushToMain({ index, key: outputKeys.range, value: range });
 
   // Do not add return logs to cross.
   main.pushToMain({ index, key: crossKey, value: cross });

package/src/moving-averages/movingAverages.js

@@ -2,17 +2,21 @@
 import {FasterEMA, FasterSMA} from '../core-indicators/index.js';
 import { validateInputValues } from '../utilities/validators.js';
 import { initializeColumns } from '../core-functions/initializeColumns.js';
+import { mathLog } from '../utilities/math.js';
+
+const isBadNumber = v => v == null || !Number.isFinite(v);
+
 
 const indicatorClasses = {
   ema: FasterEMA, 
   sma: FasterSMA
 }
 
-export const movingAverages = (main, index, methodName, size, { target, lag }) => {
+export const movingAverages = (main, index, methodName, size, { target, lag, retLogs = false }) => {
 
   const { verticalOhlcv, instances, priceBased } = main
   const suffix = (target !== 'close') ?  `_${target}` : ''
-  const keyName = `${methodName}_${size}${suffix}`
+  const keyName = `${retLogs ? 'ret_log_' : ''}${methodName}_${size}${suffix}`
 
   if (index === 0) {
     validateInputValues({ [target]: true }, verticalOhlcv, index, methodName)
@@ -26,18 +30,49 @@ export const movingAverages = (main, index, methodName, size, { target, lag }) =
     // Create the main moving average instance.
     instances[keyName] = new indicatorClasses[methodName](size)
 
-    initializeColumns(main, [{ key: keyName, priceBased: priceBased.has(target) }], { lag })
+    if(retLogs) {
+      initializeColumns(main, [
+        { key: `${keyName}_distance`, priceBased: false },
+        { key: `${keyName}_change`, priceBased: false }
+      ], { lag })
+    } else {
+      initializeColumns(main, [{ key: keyName, priceBased: priceBased.has(target) }], { lag })
+    }
+    
   }
 
   // Retrieve the current price value
-  const value = verticalOhlcv[target][index]
-  const instance = instances[keyName]
+  const currVal = verticalOhlcv[target][index];
+
+
+  if(isBadNumber(currVal)) return;
+
+  const instance = instances[keyName];
+
+  //The easiest way to compute prevMa change is to retrieve the previous result before updating the indicator.
+  const prevMa = instance.isStable ? instance.getResult() : NaN;
 
   // Update the moving average instance.
-  instance.update(value)
+  instance.update(currVal)
+
+  const currMa = instance.isStable ? instance.getResult() : NaN;
 
-  const currMa = instance.isStable ? instance.getResult() : NaN
+  if(isBadNumber(currMa)) return;
+
+  if (retLogs) {
+
+    const ratio = currVal / currMa;
+    const distance = mathLog(currVal, currMa);
+
+    main.pushToMain({ index, key: `${keyName}_distance`, value: distance })
+
+    if(isBadNumber(prevMa)) return;
+
+    const change = mathLog(currMa, prevMa);
+
+    main.pushToMain({ index, key: `${keyName}_change`, value: change })
+  } else {
+    main.pushToMain({ index, key: keyName, value: currMa })
+  }
 
-  // Always push the MA value (even if NaN).
-  main.pushToMain({ index, key: keyName, value: currMa })
 }

package/src/moving-averages/relativeVolume.js

@@ -1,12 +1,12 @@
 import { FasterSMA } from '../core-indicators/index.js';
-import { isPositiveInteger } from '../utilities/numberUtilities.js';
+import { mathLog } from '../utilities/math.js';
 import { validateInputValues } from '../utilities/validators.js';
 import { initializeColumns } from '../core-functions/initializeColumns.js';
 
 
-export const relativeVolume = (main, index, size, {lag}) => {
+export const relativeVolume = (main, index, size, {lag, retLogs = false}) => {
 
-  const key = `relative_volume_${size}`;
+  const key = `${retLogs ? 'ret_log_' : ''}relative_volume_${size}`;
   const { instances, verticalOhlcv } = main;
   
 
@@ -42,9 +42,13 @@ export const relativeVolume = (main, index, size, {lag}) => {
     return
   }
 
-  let currRelativeVolume =  volume / prevSma;
+  const ratio = volume / prevSma;
+  const currRelativeVolume = retLogs
+    ? volume > 0 && prevSma > 0 && ratio > 0 && Number.isFinite(ratio)
+      ? mathLog(ratio, 1)
+      : NaN
+    : ratio;
 
   main.pushToMain({ index, key, value: currRelativeVolume });
-  instances[key].prevRelativeVolumeSma = smaValue;
 
 };

package/src/oscillators/mfi.js

@@ -0,0 +1,56 @@
+import { mathLog } from '../utilities/math.js';
+import { validateInputValues } from '../utilities/validators.js';
+import { initializeColumns } from '../core-functions/initializeColumns.js';
+
+export const mfi = (main, index, size, { lag, retLogs }) => {
+    const { verticalOhlcv, instances } = main;
+    const key = `${retLogs ? 'ret_log_' : ''}mfi_${size}`;
+
+    if (index === 0) {
+        validateInputValues({ high: true, low: true, close: true, volume: true }, verticalOhlcv, index, 'mfi');
+        // Raw and logged variants own separate state, even at the same period.
+        initializeColumns(main, [{ key }], { lag });
+        instances[key] = {
+            flows: new Float64Array(size),
+            next: 0,
+            count: 0,
+            previousTypical: NaN
+        };
+    }
+
+    const state = instances[key];
+    const typical = (verticalOhlcv.high[index] + verticalOhlcv.low[index] + verticalOhlcv.close[index]) / 3;
+    const change = typical - state.previousTypical;
+    state.previousTypical = typical;
+
+    // The first candle seeds the comparison; a size-period MFI needs size + 1 rows.
+    if (index === 0) return;
+
+    const flow = typical * verticalOhlcv.volume[index];
+    // A tie is neutral, but an invalid comparison must not silently become zero.
+    // Zero-volume candles contribute zero and still advance the candle window.
+    state.flows[state.next] = Number.isFinite(change) && Number.isFinite(flow) && flow >= 0
+        ? Math.sign(change) * flow : NaN;
+    state.next = (state.next + 1) % size;
+    if (state.count < size) state.count++;
+    if (state.count < size) return;
+
+    // Sum oldest to newest: bounded storage, no accumulated subtraction drift,
+    // and invalid values recover naturally after leaving the window.
+    let positive = 0;
+    let negative = 0;
+    let slot = state.next;
+    for (let step = 0; step < size; step++) {
+        const value = state.flows[slot];
+        if (Number.isNaN(value)) return;
+        if (value > 0) positive += value;
+        else if (value < 0) negative -= value;
+        if (++slot === size) slot = 0;
+    }
+
+    if (!Number.isFinite(positive) || !Number.isFinite(negative)) return;
+    // No directional money flow gives an undefined ratio, not a neutral signal.
+    const value = positive === 0 && negative === 0
+        ? NaN : 100 - 100 / (1 + positive / negative);
+    main.pushToMain({ index, key, value: Number.isNaN(value) ? NaN : retLogs ? mathLog(value, 50) : value });
+};

package/src/oscillators/volumeOscillator.js

@@ -7,7 +7,7 @@ import { initializeColumns } from '../core-functions/initializeColumns.js';
 export const volumeOscillator = (main, index, fast, slow, {lag, retLogs}) => {
 
     const {verticalOhlcv, instances} = main
-    const key = `volume_oscillator_${fast}_${slow}`
+    const key = retLogs ? `ret_log_volume_oscillator_${fast}_${slow}` : `volume_oscillator_${fast}_${slow}`
 
     if (index === 0) {
         validateInputValues({ volume: true }, verticalOhlcv, index, 'volumeOscillator');
@@ -19,10 +19,7 @@ export const volumeOscillator = (main, index, fast, slow, {lag, retLogs}) => {
             }
         })
 
-        initializeColumns(main, [
-            { key },
-            { key: `ret_log_${key}`, enabled: retLogs }
-        ], { lag });
+        initializeColumns(main, [{ key }], { lag });
     }
 
     const { fastEMA, slowEMA } = instances[key];
@@ -46,12 +43,9 @@ export const volumeOscillator = (main, index, fast, slow, {lag, retLogs}) => {
         return;
     }
 
-    volumeOscValue = 100 * (fastValue - slowValue) / slowValue
-
-    if(retLogs) {
-        volumeOscRetLog = mathLog(fastValue, slowValue)
-        main.pushToMain({index, key: `ret_log_${key}`, value:  volumeOscRetLog})
-    }
+    volumeOscValue = retLogs
+        ?  mathLog(fastValue, slowValue)
+        : 100 * (fastValue - slowValue) / slowValue
 
     main.pushToMain({index, key, value:  volumeOscValue})
 };

package/src/studies/candleFeatures.js

@@ -56,14 +56,34 @@ export const candleFeatures  = (main, index, {lag, colKeys, retLogs}) => {
     const upperWickTop = Math.max(currOpen, currClose)
     const lowerWickTop = Math.min(currOpen, currClose)
 
+    const change = getRet(currClose, prevClose)
+    const midPriceChange = getRet(currMidPrice, prevMidPrice)
+    const upperWick = getRet(currHigh, upperWickTop)
+    const lowerWick = getRet(lowerWickTop, currLow)
+    const gap = getRet(currOpen, prevClose)
+    const body = getRet(currClose, currOpen)
+    const range = getRet(currHigh, currLow)
+
+    if (colKeys.length === 0) {
+        main.pushToMain({ index, key: `${prefix}change`, value: change })
+        main.pushToMain({ index, key: `${prefix}mid_price_change`, value: midPriceChange })
+        main.pushToMain({ index, key: `${prefix}upper_wick`, value: upperWick })
+        main.pushToMain({ index, key: `${prefix}lower_wick`, value: lowerWick })
+        main.pushToMain({ index, key: `${prefix}gap`, value: gap })
+        main.pushToMain({ index, key: `${prefix}body`, value: body })
+        main.pushToMain({ index, key: `${prefix}range`, value: range })
+        return
+    }
+
+    // Keep optional-target overwrite/order semantics and all-or-nothing validation.
     const row = {
-        [`${prefix}change`]: getRet(currClose, prevClose),
-        [`${prefix}mid_price_change`]: getRet(currMidPrice, prevMidPrice),
-        [`${prefix}upper_wick`]: getRet(currHigh, upperWickTop),
-        [`${prefix}lower_wick`]: getRet(lowerWickTop, currLow),
-        [`${prefix}gap`]: getRet(currOpen, prevClose),
-        [`${prefix}body`]: getRet(currClose, currOpen),
-        [`${prefix}range`]: getRet(currHigh, currLow)
+        [`${prefix}change`]: change,
+        [`${prefix}mid_price_change`]: midPriceChange,
+        [`${prefix}upper_wick`]: upperWick,
+        [`${prefix}lower_wick`]: lowerWick,
+        [`${prefix}gap`]: gap,
+        [`${prefix}body`]: body,
+        [`${prefix}range`]: range
     }
 
     let hasInvalidTarget = false
@@ -86,4 +106,4 @@ export const candleFeatures  = (main, index, {lag, colKeys, retLogs}) => {
          main.pushToMain({index, key, value})
     }
 
-}
+}

package/src/studies/dateTime.js

@@ -1,6 +1,8 @@
 import {oneHotEncode} from '../machine-learning/ml-utilities.js'
 import { initializeColumns } from '../core-functions/initializeColumns.js'
 
+const weekdays = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat']
+
 export const dateTime = (main, index, {lag, oneHot, precompute}) => {
 
     
@@ -40,43 +42,44 @@ export const dateTime = (main, index, {lag, oneHot, precompute}) => {
 
     const currDate = verticalOhlcv.date[index]
 
-    const dateInfo = getDateInfo(currDate, oneHot, colKeySizes, formatter)
-
-    for(const [key, value] of Object.entries(dateInfo))
-    {
-        main.pushToMain({index, key, value})
+    let yearPart, monthPart, hourPart, minutePart, weekdayPart, dayPart
+    for (const part of formatter.formatToParts(currDate)) {
+        switch (part.type) {
+            case 'year': yearPart = part.value; break
+            case 'month': monthPart = part.value; break
+            case 'hour': hourPart = part.value; break
+            case 'minute': minutePart = part.value; break
+            case 'weekday': weekdayPart = part.value; break
+            case 'day': dayPart = part.value; break
+        }
+    }
+    const year = Number(yearPart)
+    const month = Number(monthPart) - 1
+    const hour = Number(hourPart)
+    const minute = Number(minutePart)
+    const dayOfWeek = weekdays.indexOf(weekdayPart)
+    const dayOfMonth = Number(dayPart) - 1
+
+    if (!oneHot) {
+        main.pushToMain({ index, key: 'year', value: year })
+        main.pushToMain({ index, key: 'month', value: month + 1 })
+        main.pushToMain({ index, key: 'hour', value: hour })
+        main.pushToMain({ index, key: 'minute', value: minute })
+        main.pushToMain({ index, key: 'day_of_the_week', value: ((dayOfWeek + 6) % 7) + 1 })
+        main.pushToMain({ index, key: 'day_of_the_month', value: dayOfMonth + 1 })
+        return
     }
-}
-
-
-
-const getDateInfo = (date, oneHot, colKeySizes, formatter) => {
-
-
-  const parts = Object.fromEntries(formatter.formatToParts(date).map(({ type, value }) => [type, value]));
-  const year = Number(parts.year);
-  const month = Number(parts.month) - 1;
-  const hour = Number(parts.hour);
-  const minute = Number(parts.minute);
-  const dayOfWeek = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'].indexOf(parts.weekday);
-  const dayOfMonth = Number(parts.day) - 1;
-
-  if (!oneHot) {
-    return {
-      year: year,
-      month: month + 1,  //iso month
-      hour: hour,
-      minute: minute,
-      day_of_the_week: ((dayOfWeek + 6) % 7) + 1, //iso date of the week
-      day_of_the_month: dayOfMonth + 1,  //iso date of the month
-    };
-  }
 
-  return {
-    one_hot_month: oneHotEncode(month, colKeySizes.one_hot_month),
-    one_hot_hour: oneHotEncode(hour, colKeySizes.one_hot_hour),
-    one_hot_minute: oneHotEncode(minute, colKeySizes.one_hot_minute),
-    one_hot_day_of_the_week: oneHotEncode(dayOfWeek, colKeySizes.one_hot_day_of_the_week),
-    one_hot_day_of_the_month: oneHotEncode(dayOfMonth, colKeySizes.one_hot_day_of_the_month),
-  };
-};
+    // Build a fresh vector for every field and row before writing.
+    const oneHotMonth = oneHotEncode(month, colKeySizes.one_hot_month)
+    const oneHotHour = oneHotEncode(hour, colKeySizes.one_hot_hour)
+    const oneHotMinute = oneHotEncode(minute, colKeySizes.one_hot_minute)
+    const oneHotWeekday = oneHotEncode(dayOfWeek, colKeySizes.one_hot_day_of_the_week)
+    const oneHotDay = oneHotEncode(dayOfMonth, colKeySizes.one_hot_day_of_the_month)
+
+    main.pushToMain({ index, key: 'one_hot_month', value: oneHotMonth })
+    main.pushToMain({ index, key: 'one_hot_hour', value: oneHotHour })
+    main.pushToMain({ index, key: 'one_hot_minute', value: oneHotMinute })
+    main.pushToMain({ index, key: 'one_hot_day_of_the_week', value: oneHotWeekday })
+    main.pushToMain({ index, key: 'one_hot_day_of_the_month', value: oneHotDay })
+}

package/src/studies/findCrosses.js

@@ -24,11 +24,7 @@ class CrossInstance {
             prevSlow: NaN,
             prevHigh: NaN,
             prevLow: NaN,
-            areHighAndLowUndefined: false,
-            crossIndexes: {
-                up: [],
-                down: []
-            }
+            areHighAndLowUndefined: false
         })        
 
     }
@@ -115,9 +111,6 @@ class CrossInstance {
         }
 
 
-        if(this.interval === 1) this.crossIndexes.up.push(index)
-        if(this.interval === -1) this.crossIndexes.down.push(index)
-
         //save prev state
         Object.assign(this, {
             prevState: currState,
@@ -238,4 +231,4 @@ export const crossPairs = (main, index, crossPairsList, {oneHot, limit}) => {
 
   }
 
-}
+}