ohlcv-indicators 3.5.56 → 3.5.60

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
@@ -19,112 +13,10 @@ 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
-
-    }
-  }
+export const scaleByFeatureRange = (x, min, max) => {
+  const center = (min + max) / 2
+  const halfRange = (max - min) / 2
+  const scaled = ((x - center) / halfRange) * 2
 
-  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
-  }
-}
+  return Math.max(-2, Math.min(2, scaled))
+}

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}) => {
+import { normalizeMinMax, normalizeZScore, scaleByFeatureRange } from "./ml-utilities.js";
 
-    
+const isBadNumber = (v) => v == null || !Number.isFinite(v)
+
+//rowWiseScaler
 
-    const {groupKey, groupKeyLen} = precomputed
-    const { verticalOhlcv, instances, invalidValueIndex } = main;
-    const prefix = `${type}_${size}`;
+export const scaler = (main, index, size, colKeys, {type, minMaxRange, lookback, weights, euclideanWeights, byFeatureRange}) => {
+
+    //this function performs scaling row by row "row wise scaling"
+
+    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,120 @@ 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')
+      if(isBadNumber(currVal))
       {
         hasInvalidVal = true
-        break     
+        break
       }
 
-      const val = col[index]
+      row[target] = {
+        val: currVal, 
+        weight: (euclideanWeights) ? Math.sqrt(currWeight) :  currWeight
+      }
 
-      if(Number.isNaN(val) || val === null)
-      {
-        hasInvalidVal = true
-        break
+      rowValues.push(currVal)
+      countFeatures++
+
+      if(lookback > 0) {
+        for (let step = 1; step <= lookback; step++) {
+
+          const laggedWeight = weights?.[target]?.[step] ?? 1
+          const laggedVal = col[index - step]
+
+          if(isBadNumber(laggedVal))
+          {
+            hasInvalidVal = true
+            break
+          }
+
+          row[`${target}_lag_${step}`] = {
+            val: laggedVal, 
+            weight: (euclideanWeights) ? Math.sqrt(laggedWeight) : laggedWeight
+          }
+
+          rowValues.push(laggedVal)
+          countFeatures++
+        }
+
+        if(hasInvalidVal) break
       }
+    }
 
-      const winKey = group ? groupKey : target
-      const win = windows[winKey]
-  
-      win.push(val)
-      
-      if (win.length > (group ? size * groupKeyLen : size)) {
-        win.shift()
+    if(hasInvalidVal || countFeatures !== extectedFeatures) return
+
+    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, minMaxRange)
+        const weigthed = scaled === 0 ? 0 : scaled * weight
+        main.pushToMain({ index, key: `${prefix}_${key}`, value: weigthed });
       }
+    }
 
+    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)
+        const weigthed = scaled === 0 ? 0 : scaled * weight
+        main.pushToMain({ index, key: `${prefix}_${key}`, value: weigthed });
+      }
     }
 
-    if(hasInvalidVal) return
-  
-    const ready = index + 1 >= size
+    if(type === "byfeature") {
 
-    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 [mn, mx] = byFeatureRange
 
-      if(typeof col === 'undefined')
-      {
-        break     
-      }     
+      for (const [key, { val, weight }] of Object.entries(row)) {
 
-      const val = col[index]
+        const scaled = normalizeMinMax(val, mn, mx, minMaxRange)
+        const weigthed = scaled === 0 ? 0 : scaled * weight
 
-      if(Number.isNaN(val) || val === null)
-      {
-        break
+        main.pushToMain({ index, key: `${prefix}_${key}`, value: weigthed });
       }
 
-      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: scaled})
     }
 }
   

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),
+  };
+};

package/src/studies/priceFeatures.js

@@ -0,0 +1,78 @@
+
+const getRet = (next, prev) => (next - prev) / prev 
+const isBadNumber = (v) => v == null || !Number.isFinite(v)
+
+export const priceFeatures  = (main, index, {lag, colKeys}) => {
+    const { verticalOhlcv } = main
+
+    if(index === 0) {
+        const {len} = main
+
+        const newCols = {
+            ret_change: new Float64Array(len).fill(NaN),
+            ret_upper_wick: new Float64Array(len).fill(NaN),
+            ret_lower_wick: new Float64Array(len).fill(NaN),
+            ret_gap: new Float64Array(len).fill(NaN),
+            ret_body: new Float64Array(len).fill(NaN),
+            ret_range: new Float64Array(len).fill(NaN)
+        }
+
+        for(const target of colKeys) {
+            if(!verticalOhlcv.hasOwnProperty(target)) {
+                throw new Error(
+                    `Target property ${target} not found in verticalOhlcv for "priceFeatures".`
+                );
+            }
+
+            newCols[`ret_${target}`] = new Float64Array(len).fill(NaN)
+        }
+
+        Object.assign(verticalOhlcv, newCols)
+
+        if(lag) {
+            main.lag(Object.keys(newCols), lag)
+        }
+    }
+
+    const prevClose = verticalOhlcv.close[index - 1]
+
+    if(typeof prevClose === 'undefined') return
+
+    const currOpen = verticalOhlcv.open[index]
+    const currHigh = verticalOhlcv.high[index]
+    const currLow = verticalOhlcv.low[index]
+    const currClose = verticalOhlcv.close[index]
+
+    const upperWickTop = Math.max(currOpen, currClose)
+    const lowerWickTop = Math.min(currOpen, currClose)
+
+    const row = {
+        ret_change: getRet(currClose, prevClose),
+        ret_upper_wick: getRet(currHigh, upperWickTop),
+        ret_lower_wick: getRet(lowerWickTop, currLow),
+        ret_gap: getRet(currOpen, prevClose),
+        ret_body: getRet(currClose, currOpen),
+        ret_range: getRet(currHigh, currLow)
+    }
+
+    let hasInvalidTarget = false
+
+    for(const target of colKeys) {
+        const targetVal = verticalOhlcv[target][index]
+
+        if(isBadNumber(targetVal)) {
+            hasInvalidTarget = true
+            break
+        }
+
+        const targetRet = getRet(currClose, targetVal)
+        row[`ret_${target}`] = targetRet
+    }
+
+    if(hasInvalidTarget) return
+
+    for(const [key, value] of Object.entries(row)) {
+         main.pushToMain({index, key, value})
+    }
+
+}

package/src/utilities/dateUtilities.js

@@ -1,5 +1,5 @@
 export const dateOutputFormaters = {
-  string: d => d.toISOString(),
+  string: d => d.toString(),
   milliseconds: d => d.getTime(),
   seconds: d => d.getTime() / 1000,
   object: d => d

package/src/utilities/validators.js

@@ -123,8 +123,8 @@ export const validateArrayOfRanges = (range, paramName, callerName) => {
 
     const [min, max] = range
 
-    validateNumber(min, {min: -100, max, allowDecimals: false}, 'min', callerName)
-    validateNumber(max, {min: min, max: 100, allowDecimals: false}, 'max', callerName)
+    validateNumber(min, {min: -100, max, allowDecimals: false}, `${paramName}[0] (min)`, callerName)
+    validateNumber(max, {min: min, max: 100, allowDecimals: false}, `${paramName}[1] (max)`, callerName)
 
     if(min === max)
     {

package/src/machine-learning/balancing.js

@@ -1,65 +0,0 @@
-export const countUniqueLabels = Y => {
-  // 1. Guard against empty or non-array input
-  if (!Array.isArray(Y) || Y.length === 0) {
-    return 1
-  }
-
-  // 2. Detect if Y is 2D or 1D
-  const is2D = Array.isArray(Y[0])
-  const nCols = is2D ? Y[0].length : 1
-
-  let total = 0
-
-  // 3. For each column, collect uniques in a single pass
-  for (let col = 0; col < nCols; col++) {
-    const seen = new Set()
-    for (let row = 0; row < Y.length; row++) {
-      // pick the cell: Y[row][col] if 2D, or Y[row] if 1D
-      const cell = is2D ? Y[row][col] : Y[row]
-      seen.add(cell)
-    }
-    total += seen.size
-  }
-
-  // 4. Return “sum of uniques per column”
-  return total
-}
-
-// X and Y can have multivariable or univariable rows
-export const oversampleXY = (X, Y) => {
-  if (!Array.isArray(X) || !Array.isArray(Y)) {
-    throw new TypeError('Both X and Y must be arrays');
-  }
-  if (X.length !== Y.length) {
-    throw new Error('X and Y must have the same length');
-  }
-  if (Y.length === 0) {
-    return { X: [], Y: [] };
-  }
-
-  // 2) Group X-values by label using a Map
-  const groups = Y.reduce((map, label, i) => {
-    if (!map.has(label)) map.set(label, []);
-    map.get(label).push(X[i]);
-    return map;
-  }, new Map());
-
-  // 3) Find the largest group size
-  let maxSize = 0;
-  for (const arr of groups.values()) {
-    if (arr.length > maxSize) maxSize = arr.length;
-  }
-
-  // 4) Build the oversampled arrays
-  const outX = [];
-  const outY = [];
-  for (const [label, xArr] of groups.entries()) {
-    const sz = xArr.length;
-    for (let i = 0; i < maxSize; i++) {
-      outX.push(xArr[i % sz]);
-      outY.push(label);
-    }
-  }
-
-  return { X: outX, Y: outY };
-};