ohlcv-indicators 3.5.55 → 3.5.59

package/src/machine-learning/ml-utilities.js

@@ -4,12 +4,6 @@ export const oneHotEncode = (idx, size) => {
     return vec
 }
 
-export const logMlTraining = ({featureCols, flatFeaturesColLen, type, trainingSize}) => {
-
-    const oneHotTxt = (featureCols.length !== flatFeaturesColLen) ? ' (including flat one-hot encoded array values) ' : ''
-    console.log(`---\nInitialized "${type}" with ${flatFeaturesColLen} features ${oneHotTxt} and ${trainingSize} rows: \n${JSON.stringify(featureCols)}\n\n`)
-}
-
 export const normalizeMinMax = (value, min, max, [validMin, validMax]) => {
     const clamped = Math.min(Math.max(value, min), max)
     return ((clamped - min) / (max - min)) * (validMax - validMin) + validMin
@@ -17,114 +11,4 @@ export const normalizeMinMax = (value, min, max, [validMin, validMax]) => {
   
 export const normalizeZScore = (value, mean, std) => {
     return std === 0 ? 0 : (value - mean) / std
-}
-
-export const findGroupsFunc = (findGroups, scaledGroups) => {
-
-    const output = []
-
-    if(findGroups.length > 0)
-    {
-        for(let g = 0; g < findGroups.length; g++)
-        {
-            const group = findGroups[g]
-            const {type, size = null, groupName = null} = group
-
-            let groupKey = (size !== null) ? `${type}_${size}` : `${type}_${groupName}`
-
-            if(!scaledGroups.hasOwnProperty(groupKey)) throw new Error(`Scaled group (${groupKey}) not found for regressor.options.findGroups[${g}]: ${JSON.stringify(group)}`)
-            output.push(...scaledGroups[groupKey])
-        }
-    }
-
-    return output
-}
-
-export const computeFlatFeaturesLen = (featureCols, verticalOhlcv, index) => {
-  
-  let flatFeaturesColLen = 0
-
-  for (const key of featureCols) {
-
-    if(!verticalOhlcv.hasOwnProperty(key)) throw new Error(`Property "${key}" not found in "verticalOhlcv".`)
-
-    const val = verticalOhlcv[key][index]
-
-    if(typeof val === 'undefined' || val === null || Number.isNaN(val)) throw new Error(`Invalid value of property "${key}".`)
-
-    if (key.startsWith('one_hot_') || key.startsWith('pca_')) {
-
-      const colSize = verticalOhlcv[key][index].length
-
-      flatFeaturesColLen += colSize
-
-    } else {
-
-      flatFeaturesColLen += 1
-
-    }
-  }
-
-  return flatFeaturesColLen
-}
-
-
-export const getFeaturedKeys = ({trainingCols, findGroups, verticalOhlcv, scaledGroups}) => {
-
-  const featureCols = [...trainingCols, ...(findGroupsFunc(findGroups, scaledGroups))]
-
-
-  if (featureCols.length === 0) {
-    return []
-  }
-
-  let keyNotFound = false
-
-  // sanity‐check that all features exist
-  for(let x = 0; x < featureCols.length; x++)
-  {
-    const featureKey = featureCols[x]
-
-    if(!verticalOhlcv.hasOwnProperty(featureKey)) {
-      keyNotFound = true
-      break
-    }
-  }
-  
-  if(keyNotFound) return []
-
-  return featureCols
-}
-
-export const updateClassifierMetrics = ({ metrics, trueLabel, predictedLabel }) => {
-  // Increment overall counters
-  metrics.total = (metrics.total || 0) + 1
-  metrics.correct = (metrics.correct || 0)
-
-  // Initialize per‐label stats container if needed
-  metrics.labels = metrics.labels || {}
-
-  const labelKey = predictedLabel.toString()
-  // Ensure we have a slot for this label
-  if (!metrics.labels[labelKey]) {
-    metrics.labels[labelKey] = { total: 0, correct: 0, accuracy: 0 }
-  }
-
-  // Update this label’s total predictions
-  metrics.labels[labelKey].total++
-
-  // If correct, bump both overall and per-label correct counters
-  if (predictedLabel === trueLabel) {
-    metrics.correct++
-    metrics.labels[labelKey].correct++
-  }
-
-  // Recompute overall accuracy
-  metrics.accuracy = metrics.correct / metrics.total
-
-  // Recompute accuracy for each label
-  for (const key in metrics.labels) {
-    const stats = metrics.labels[key]
-    stats.accuracy = stats.correct / stats.total
-  }
-}
+}

package/src/machine-learning/scaler.js

@@ -1,12 +1,15 @@
 import { normalizeMinMax, normalizeZScore } from "./ml-utilities.js";
-  
-export const scaler = (main, index, size, colKeys, {type, group, range, lag, precomputed, secondaryLoop}) => {
 
-    
+const isBadNumber = (v) => v == null || !Number.isFinite(v)
+
+//rowWiseScaler
+
+export const scaler = (main, index, size, colKeys, {type, range, lookback, weights, euclideanWeights}) => {
+
+    //this function performs scaling row by row "row wise scaling"
 
-    const {groupKey, groupKeyLen} = precomputed
-    const { verticalOhlcv, instances, invalidValueIndex } = main;
-    const prefix = `${type}_${size}`;
+    const { verticalOhlcv, instances } = main
+    const prefix = `${type}_${size}`
   
     if(index === 0) {
       const { len, isAlreadyComputed } = main
@@ -15,8 +18,6 @@ export const scaler = (main, index, size, colKeys, {type, group, range, lag, pre
       {
         throw new Error(`In scaler method can not repeat params "size" and "options.type" together between indicators.`)
       }
-
-      isAlreadyComputed.add(prefix)
   
       if(!instances.hasOwnProperty('scaler')) {
         instances.scaler = {}
@@ -25,7 +26,7 @@ export const scaler = (main, index, size, colKeys, {type, group, range, lag, pre
       if(!instances.scaler.hasOwnProperty(prefix))
       {
         instances.scaler[prefix] = {
-          windows: {}
+          extectedFeatures: (lookback === 0) ? colKeys.length : colKeys.length + (lookback * colKeys.length)
         }
       }
 
@@ -39,103 +40,104 @@ export const scaler = (main, index, size, colKeys, {type, group, range, lag, pre
         const key = `${prefix}_${target}`;
         verticalOhlcv[key] = new Float64Array(len).fill(NaN)
   
-        const winKey = group ? groupKey : target;
-        instances.scaler[prefix].windows[winKey] = [];
-  
-        if (!main.scaledGroups[groupKey]) main.scaledGroups[groupKey] = [];
-        main.scaledGroups[groupKey].push(key);
+        if (!main.scaledGroups[prefix]) main.scaledGroups[prefix] = [];
+
+        main.scaledGroups[prefix].push(key);
   
-        if (lag > 0) {
-          const lags = Array.from({ length: lag }).map((_, i) => `${key}_lag_${i + 1}`)
-          main.scaledGroups[groupKey].push(...lags)
+        if (lookback > 0) {
+          const laggedKeys = Array.from({ length: lookback }).map((_, i) => `${key}_lag_${i + 1}`)
+
+          for(const lKey of laggedKeys) {
+            verticalOhlcv[lKey] = new Float64Array(len).fill(NaN)
+          }
+
+          main.scaledGroups[prefix].push(...laggedKeys)
           features.push(key)
         }
       }
 
-      if(lag > 0)
-      {
-        main.lag(features, lag)
+      for(const weKey of Object.keys(weights)) {
+        if (!verticalOhlcv.hasOwnProperty(weKey)) {
+          throw new Error(`Target property "${weKey}" not found in verticalOhlcv`);
+        }
       }
-    }
 
-    if(secondaryLoop === true && index <= invalidValueIndex) true
+    }
   
-    const { windows } = instances.scaler[prefix]
+    const { extectedFeatures } = instances.scaler[prefix]
     
     let hasInvalidVal = false
+    const row = {}
+    const rowValues = []
+    let countFeatures = 0
 
-    // update windows with current values
     for (let x = 0; x < colKeys.length; x++) {
       const target = colKeys[x]
       const col = verticalOhlcv[target]
+      const currWeight = weights?.[target]?.[0] ?? 1
+      const currVal = col[index]
 
-      if(typeof col === 'undefined')
-      {
-        hasInvalidVal = true
-        break     
-      }
-
-      const val = col[index]
-
-      if(Number.isNaN(val) || val === null)
+      if(isBadNumber(currVal))
       {
         hasInvalidVal = true
         break
       }
 
-      const winKey = group ? groupKey : target
-      const win = windows[winKey]
-  
-      win.push(val)
-      
-      if (win.length > (group ? size * groupKeyLen : size)) {
-        win.shift()
+      row[target] = {
+        val: currVal, 
+        weight: (euclideanWeights) ? Math.sqrt(currWeight) :  currWeight
       }
 
-    }
+      rowValues.push(currVal)
+      countFeatures++
 
-    if(hasInvalidVal) return
-  
-    const ready = index + 1 >= size
+      if(lookback > 0) {
+        for (let step = 1; step <= lookback; step++) {
 
-    if(!ready) return
-  
-    // scale values once enough data
-    for (let x = 0; x < colKeys.length; x++) {
-      const target = colKeys[x]
-      const col = verticalOhlcv[target]
+          const laggedWeight = weights?.[target]?.[step] ?? 1
+          const laggedVal = col[index - step]
 
-      if(typeof col === 'undefined')
-      {
-        break     
-      }     
+          if(isBadNumber(laggedVal))
+          {
+            hasInvalidVal = true
+            break
+          }
 
-      const val = col[index]
+          row[`${target}_lag_${step}`] = {
+            val: laggedVal, 
+            weight: (euclideanWeights) ? Math.sqrt(laggedWeight) : laggedWeight
+          }
 
-      if(Number.isNaN(val) || val === null)
-      {
-        break
+          rowValues.push(laggedVal)
+          countFeatures++
+        }
+
+        if(hasInvalidVal) break
       }
+    }
+
+    if(hasInvalidVal || countFeatures !== extectedFeatures) return
 
-      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}"`)
+    if (type === "minmax") {
+      const mn = Math.min(...rowValues);
+      const mx = Math.max(...rowValues);
+
+      for (const [key, { val, weight }] of Object.entries(row)) {
+        const scaled = normalizeMinMax(val, mn, mx, range) * weight;
+        main.pushToMain({ index, key: `${prefix}_${key}`, value: scaled });
+      }
+    }
+
+    if (type === "zscore") {
+      const n = rowValues.length;
+      const mean = rowValues.reduce((s, x) => s + x, 0) / n;
+      const variance = rowValues.reduce((s, x) => s + (x - mean) ** 2, 0) / n;
+      const std = Math.sqrt(variance);
+
+      for (const [key, { val, weight }] of Object.entries(row)) {
+        const scaled = normalizeZScore(val, mean, std) * weight;
+        main.pushToMain({ index, key: `${prefix}_${key}`, value: scaled });
       }
-  
-      main.pushToMain({ index, key, value: scaled})
     }
 }
   

package/src/moving-averages/movingAverages.js

@@ -8,8 +8,6 @@ const indicatorClasses = {
 
 export const movingAverages = (main, index, methodName, size, { target, lag }) => {
 
-  
-
   const { verticalOhlcv, instances, priceBased } = main
   const suffix = (target !== 'close') ?  `_${target}` : ''
   const keyName = `${methodName}_${size}${suffix}`

package/src/moving-averages/relativeVolume.js

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

package/src/moving-averages/vidya.js

@@ -9,11 +9,11 @@ export const vidya = (main, index, size, momentum, options = {}) => {
   // Initialization on the first bar
   if (index === 0) {
     if (!(target in verticalOhlcv)) {
-      throw new Error(`VIDYA could not find target "${target}"`);
+      throw new Error(`VIDYA could not find target "${target}"`)
     }
 
-    const prefix = `vidya_${indicatorKey}`;
-    const keyBase = target === 'close' ? prefix : `${prefix}_${target}`;
+    const prefix = `vidya_${indicatorKey}`
+    const keyBase = target === 'close' ? prefix : `${prefix}_${target}`
     const keys = {
       vidya: keyBase,
       upper: `${prefix}_upper`, 
@@ -21,7 +21,7 @@ export const vidya = (main, index, size, momentum, options = {}) => {
       delta_vol: `${prefix}_delta_vol`,
       cross: `${prefix}_cross`,
       liquidity: `${prefix}_liquidity`,
-    };
+    }
 
     const priceBasedVidyaKeys = [keyBase, keys.upper, keys.lower, keys.liquidity]
 
@@ -63,13 +63,13 @@ export const vidya = (main, index, size, momentum, options = {}) => {
   };
 
   // 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 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 highestHigh = (inst.liquidity.high.length === liquidityLookback) ? Math.max(...inst.liquidity.high) : NaN
   const lowestLow = (inst.liquidity.low.length === liquidityLookback) ? Math.min(...inst.liquidity.low) : NaN
@@ -81,77 +81,77 @@ export const vidya = (main, index, size, momentum, options = {}) => {
       high - low,
       Math.abs(high - prevClose),
       Math.abs(low - prevClose)
-    );
-    inst.atrBuffer.push(tr);
-    if (inst.atrBuffer.length > atrLength) inst.atrBuffer.shift();
+    )
+    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;
+    : 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();
+  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;
+    let sumPos = 0, sumNeg = 0
     inst.momentumBuffer.forEach(m => m >= 0 ? sumPos += m : sumNeg += -m);
-    const denom = sumPos + sumNeg;
+    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);
+    const alpha = 2 / (size + 1)
+    const a = alpha * (cmo / 100)
     rawVidya = isNaN(inst.prevVidya) ? price : (a * price + (1 - a) * inst.prevVidya);
-    inst.prevVidya = rawVidya;
+    inst.prevVidya = rawVidya
   }
 
   // Smooth VIDYA using fixed 15-bar SMA
-  inst.sma.update(rawVidya);
-  let smoothedVidya = NaN;
-  try { smoothedVidya = inst.sma.getResult(); } catch {}
+  inst.sma.update(rawVidya)
+  let smoothedVidya = NaN
+  try { smoothedVidya = inst.sma.getResult() } catch {}
 
   // Bands
   const upper = (!isNaN(atr) && !isNaN(smoothedVidya))
     ? smoothedVidya + atr * bandDistance
-    : NaN;
+    : NaN
   const lower = (!isNaN(atr) && !isNaN(smoothedVidya))
     ? smoothedVidya - atr * bandDistance
-    : NaN;
+    : 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;
+  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;
+  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;
+      cross = prevCross > 0 ? prevCross + 1 : 1
     } else {
-      cross = prevCross < 0 ? prevCross - 1 : -1;
+      cross = prevCross < 0 ? prevCross - 1 : -1
     }
   }
 
   // Volume accumulation
   if (crossUp || crossDown) {
-    inst.upVol = inst.downVol = 0;
+    inst.upVol = inst.downVol = 0
   } else {
-    inst.upVol   += (close > open ? vol : 0);
-    inst.downVol += (close < open ? vol : 0);
+    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;
+  const avgVol = (inst.upVol + inst.downVol) / 2 || 1
+  const deltaPct = (inst.upVol - inst.downVol) / avgVol
 
   // Trend-based boundary (reset on crossover)
-  const trendValue = (inst.isTrendUp) ? lower : upper;
+  const trendValue = (inst.isTrendUp) ? lower : upper
   let liquidity = NaN
 
   if(cross > 0)
@@ -164,12 +164,12 @@ export const vidya = (main, index, size, momentum, options = {}) => {
   }
 
   // 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 });
+  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)
@@ -177,5 +177,5 @@ export const vidya = (main, index, size, momentum, options = {}) => {
   if(inst.liquidity.high.length > liquidityLookback) inst.liquidity.high.shift()
   if(inst.liquidity.low.length > liquidityLookback) inst.liquidity.low.shift()
 
-  return true;
-};
+  return true
+}

package/src/studies/dateTime.js

@@ -12,17 +12,12 @@ export const dateTime = (main, index, {lag, oneHot, precompute}) => {
         const {len, dateType} = 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: {
                 colKeys: [...precompute.colKeys, `${prefix}year`],
                 colKeySizes: {
-                    ...precompute.colKeySizes,
-                    [`${prefix}year`]: (currentYear - startYear) + 1
+                    ...precompute.colKeySizes
                 }
-                ,startYear
             }
         })
 
@@ -45,11 +40,11 @@ export const dateTime = (main, index, {lag, oneHot, precompute}) => {
         }
     }
 
-    const {colKeySizes, startYear} = instances.dateTime
+    const {colKeySizes} = instances.dateTime
 
     const currDate = verticalOhlcv.date[index]
 
-    const dateInfo = getDateInfo(currDate, oneHot, colKeySizes, prefix, startYear)
+    const dateInfo = getDateInfo(currDate, oneHot, colKeySizes)
 
     for(const [key, value] of Object.entries(dateInfo))
     {
@@ -59,25 +54,34 @@ export const dateTime = (main, index, {lag, oneHot, precompute}) => {
 
 
 
-const getDateInfo = (date, oneHot, colKeySizes, prefix, startYear) => {
+const getDateInfo = (date, oneHot, colKeySizes) => {
 
-    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,
-    }
+  const year = date.getFullYear();
 
-    for(const [key, size] of Object.entries(colKeySizes))
-    {
-        const value = (key === `${prefix}year`) ? output[key] - startYear: output[key]
-        output[key] = encode(value, size)
-    }
+  //start with 0 values
+  const month = date.getMonth();
+  const hour = date.getHours();
+  const minute = date.getMinutes();
+  const dayOfWeek = date.getDay();
+  const dayOfMonth = date.getDate() - 1; // keep same offset
 
-    return output
-}
+  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),
+  };
+};