ohlcv-indicators 3.5.55 → 3.5.59

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/precisionMultiplier.js

@@ -1,39 +1,56 @@
 
-//calcPrecisionMultiplier is calculated once, using the open, high, low and close values of the first row
-//the multiplier (min 10000 and max 1000000000) is store in constructor
+//calcPrecisionMultiplier is calculated once in the class constructor, using the open, high, low and close values of the first row
+//the multiplier (min 10000) is store in constructor
 
 export const calcPrecisionMultiplier = main => {
-  const { precision, firstRow, initialPriceBased, priceBased } = main;
+  const { precision, firstRow, initialPriceBased } = main
   if (precision === false) return 1
 
-  const multipliers = []
-
-  const err = 'If "precision" is set to true all the "open", "high", "low" and "close" values must be numeric strings like "123.45" with no commas or currency symbols.'
+  let maxMultiplier = 1
 
   for (const [key, strNum] of Object.entries(firstRow)) {
+    if (!initialPriceBased.has(key)) continue
 
-    if(!initialPriceBased.has(key)) continue
-    
-    if (typeof strNum !== 'string' || !/^-?\d+(\.\d+)?$/.test(strNum)) {
-      throw new Error(`${err} 
-        Property "${key}" had the value "${strNum}" type ${typeof strNum}.`)
+    if (typeof strNum !== 'string' || !/^\d+(\.\d+)?$/.test(strNum))  {
+      throw new Error(
+        `If "precision" is set to true all the "open", "high", "low" and "close" values must be numeric strings like "123.45" with no commas or currency symbols. Property "${key}" had the value "${strNum}" type ${typeof strNum}.`
+      )
     }
 
-    if (!priceBased.has(key)) continue
-
     const [integerStr, decimals = ''] = strNum.split('.')
     const integer = Number(integerStr)
-    const decimalPrecision = integer > 0 ? 4 : Math.max(4, decimals.length)
-    multipliers.push(Math.pow(10, decimalPrecision))
-  }
 
-  if (multipliers.length === 0) return 1
+    let decimalPrecision = 4
+
+    // Treat any non-zero integer (positive or negative) as "normal"
+    if (Math.abs(integer) === 0) {
+      const decimalsLen = decimals.length
+      const countDecimals = Math.max(4, decimalsLen)
+
+      // index of first non-zero decimal digit, -1 if none
+      const firstNonZeroIndex = decimals.search(/[1-9]/)
+
+      if (firstNonZeroIndex === -1) {
+        // 0, 0.0, 0.0000... -> nothing special to preserve
+        decimalPrecision = countDecimals
+      } else {
+        // Give extra headroom after the first non-zero digit
+        const extra = 5 // tweak as you like
+        const needed = firstNonZeroIndex + 1 + extra
+        decimalPrecision = Math.max(countDecimals, needed)
+      }
+    }
 
-  const maxMultiplier = 10 ** 9 //1000000000
+    // Optional: cap exponent to keep numbers sane
+    const multiplier = 10 ** decimalPrecision
 
-  return Math.min(maxMultiplier, Math.max(...multipliers))
+    if (multiplier > maxMultiplier) maxMultiplier = multiplier
+  }
+
+  return maxMultiplier
 }
 
+
 //this function converts the strNum into a integer * multiplier
 export const addPrecisionAsNumber = (strNum, multiplier) => {
   if (typeof strNum !== 'string') throw new Error('addPrecisionExact expects a string when precision=true')

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 };
-};

package/src/machine-learning/classifier.js

@@ -1,321 +0,0 @@
-import { getFeaturedKeys, computeFlatFeaturesLen, logMlTraining, updateClassifierMetrics, findGroupsFunc } from "./ml-utilities.js"
-import { buildTrainX } from "./trainX.js"
-import { areKeyValuesValid } from "../core-functions/pushToMain.js"
-import { countUniqueLabels, oversampleXY } from "./balancing.js"
-
-const algo = 'classifier'
-
-class Store {
-  constructor(args = {}) {
-    Object.entries(args).forEach(([k, v]) => { this[k] = v })
-  }
-
-  // internal helpers
-  _unwrap = v => Array.isArray(v) ? v[0] : v
-  _num = (v, def = 0) => {
-    const n = Number(this._unwrap(v))
-    return Number.isFinite(n) ? n : def
-  }
-
-  // set: supports value OR updater function
-  // if you pass a function, we feed it the current *numeric* value
-  set = (key, valueOrFn) => {
-    if (typeof valueOrFn === 'function') {
-      const next = valueOrFn(this._num(this[key], 0))
-      this[key] = next               // <- change to [next] if you want to keep the array wrapper
-      return next
-    } else {
-      this[key] = valueOrFn          // <- change to [valueOrFn] if you want to keep the array wrapper
-      return valueOrFn
-    }
-  }
-
-  // convenience numerics
-  inc = (key, delta = 1) => this.set(key, v => v + delta)
-  add = (key, delta = 0) => this.inc(key, delta) // alias
-  getNum = (key, def = 0) => this._num(this[key], def)
-
-  get = (key) => this._unwrap(this[key])
-  getAll = () => {
-
-    const output = {}
-    
-    for(const [key, valueOrFn] of Object.entries(this)) {
-      if(typeof valueOrFn === 'function') continue
-      output[key] = valueOrFn
-    }
-
-
-    return {...output}
-  }  // shallow clone of data-only fields
-}
-
-export const classifier = (
-  main,
-  index,
-  trainingSize,
-  {
-    yCallback,
-    trainingCols,
-    findGroups = [],
-    retrain,
-    type,
-    modelArgs,
-    horizon,
-    precompute,
-    predictions,
-    filterCallback,
-    modelConfig,
-    modelClass
-  }
-) => {
-  const { lookbackAbs, prefix, flatY } = precompute
-  const { verticalOhlcv, len, instances, scaledGroups, invalidValueIndex, ML } = main
-  const allModels = ML.models
-  const startIndex = (invalidValueIndex + 1)
-  
-  // ─── INITIALIZATION ───────────────────────────────────────────────
-  if(index === startIndex) {
-
-    // prepare instance storage
-    if (!instances.hasOwnProperty(algo)) instances[algo] = {}
-    if(!instances[algo].hasOwnProperty(prefix)) instances[algo][prefix] = {}
-
-    const expectedLoops = (flatY) ? predictions : 1 //
-
-    instances[algo][prefix] = {
-      store: new Store({
-        strategy: null,
-        total: 0,
-        win: 0,
-        loss: 0,
-        strategyGainLoss: 0,
-        idx: 0,
-        initialBalance: verticalOhlcv.close[index]
-      }),
-      expectedLoops,
-      isTrained: new Array(expectedLoops).fill(false),
-      uniqueLabels: new Array(expectedLoops).fill(0),
-      shouldRetrain: retrain,
-      featureCols: [],
-      flatFeaturesColLen: 0,
-      X: [],
-      Y: Array.from({ length: expectedLoops }, () => []),
-    }
-
-    for (let i = 0; i < predictions; i++) {
-      const predictionKey = `${prefix}_${i + 1}`
-
-      verticalOhlcv[predictionKey] = (type === 'KNN') ? new Array(len).fill(null) : new Float32Array(len).fill(NaN)
-      ML.metrics[predictionKey] = {accuracy: {}, total: 0, correct: 0, labels: {}}
-
-      if(!allModels.hasOwnProperty(predictionKey))
-      {
-        allModels[predictionKey] = []
-      }
-    }
-  } 
-  else if(index < startIndex || index < lookbackAbs)
-  {
-    return
-  }
-  else if(filterCallback(verticalOhlcv, index, instances[algo][prefix].store) === false)
-  {
-      return
-  }
-  else if(index + 1 === len) 
-  {
-
-      if(instances[algo][prefix].featureCols.length === 0)
-      {
-        const inputFeatures = [...trainingCols, ...(findGroupsFunc(findGroups, scaledGroups))]
-
-        throw new Error(`Some of the provided features in ${algo} "${prefix}" features where not found in "verticalOhlcv": ${JSON.stringify(inputFeatures)}`)
-      }
-
-      //last execution
-      for(const featureKey of instances[algo][prefix].featureCols)
-      {
-          if(!verticalOhlcv.hasOwnProperty(featureKey)) throw new Error(`Feature "${featureKey}" not found in verticalOhlcv for ${prefix}.`)
-      }
-
-      if(instances[algo][prefix].X.length < trainingSize)
-      {
-        const requiredDatapoints = instances[algo][prefix].X.length - trainingSize
-        throw new Error(`The current "trainingSize" at ${algo} "${prefix}" requires at least ${requiredDatapoints} more datapoints. Try adding more input ohlcv rows or reducing the "trainingSize" by ${requiredDatapoints}.`)
-      }
-
-  }
-
-  const dataSetInstance = instances[algo][prefix]
-
-  if(dataSetInstance.flatFeaturesColLen === 0)
-  {
-    dataSetInstance.featureCols = getFeaturedKeys({trainingCols, findGroups, verticalOhlcv, scaledGroups})
-
-    if(areKeyValuesValid(main, index, dataSetInstance.featureCols))
-    {
-      dataSetInstance.flatFeaturesColLen = computeFlatFeaturesLen(dataSetInstance.featureCols, verticalOhlcv, index)
-
-      logMlTraining({
-        featureCols: dataSetInstance.featureCols, 
-        flatFeaturesColLen: dataSetInstance.flatFeaturesColLen, 
-        type, 
-        trainingSize
-      })
-    } else {
-      return
-    }
-  }
-
-  if(dataSetInstance.flatFeaturesColLen === 0) return
-
-  const {
-    uniqueLabels,
-    expectedLoops,
-    featureCols,
-    flatFeaturesColLen,
-    shouldRetrain,
-    X: xRows
-  } = dataSetInstance
-
-  const trainX = buildTrainX({
-    featureCols,
-    flatFeaturesColLen,
-    type,
-    index,
-    lookbackAbs,
-    main
-  })
-
-  if(!trainX) return 
-
-   //if univariable Y (flatY) a model is created for each prediction
-  const trainY = yCallback(index, verticalOhlcv, horizon, instances[algo][prefix].store)
-
-  if (trainY !== null && (!Array.isArray(trainY) || trainY.length !== predictions)) {
-
-    throw new Error(`trainY must be null or an array with ${predictions} items, got "${JSON.stringify(trainY)}" at index ${index} for ${type}`);
-  }
-
-  for(let loopIdx = 0; loopIdx < expectedLoops; loopIdx++)
-  {
-    const predictionKey = `${prefix}_${(loopIdx+1)}`
-    const yRows = dataSetInstance.Y[loopIdx]
-    const currTrainY =  (flatY) ? (trainY === null) ? null : trainY[loopIdx] : trainY
-    const isTrained = dataSetInstance.isTrained[loopIdx]
-
-    const shouldPredict = allModels.hasOwnProperty(predictionKey) && isTrained && (shouldRetrain === false || allModels[predictionKey].length === horizon)
-
-    //predicts using previously saved models even if current currTrainY is not available
-    if(shouldPredict)
-    {
-      const futureRow = allModels[predictionKey][0].predict([trainX])[0]
-
-      if(flatY)
-      {
-        if(futureRow == null) throw new Error(`Prediction of ${prefix} at index ${index} was expecting a number.`)
-
-        main.pushToMain({index, key: predictionKey, value: futureRow})
-
-        if(currTrainY != null)
-        {
-          updateClassifierMetrics({
-            metrics: ML.metrics[predictionKey], 
-            trueLabel: currTrainY, 
-            predictedLabel: futureRow
-          })
-        }
-      }
-      else {
-
-        if (!Array.isArray(futureRow) || futureRow.length !== predictions) {
-          throw new Error(
-            `Prediction output of ${algo} "${prefix}" at index ${index} was expecting an array of values.`
-          )
-        }
-
-        for(let preIdx = 0; preIdx < predictions; preIdx++) {
-          main.pushToMain({index, key: `${prefix}_${(preIdx+1)}`, value: futureRow[preIdx]})
-
-          if(Array.isArray(currTrainY) && currTrainY.length === predictions)
-          {
-            updateClassifierMetrics({
-              metrics: ML.metrics[`${prefix}_${(preIdx+1)}`], 
-              trueLabel: currTrainY[preIdx], 
-              predictedLabel: futureRow[preIdx]
-            })
-          }
-
-        }
-      }
-    }
-
-    if((index + predictions + 1) > len) continue 
-    if(currTrainY === null) continue // future not defined
-
-    if(flatY)
-    {
-        if (typeof currTrainY === 'undefined' || currTrainY == null)
-        {
-            throw new Error(`currTrainY must return number, string or boolean got ${typeof currTrainY} at index ${index}`)
-        }
-    } else {
-
-        if ((currTrainY.length !== predictions)) {
-
-          throw new Error(
-            `The number of label columns returned (${currTrainY.length}) doesn’t match the options.predictions (${predictions}) setting for the ${algo} "${prefix}" classifier. ` +
-            `Please update your yCallback function so its output array items align with options.predictions.`
-          );
-
-        }           
-    }
-
-    // enqueue
-    
-    yRows.push(currTrainY)
-    if (yRows.length > trainingSize) yRows.shift()
-
-    if(loopIdx === 0)
-    {
-      xRows.push(trainX)
-      if (xRows.length > trainingSize) xRows.shift()
-    }
-
-    const shouldTrainModel = shouldRetrain || !isTrained
-
-    if (shouldTrainModel && xRows.length === trainingSize && yRows.length === trainingSize) {
-
-      if(isTrained === false)
-      {
-        uniqueLabels[loopIdx] = countUniqueLabels(yRows)
-        
-        if(uniqueLabels[loopIdx] < 1)
-        {
-          throw new Error(`Invalid number or labels in ${prefix}. Check the logic of your "yCallback" function.`)
-        }
-      }
-
-
-      const {train} = modelConfig
-
-      const {X: overX, Y: overY} = oversampleXY(xRows, yRows)      
-
-      const trainedModel = train({modelClass, xRows: overX, yRows: overY, modelArgs, uniqueLabels: uniqueLabels[loopIdx]})
-
-      allModels[predictionKey].push(
-       trainedModel
-      )
-
-      if(allModels[predictionKey].length > horizon)
-      {
-        allModels[predictionKey].shift()
-      }
-
-      dataSetInstance.isTrained[loopIdx] = true
-    }
-  }
-
-  return true
-}