ohlcv-indicators 3.5.52 → 3.5.54

package/index.js

@@ -1,5 +1,4 @@
 import { mainLoop } from './src/core-functions/mainLoop.js'
-import { correlation } from './src/studies/correlation.js'
 import { 
     isAlreadyComputed, 
     validateArray, 
@@ -14,10 +13,10 @@ import {
 import { verticalToHorizontal } from './src/utilities/verticalToHorizontal.js'
 import { pushToMain } from './src/core-functions/pushToMain.js'
 import { assignTypes } from './src/utilities/assignTypes.js'
-import { buildArray, getArrayType } from './src/utilities/assignTypes.js'
 import { dateOutputFormaters } from './src/utilities/dateUtilities.js'
 import { defaultMapColsCallback } from './src/studies/mapCols.js'
 import { getOrderFromArray } from './src/utilities/order.js'
+import { calcPrecisionMultiplier } from './src/utilities/precisionMultiplier.js'
 
 import {
     defaultYCallback,
@@ -38,24 +37,32 @@ import { normalizeMinMax } from './src/machine-learning/ml-utilities.js'
  */
 
 export default class OHLCV_INDICATORS {
-    constructor({input, ticker = null, inputParams = null, chunkProcess = 2000, ML = {}}) {
+    constructor({input, ticker = null, inputParams = null, chunkProcess = 2000, ML = {}, precision = false}) {
 
         validateArray(input, 'input', (ticker !== null) ? `contructor ${ticker}` : 'constuctor')
         if(input.length === 0) throw Error('input OHLCV must not be empty: ' + ticker)
 
         validateNumber(chunkProcess, {min: 100, max: 50000, allowDecimals: false}, 'chunkProcess', 'constructor')
         validateObject(ML, 'ML', 'constructor')
+        validateBoolean(precision, 'precision', 'contructor')
 
         this.chunkProcess = chunkProcess
         
         this.input = [...input]
         this.len = this.input.length
         this.firstRow = this.input[0]
-        
+        this.precision = precision
+
+        const initialPriceBasedArr = ['open', 'high', 'low', 'close']
+        this.initialPriceBased = new Set(initialPriceBasedArr)
+        this.priceBased = new Set(initialPriceBasedArr)
+        this.precisionMultiplier = calcPrecisionMultiplier(this)
+
         const {inputTypes, arrayTypes} = assignTypes(this)
 
         this.inputTypes = inputTypes
         this.arrayTypes = arrayTypes
+
         if(!this.firstRow.hasOwnProperty('close')) throw Error(`input OHLCV array objects require at least "close" property: ${ticker}`)
 
         this.dateType = this.inputTypes.date ? this.inputTypes.date : null;
@@ -65,10 +72,7 @@ export default class OHLCV_INDICATORS {
         this.verticalOhlcv = {}
         this.verticalOhlcvKeyNames = []
         this.verticalOhlcvTempCols = new Set()
-
-        this.utilities = {
-            correlation
-        }
+        this.utilities = {}
 
         this.invalidValueIndex = -1
         this.scaledGroups = {}
@@ -105,50 +109,6 @@ export default class OHLCV_INDICATORS {
     }
 
 
-    getDataAsCols(options = {}) {
-        this.compute();
-
-        const {skipNull = true, dateFormat = 'string'} = options
-
-        validateArrayOptions(Object.keys(dateOutputFormaters), dateFormat, 'dateFormat', 'getDataAsCols')
-        validateObject(options, 'options', 'getDataAsCols')
-      
-        const {
-          len,
-          invalidValueIndex,
-          verticalOhlcv,
-          verticalOhlcvTempCols,
-        } = this
-        const result = {}
-
-        const startIndex = skipNull ? invalidValueIndex + 1 : 0
-        const newLen = len - startIndex
-      
-        for (const [key, arr] of Object.entries(verticalOhlcv)) {
-
-            if(verticalOhlcvTempCols.has(key)) continue
-
-            const thisArrType = getArrayType(key, verticalOhlcv[key])
-
-            result[key] = buildArray(thisArrType, newLen)
-
-            for (let x = startIndex; x < len; x++)
-            {
-                if(key === 'date')
-                {
-                    result[key][x] = dateOutputFormaters[dateFormat](arr[x])
-                }
-                else{
-                    result[key][x] = arr[x]
-                }
-            }
-
-        }
-      
-        return result;
-      }
-      
-
     getData(options = {}) {
 
         //getData method returns the last object (row) of the new OHLCV with indicators: {open, high, low, close, rsi_14, bollinger_bands_upper}
@@ -223,9 +183,9 @@ export default class OHLCV_INDICATORS {
         validateArray(arr, 'arr', methodName)
         validateObject(options, 'options', methodName)
 
-        const {limit = 125, oneHot = false} = options
+        const {limit = null, oneHot = false} = options
         
-        validateNumber(limit, {min: 2, max: this.len}, 'options.limit', methodName)
+        if(limit !== null) validateNumber(limit, {min: 2, max: this.len}, 'options.limit', methodName)
         validateBoolean(oneHot, 'options.oneHot', methodName)
        
         const orderArr = []
@@ -292,6 +252,27 @@ export default class OHLCV_INDICATORS {
         return this
     }
 
+    volumeDelta(options = {}) {
+
+        const methodName = 'volumeDelta'
+
+        if(!this.inputTypes.hasOwnProperty('volume')) {
+            throw new Error('If "volumeDelta" is called the input ohlcv must contain valid volume properties.')
+        }
+
+        isAlreadyComputed(this)
+
+        validateObject(options, 'options', methodName)
+
+        const { lag = 0} = options;
+
+        validateNumber(lag, {min: 0, max: this.len, allowDecimals: false}, 'options.lag', methodName)
+
+        this.inputParams.push({key: methodName, order: 0, params: [{lag}]})
+ 
+        return this
+    }
+
     atr(size = 14, options = {}) {
 
         const methodName = 'atr'
@@ -355,13 +336,18 @@ export default class OHLCV_INDICATORS {
         return this
     }
 
-    heikenAshi(smoothLength = 10, afterSmoothLength = 10, options = {}) {
+    heikenAshi(smoothLength = null, afterSmoothLength = null, options = {}) {
         const methodName = 'heikenAshi'
 
         isAlreadyComputed(this)
 
-        validateNumber(smoothLength, {min: 1, max: this.len, allowDecimals: false}, 'smoothLength', methodName)
-        validateNumber(afterSmoothLength, {min: 1, max: this.len, allowDecimals: false}, 'afterSmoothLength', methodName)
+        const bothNull = smoothLength === null && afterSmoothLength === null;
+
+        if(bothNull === false) {
+            validateNumber(smoothLength, {min: 1, max: this.len, allowDecimals: false}, 'smoothLength', methodName)
+            validateNumber(afterSmoothLength, {min: 1, max: this.len, allowDecimals: false}, 'afterSmoothLength', methodName)
+        }
+
         validateObject(options, 'options', methodName)
 
         const {lag = 0} = options
@@ -370,7 +356,7 @@ export default class OHLCV_INDICATORS {
 
         const order = 0
 
-        this.inputParams.push({key: methodName, order, params: [smoothLength, afterSmoothLength, {lag}]})
+        this.inputParams.push({key: methodName, order, params: [smoothLength, afterSmoothLength, {lag, bothNull}]})
 
         return this
     }
@@ -474,17 +460,16 @@ export default class OHLCV_INDICATORS {
         validateNumber(stdDev, {min: 0.01, max: 50, allowDecimals: true}, 'stdDev', methodName)
         validateObject(options, 'options', methodName)
 
-        const {target = 'close', height = false, range = [],  lag = 0, decimals = null} = options
+        const {target = 'close', height = false, range = [],  lag = 0} = options
 
         validateString(target, 'options.target', methodName)
         validateArray(range, 'options.range', methodName)
         validateNumber(lag, {min: 0, max: this.len, allowDecimals: false}, 'options.lag', methodName)
         validateBoolean(height, 'options.height', methodName)
-        if(decimals !== null) validateNumber(decimals, {min: 1, max: 15, allowDecimals: false}, 'decimals', methodName)
   
         const order = getOrderFromArray([target], methodName)
 
-        this.inputParams.push({key: methodName, order, params: [size, stdDev, {target, height, range, lag, decimals}]});
+        this.inputParams.push({key: methodName, order, params: [size, stdDev, {target, height, range, lag}]});
     
         return this;
     }
@@ -532,19 +517,17 @@ export default class OHLCV_INDICATORS {
 
         isAlreadyComputed(this)
 
-        
         validateNumber(size, {min: 1, max: this.len, allowDecimals: false}, 'size', methodName)
         validateNumber(offset, {min: 0, max: this.len, allowDecimals: false}, 'offset', methodName)
       
         validateObject(options, 'options', methodName)
-        const { height = false, range = [], lag = 0, decimals = null} = options;
+        const { height = false, range = [], lag = 0} = options;
       
         validateArray(range, 'options.range', methodName)
         validateNumber(lag, {min: 0, max: this.len, allowDecimals: false}, 'options.lag', methodName)
         validateBoolean(height, 'options.height', methodName)
-        if(decimals !== null) validateNumber(decimals, {min: 1, max: 15, allowDecimals: false}, 'decimals', methodName)
       
-        this.inputParams.push({ key: methodName, order: 0, params: [size, offset, { height, range, lag, decimals}] });
+        this.inputParams.push({ key: methodName, order: 0, params: [size, offset, { height, range, lag}] });
       
         return this;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ohlcv-indicators",
-  "version": "3.5.52",
+  "version": "3.5.54",
   "description": "A JavaScript library featuring optimized trading indicators for OHLCV arrays [{open, high, low, close, value}]. This library is optimized for backtesting and trading bot development.",
   "main": "index.js",
   "type": "module",

package/src/core-functions/mainLoop.js

@@ -10,6 +10,7 @@ import { relativeVolume } from "../moving-averages/relativeVolume.js";
 import { donchianChannels } from "../moving-averages/donchianChannel.js";
 import { bollingerBands } from "../moving-averages/bollingerBands.js";
 import { volumeOscillator } from "../oscillators/volumeOscillator.js";
+import { volumeDelta } from "../oscillators/volumeDelta.js";
 import { lag } from "../studies/lag.js";
 import { crossPairs } from "../studies/findCrosses.js";
 import { dateTime } from "../studies/dateTime.js";
@@ -18,7 +19,7 @@ import { atr } from "../volatility/atr.js";
 import { mapCols } from "../studies/mapCols.js";
 
 import { buildArray } from "../utilities/assignTypes.js";
-import {  numberFormater } from "../utilities/numberUtilities.js";
+import {  inputNumberFormatter } from "../utilities/numberUtilities.js";
 import { dateFormaters } from "../utilities/dateUtilities.js";
 
 import { pca } from "../machine-learning/pca.js";
@@ -36,6 +37,7 @@ const mainFunctions = {
   sma: movingAverages,
   vidya,
   macd,
+  volumeDelta,
   relativeVolume,
   donchianChannels,
   bollingerBands,
@@ -55,6 +57,7 @@ export const mainLoop = (input, main) => {
     inputTypes, 
     chunkProcess, 
     processSecondaryLoop,
+    precisionMultiplier
   } = main;
 
   validateInputParams(inputParams, len)
@@ -75,9 +78,11 @@ export const mainLoop = (input, main) => {
         {
           const value = curr[key]
 
-          if(numberFormater.hasOwnProperty(formaterKey))
+          if(inputNumberFormatter.hasOwnProperty(formaterKey))
           {
-            const formatedValue = numberFormater[formaterKey](value)
+            if(typeof value === 'undefined') console.log({index, formaterKey, key})
+
+            const formatedValue = inputNumberFormatter[formaterKey](value, precisionMultiplier)
 
             main.pushToMain({index, key, value: formatedValue})
           }

package/src/core-functions/pushToMain.js

@@ -25,8 +25,7 @@ export const areKeyValuesValid = (main, index, keyNames) => {
 
         const val = verticalOhlcv[key][index]
 
-        if(typeof val === 'undefined' || val === null || Number.isNaN(val))
-        {
+        if (val == null || Number.isNaN(val)) {
             output = false
             break
         }

package/src/machine-learning/classifier.js

@@ -5,6 +5,51 @@ 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,
@@ -39,7 +84,15 @@ export const classifier = (
     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),
@@ -66,7 +119,7 @@ export const classifier = (
   {
     return
   }
-  else if(filterCallback(verticalOhlcv, index) === false)
+  else if(filterCallback(verticalOhlcv, index, instances[algo][prefix].store) === false)
   {
       return
   }
@@ -138,7 +191,7 @@ export const classifier = (
   if(!trainX) return 
 
    //if univariable Y (flatY) a model is created for each prediction
-  const trainY = yCallback(index, verticalOhlcv, horizon)
+  const trainY = yCallback(index, verticalOhlcv, horizon, instances[algo][prefix].store)
 
   if (trainY !== null && (!Array.isArray(trainY) || trainY.length !== predictions)) {
 

package/src/moving-averages/bollingerBands.js

@@ -1,11 +1,7 @@
 import { FasterBollingerBands } from 'trading-signals'
-import { roundDecimalPlaces } from '../utilities/numberUtilities.js';
-
 const defaultTarget = 'close'
 
-export const bollingerBands = (main, index, size, stdDev, { height, range = [], target, lag, decimals }) => {
-
-  
+export const bollingerBands = (main, index, size, stdDev, { height, range = [], target, lag }) => {
 
   const { verticalOhlcv, instances } = main;
   const indicatorKey = `${size}_${stdDev}`;
@@ -14,7 +10,7 @@ export const bollingerBands = (main, index, size, stdDev, { height, range = [],
   // Initialization on the first call.
   if (index === 0) {
 
-    const {inputParams, verticalOhlcv, len } = main;
+    const {inputParams, verticalOhlcv, len, priceBased } = main;
 
     if (!(target in verticalOhlcv)) {
       throw new Error(`bollingerBands could not find target "${target}"`);
@@ -62,6 +58,13 @@ export const bollingerBands = (main, index, size, stdDev, { height, range = [],
 
     }
 
+    if(priceBased.has(target)) {
+      for(const k of keyNames) {
+        priceBased.add(k)
+      }
+    }
+
+
     const verticalOhlcvSetup = Object.fromEntries(keyNames.map(v => [v, new Float64Array(len).fill(NaN)]))
     Object.assign(verticalOhlcv, {...verticalOhlcvSetup})
 
@@ -106,7 +109,7 @@ export const bollingerBands = (main, index, size, stdDev, { height, range = [],
     if (!Number.isNaN(lower) && !Number.isNaN(upper)) {
       heightValue = ((upper - lower) / lower)
     }
-    main.pushToMain({ index, key: `${prefix}_height${suffix}`, value: (decimals === null) ? heightValue : roundDecimalPlaces(heightValue, decimals) });
+    main.pushToMain({ index, key: `${prefix}_height${suffix}`, value: heightValue });
   }
 
   // Process each range property.
@@ -116,7 +119,7 @@ export const bollingerBands = (main, index, size, stdDev, { height, range = [],
     if (!Number.isNaN(priceValue) && !Number.isNaN(lower) && !Number.isNaN(upper)) {
       rangeValue = (priceValue - lower) / (upper - lower)
     }
-    main.pushToMain({ index, key: `${prefix}_range_${rangeKey}${suffix}`, value: (decimals === null) ? rangeValue : roundDecimalPlaces(rangeValue, decimals) });
+    main.pushToMain({ index, key: `${prefix}_range_${rangeKey}${suffix}`, value: rangeValue });
   }
 
   return true;

package/src/moving-averages/donchianChannel.js

@@ -1,12 +1,10 @@
 
-import { roundDecimalPlaces } from "../utilities/numberUtilities.js";
-
 export const donchianChannels = (main, index, size, offset, options) => {
 
   
 
-  const {verticalOhlcv, instances, len, inputParams, lag} = main
-  const { height: includeHeight, range: rangeKeys, decimals } = options
+  const {verticalOhlcv, instances, len, inputParams, lag, priceBased} = main
+  const { height: includeHeight, range: rangeKeys } = options
   const indicatorKey = `${size}_${offset}`
 
   // ---- INIT (only at first bar) ----
@@ -30,6 +28,10 @@ export const donchianChannels = (main, index, size, offset, options) => {
       keys.push(`${prefix}_range_${rk}`);
     }
 
+    for(const k of keys) {
+      priceBased.add(k)
+    }
+
     // bootstrap instance
     if (!instances.donchian_channel) {
       instances.donchian_channel = { numberOfIndicators, settings: {} };
@@ -96,7 +98,7 @@ export const donchianChannels = (main, index, size, offset, options) => {
     const heightVal = hasBounds && lower
       ? (upper - lower) / lower
       : NaN;
-    main.pushToMain({ index, key: `${prefix}_height`, value: (decimals === null) ? heightVal : roundDecimalPlaces(heightVal, decimals) });
+    main.pushToMain({ index, key: `${prefix}_height`, value: heightVal });
   }
 
   // precompute spread once
@@ -111,7 +113,7 @@ export const donchianChannels = (main, index, size, offset, options) => {
     const val   = hasBounds && price === price && spread
       ? (price - lower) / spread
       : NaN;
-    main.pushToMain({ index, key: rangeOut[i], value: (decimals === null) ? val : roundDecimalPlaces(val, decimals) });
+    main.pushToMain({ index, key: rangeOut[i], value: val });
   }
 
   return true;