ohlcv-indicators 3.3.4 → 3.3.5

package/index.js

@@ -1,12 +1,10 @@
 import { mainLoop } from './src/core-functions/mainLoop.js'
 import { correlation } from './src/studies/correlation.js'
 import { isAlreadyComputed, validateArray, validateObject, validateArrayOptions, validateBoolean, validateNumber } from './src/utilities/validators.js'
-import { divideByMultiplier } from './src/utilities/numberUtilities.js'
 import { verticalToHorizontal } from './src/utilities/verticalToHorizontal.js'
 import { pushToMain } from './src/core-functions/pushToMain.js'
 import { assignTypes } from './src/utilities/assignTypes.js'
 import { calcPrecisionMultiplier } from './src/utilities/precisionMultiplier.js'
-import { selectDateFormatter, dateFormaters } from './src/utilities/dateUtilities.js'
 
 /**
  * Class OHLCV_INDICATORS
@@ -27,37 +25,31 @@ export default class OHLCV_INDICATORS {
 
         this.firstRow = input[0]
         
-        this.inputCols = Object.keys(this.firstRow)
-
         const {inputTypes, arrayTypes} = assignTypes(this.firstRow)
-        
+
         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;
         this.isComputed = false
         this.input = input
-        this.priceBased = ['open', 'high', 'low', 'close']
+        this.priceBased = new Set(['open', 'high', 'low', 'close'])
         this.len = input.length
         this.instances = {}
         this.crossPairsList = []
         this.verticalOhlcv = {}
+        this.verticalOhlcvKeyNames = []
 
-        this.studies = {}
         this.utilities = {
             correlation
         }
 
         this.invalidValueIndex = -1
-
         this.precision = precision
         this.precisionMultiplier = calcPrecisionMultiplier(this, this.firstRow)
         this.ScaledGroups = {}
         
-        
         if(inputParams !== null)
         {
             validateArray(inputParams, 'inputParams', 'constructor')
@@ -70,7 +62,6 @@ export default class OHLCV_INDICATORS {
 
         this.pushToMain = ({index, key, value}) => pushToMain({main: this, index, key, value})
         
-
         return this 
     }
 
@@ -95,7 +86,7 @@ export default class OHLCV_INDICATORS {
           let newArr = shouldSlice ? arr.slice(-sliceLength) : arr;
       
           // If this key is price based and precision is enabled, map over the array.
-          if (precision && priceBased.includes(key)) {
+          if (precision && priceBased.has(key)) {
             newArr = newArr.map(v => (v == null ? null : v / precisionMultiplier));
           }
           result[key] = newArr;
@@ -110,9 +101,7 @@ export default class OHLCV_INDICATORS {
         //getData method returns the last object (row) of the new OHLCV with indicators: {open, high, low, close, rsi_14, bollinger_bands_upper}
         this.compute()
 
-        const {precisionMultiplier, priceBased, precision, verticalOhlcv, invalidValueIndex} = this
-
-        return verticalToHorizontal(verticalOhlcv, skipNull, precision, precisionMultiplier, priceBased, invalidValueIndex)
+        return verticalToHorizontal(skipNull, this, 0)
     }
     
     
@@ -120,16 +109,7 @@ export default class OHLCV_INDICATORS {
 
         this.compute()
 
-        const {precisionMultiplier, priceBased, precision, verticalOhlcv, len} = this
-        const keyNames = Object.keys(verticalOhlcv)
-        const row = {}
-
-        for(const key of keyNames)
-        {
-            row[key] = verticalOhlcv[key][len - 1]
-        }
-     
-        return (precision) ? divideByMultiplier({row, precisionMultiplier, priceBased}) : row
+        return verticalToHorizontal(false, this, this.len - 1)[0]
     }
 
     compute() {
@@ -150,6 +130,11 @@ export default class OHLCV_INDICATORS {
         if (this.len > 0) {
           mainLoop(this.input, this);
           this.isComputed = true;
+
+          //flushing after mainLoop
+          this.input = []
+          this.instances = {}
+          this.firstRow = []
         }
       
         return this;
@@ -184,13 +169,11 @@ export default class OHLCV_INDICATORS {
 
         this.inputParams.push({key: methodName, params: [colKeys, lookback]})
 
-        for(let x = 0; x < colKeys.length; x++)
+        for(const key of colKeys)
         {
-            const key = colKeys[x]
-
-            if(this.priceBased.find(v => key === v))
+            if(this.priceBased.has(key))
             {
-                this.priceBased.push(key)
+                this.priceBased.add(key);
             }
         }
         
@@ -201,7 +184,7 @@ export default class OHLCV_INDICATORS {
 
         const methodName = 'relativeVolume'
 
-        if(!this.inputCols.includes('volume')) {
+        if(!this.inputTypes.hasOwnProperty('volume')) {
             throw new Error('If "relativeVolume" is called the input ohlcv must contain valid volume properties.')
         }
 
@@ -341,7 +324,7 @@ export default class OHLCV_INDICATORS {
     {
         const methodName = 'volumeOscillator'
 
-        if(!this.inputCols.includes('volume')) {
+        if(!this.inputTypes.hasOwnProperty('volume')) {
             throw new Error('If "volumeOscillator" is called the input ohlcv must contain valid volume properties.')
         }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ohlcv-indicators",
-  "version": "3.3.4",
+  "version": "3.3.5",
   "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

@@ -29,41 +29,22 @@ const indicatorFunctions = {
   Scaler
 };
 
-// Processes the inputParams into a list of indicator calls
-const processIndicatorCalls = inputParams =>
-  Array.isArray(inputParams)
-    ? inputParams.map(({ key, params }) => ({
-        key,
-        fn: indicatorFunctions[key],
-        args: params
-      }))
-    : [];
 
 export const mainLoop = (input, main) => {
-  const { len, inputParams, priceBased, precisionMultiplier, arrayTypes } = main;
+  const { len, inputParams, priceBased, precisionMultiplier, arrayTypes, verticalOhlcv, verticalOhlcvKeyNames, inputTypes } = main;
 
-  validateInputParams(main)
+  validateInputParams({inputParams, len})
 
-  for(const key of Object.keys(main.inputTypes))
+  for(const key of Object.keys(inputTypes))
   {
-    main.verticalOhlcv[key] = buildArray(arrayTypes[key], len)
+    verticalOhlcv[key] = buildArray(arrayTypes[key], len)
   }
 
-  // Prepare the list of indicator function calls
-  const indicatorCalls = processIndicatorCalls(inputParams);
-
   // Process each row in the input
-  for (let x = 0; x < len; x++) {
-    const curr = input[x]
-
-    processThisRow({x, main, curr, indicatorCalls, priceBased, precisionMultiplier})
-  }
-}
-
-const processThisRow = ({x, main, curr, indicatorCalls, priceBased, precisionMultiplier}) => {
-
-
-  for(const [key, formaterKey] of Object.entries(main.inputTypes))
+  for (let index = 0; index < len; index++) {
+    const curr = input[index]
+    
+    for(const [key, formaterKey] of Object.entries(inputTypes))
     {
       const value = curr[key]
 
@@ -71,30 +52,34 @@ const processThisRow = ({x, main, curr, indicatorCalls, priceBased, precisionMul
       {
         let formatedValue = numberFormater[formaterKey](value)
 
-        if(precisionMultiplier > 1 && priceBased.includes(key))
+        if(precisionMultiplier > 1 && priceBased.has(key))
         {
           formatedValue = formatedValue * precisionMultiplier
         }
 
-        main.pushToMain({index: x, key, value: formatedValue})
+        main.pushToMain({index, key, value: formatedValue})
       }
       else if(dateFormaters.hasOwnProperty(formaterKey))
       {
-        main.pushToMain({index: x, key, value: dateFormaters[formaterKey](value)})
+        main.pushToMain({index, key, value: dateFormaters[formaterKey](value)})
       }
       else
       {
-        main.pushToMain({index: x, key, value})
+        main.pushToMain({index, key, value})
       }
     }
+  
+      // Run all indicator functions except for the ones processed later
+      for (const { key, params } of inputParams) {
+        if (key === 'lag' || key === 'crossPairs') continue;
+        // resolve fn on-demand, no per-item object allocation here
+        indicatorFunctions[key](main, index, ...params)
+      }
+  
+      // Process these indicators separately (ensuring their execution order)
+      lag(main, index)
+      crossPairs(main, index)
+  }
 
-    // Run all indicator functions except for the ones processed later
-    for (const { key, fn, args } of indicatorCalls) {
-      if (['crossPairs', 'lag'].includes(key)) continue;
-      fn(main, x, ...args)
-    }
-
-    // Process these indicators separately (ensuring their execution order)
-    lag(main, x)
-    crossPairs(main, x)
-}
+  verticalOhlcvKeyNames.push(...Object.keys(verticalOhlcv))
+}

package/src/moving-averages/bollingerBands.js

@@ -45,7 +45,7 @@ export const bollingerBands = (main, index, size, stdDev, { height, range = [],
 
     // Set up additional arrays for each range property.
     for (const rangeKey of range) {
-      if (!(rangeKey in verticalOhlcv) || !priceBased.includes(rangeKey)) {
+      if (!(rangeKey in verticalOhlcv) || !priceBased.has(rangeKey)) {
         throw new Error(`Invalid range item value "${rangeKey}" property for bollingerBands. Only price based key names are accepted:\n${JSON.stringify(priceBased)}`);
       }
       keyNames.push(`${prefix}_range_${rangeKey}`)
@@ -60,7 +60,9 @@ export const bollingerBands = (main, index, size, stdDev, { height, range = [],
       main.lag(keyNames, lag)
     }
 
-    priceBased.push(`${prefix}_upper`, `${prefix}_middle`, `${prefix}_lower`);
+    [`${prefix}_upper`, `${prefix}_middle`, `${prefix}_lower`].forEach(v => {
+      priceBased.add(v)
+    })
 
     for(const key of keyNames)
     {

package/src/moving-averages/donchianChannel.js

@@ -27,7 +27,7 @@ export const donchianChannels = (main, index, size, offset, { height, range, lag
 
     // Set up additional arrays for each range property.
     for (const rangeKey of range) {
-      if (!(rangeKey in verticalOhlcv) || !priceBased.includes(rangeKey)) {
+      if (!(rangeKey in verticalOhlcv) || !priceBased.has(rangeKey)) {
         throw new Error(`Invalid range item value "${rangeKey}" property for donchianChannels. Only price based key names are accepted:\n${JSON.stringify(priceBased)}`);
       }
       keyNames.push(`${prefix}_range_${rangeKey}`)
@@ -42,7 +42,10 @@ export const donchianChannels = (main, index, size, offset, { height, range, lag
       main.lag(keyNames, lag)
     }
 
-    priceBased.push(`${prefix}_upper`, `${prefix}_basis`, `${prefix}_lower`);
+
+    [`${prefix}_upper`, `${prefix}_basis`, `${prefix}_lower`].forEach(v => {
+      priceBased.add(v)
+    })
 
     instances.donchian_channel.settings[indicatorKey] = {
       maxDeque: [], // will hold indices for highs in descending order

package/src/moving-averages/macd.js

@@ -47,7 +47,9 @@ export const macd = (main, index, fast, slow, signal, {target, lag}) => {
       [histogramKey]: new Float64Array(len).fill(NaN),
     });
 
-    priceBased.push(diffKey, deaKey, histogramKey)
+    [diffKey, deaKey, histogramKey].forEach(v => {
+      priceBased.add(v)
+    })
 
     const keyNames = [diffKey, deaKey, histogramKey]
 

package/src/moving-averages/movingAverages.js

@@ -28,7 +28,8 @@ export const movingAverages = (main, index, indicatorName, size, { target, lag }
     };
 
     verticalOhlcv[keyName] = new Float64Array(len).fill(NaN)
-    priceBased.push(keyName);
+
+    priceBased.add(keyName);
 
     if(lag > 0)
     {

package/src/studies/lag.js

@@ -17,10 +17,10 @@ export const lag = (main, index) => {
         {
             for (const colKey of colKeys)
             {
-                if(priceBased.includes(colKey))
+                if(priceBased.has(colKey))
                 {
                     for (let step = 1; step <= lookback; step++) {
-                        priceBased.push(`${colKey}_lag_${step}`)
+                        priceBased.add(`${colKey}_lag_${step}`)
                     }
                 }
             }

package/src/studies/scaler.js

@@ -37,7 +37,7 @@ export const Scaler = (
         if (!verticalOhlcv.hasOwnProperty(target)) {
           throw new Error(`Target property "${target}" not found in verticalOhlcv`);
         }
-        if (!priceBased.includes(target)) {
+        if (!priceBased.has(target)) {
           throw new Error(`Column "${target}" is not priceBased and cannot be scaled.`);
         }
   

package/src/utilities/assignTypes.js

@@ -1,7 +1,7 @@
 import { classifyNum } from "./numberUtilities.js";
 import { selectDateFormatter } from "./dateUtilities.js";
 
-const numberKeys = ['open', 'high', 'low', 'close']
+const numberKeys = new Set(['open', 'high', 'low', 'close'])
 
 export const buildArray = (arrayType, len) => {
   if(arrayType === 'Array') return new Array(len).fill(null)
@@ -24,7 +24,7 @@ export const assignTypes = firstRow => {
       inputTypes[colName] = classifyNum(cellValue, true)
       arrayTypes[colName] = 'Int32Array'
     }
-    else if(numberKeys.includes(colName))
+    else if(numberKeys.has(colName))
     {
       inputTypes[colName] = classifyNum(cellValue, true)
       arrayTypes[colName] = 'Float64Array'

package/src/utilities/numberUtilities.js

@@ -15,7 +15,7 @@ export const divideByMultiplier = ({row, precisionMultiplier, priceBased}) => {
 
         let newValue = value
 
-        if(priceBased.includes(key))
+        if(priceBased.has(key))
         {
             newValue = newValue / precisionMultiplier
         }

package/src/utilities/precisionMultiplier.js

@@ -4,7 +4,7 @@ export const calcPrecisionMultiplier = (main, firstRow) => {
     if(precision === false) return 1
 
     let output = 1
-    const priceBasedValues = Object.entries(firstRow).filter(([k, _]) => priceBased.includes(k)).map(([_, v]) => v)
+    const priceBasedValues = Object.entries(firstRow).filter(([k, _]) => priceBased.has(k)).map(([_, v]) => v)
 
 
     for(const value of priceBasedValues)

package/src/utilities/validators.js

@@ -1,6 +1,4 @@
-export const validateInputParams = main => {
-
-    const {inputParams, len} = main
+export const validateInputParams = ({inputParams, len}) => {
 
     for (const { params } of inputParams) {
         for (const v of params) {

package/src/utilities/verticalToHorizontal.js

@@ -1,31 +1,29 @@
 export const verticalToHorizontal = (
-  obj, 
   skipNull = false, 
-  precision, 
-  precisionMultiplier, 
-  priceBased, 
-  invalidValueIndex = 0
+  main,
+  startIndex = 0
 ) => {
-  const keys = Object.keys(obj);
-  if (keys.length === 0) return [];
-  
-  const startIndex = skipNull && invalidValueIndex >= 0 ? invalidValueIndex + 1 : 0
-  const endIndex = obj[keys[0]].length
-  const len = endIndex - startIndex
-  const result = new Array(len)
 
+  const {precisionMultiplier, priceBased, precision, verticalOhlcv, invalidValueIndex, len, verticalOhlcvKeyNames} = main
+
+  if (verticalOhlcvKeyNames.length === 0) return []
   
-  for (let i = startIndex; i < endIndex; i++) {
+  const skipNullIndex = skipNull && invalidValueIndex >= 0 ? invalidValueIndex + 1 : 0
+  const maxStartIndex = Math.max(skipNullIndex, startIndex)
+  const diffLen = len - maxStartIndex
+  const result = new Array(diffLen)
+
+  for (let i = maxStartIndex; i < len; i++) {
     const row = {};
-    for (let j = 0; j < keys.length; j++) {
-      const key = keys[j]
-      const value = obj[key][i]
+    for (let j = 0; j < verticalOhlcvKeyNames.length; j++) {
+      const key = verticalOhlcvKeyNames[j]
+      const value = verticalOhlcv[key][i]
 
-      row[key] = (precision && priceBased.includes(key)) ? value / precisionMultiplier : value
+      row[key] = (precision && priceBased.has(key)) ? value / precisionMultiplier : value
       
     }
 
-    result[i - startIndex] = row
+    result[i - maxStartIndex] = row
   }
   
   return result