ohlcv-indicators 2.0.5 → 2.0.6

package/index.js

@@ -12,14 +12,15 @@ export default class OHLCV_INDICATORS {
         if(!input[0].hasOwnProperty('close')) throw Error('input OHLCV array objects require at least close property: ' + ticker)
 
         this.lastComputedIndex = 0
-
         this.input = input
+        this.inputTypes = {open: '', high: '', low: '', close: '', volume: ''}
         this.priceBased = ['open', 'high', 'low', 'close']
         this.len = input.length
         this.lastIndexReplace = false 
         this.instances = {}
         this.crossPairsList = []
         this.verticalOhlcv = {}
+        this.horizontalOhlcv = new Array(this.len).fill({})
 
         this.inputParams = []
 
@@ -28,59 +29,52 @@ export default class OHLCV_INDICATORS {
             correlation
         }
 
-
+        this.precisionMultiplier = 0
         this.setIndicatorsFromInputParams = setIndicatorsFromInputParams
     
         return this 
     }
 
+    pushToMain({index, key, value})
+    {
+        this.verticalOhlcv[key][index] = value
+        this.horizontalOhlcv[index][key] = value
+    }
 
-    getData() {
+    getDataAsCols(){
 
-        //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 {verticalOhlcv} = this
-        const keys = Object.keys(verticalOhlcv);
-        const len = verticalOhlcv[keys[0]].length;
-        const keysLength = keys.length;
-    
-        // Pre-allocate array to improve memory efficiency
-        const result = [];
-    
-        // Iterate over the rows
-        for (let i = 0; i < len; i++) {
-            const row = {};
-            let isInvalidValue = false;  // Flag to track if any null value is found
-    
-            // Loop over keys to fill row data
-            for (let x = 0; x < keysLength; x++) {
-                const header = keys[x];
 
-                const value = verticalOhlcv[header][i];
-    
-                // If value is null, mark the row to be skipped and break
-                if (value === null || typeof value === 'undefined') {
-                    isInvalidValue = true;
-                    break;
-                }
-    
-                row[header] =  value
-            }
-    
-            // If no null values were found, add row to result
-            if (!isInvalidValue) {
-                result.push(row);
+        const {precisionMultiplier} = this
+        const verticalClone = {...this.verticalOhlcv}
+
+        for(const [key, arr] of Object.entries(verticalClone))
+        {
+            if(this.priceBased.includes(key))
+            {
+                verticalClone[key] = arr.map(v => v / precisionMultiplier)
             }
         }
-    
-        return result;
+
+        return verticalClone
+
+    }
+
+    getData() {
+
+        //getData method returns the last object (row) of the new OHLCV with indicators: {open, high, low, close, rsi_14, bollinger_bands_upper}
+        this.compute()
+        return this.horizontalOhlcv.filter(row => 
+            !Object.values(row).some(value => value === undefined || value === null)
+        )
     }
     
     
     getLastValues(){
 
-        return this.getData()[this.getData().length -1]
+        this.compute()
+
+        return this.horizontalOhlcv[this.horizontalOhlcv.length - 1]
     
     }
 
@@ -222,7 +216,7 @@ export default class OHLCV_INDICATORS {
 
         return this 
     }
-    macd(fast = 12, slow = 26, signal = 9) {
+    macd(fast = 12, slow = 26, signal = 9, options = {}) {
 
         isAlreadyComputed(this)
 
@@ -236,14 +230,20 @@ export default class OHLCV_INDICATORS {
             throw new Error('"signal" must be a positive number in macd.');
         }
 
-        this.inputParams.push({key: 'macd', params: [fast, slow, signal]})
+        if(typeof options !== 'object')
+        {
+            throw new Error('"options" must be an object in macd. eg: {target}');
+        }
+
+        const {target = 'close'} = options
+
+        this.inputParams.push({key: 'macd', params: [fast, slow, signal, {target}]})
         
         return this
 
     }
     bollingerBands(size = 20, stdDev = 2, options = {}) {
 
-
         isAlreadyComputed(this)
 
         if(!options || typeof options !== 'object')
@@ -251,7 +251,7 @@ export default class OHLCV_INDICATORS {
             throw new Error('"options" must be an object in bollingerBands. eg: {target, height, range}');
         }
 
-        const {target = 'close', height = false, range = false} = options
+        const {target = 'close', height = 0, range = [], zScore = []} = options
 
         // Validate size and times
         if (typeof size !== 'number' || size <= 0) {
@@ -260,8 +260,17 @@ export default class OHLCV_INDICATORS {
         if (typeof stdDev !== 'number' || stdDev <= 0) {
             throw new Error('"stdDev" must be a positive number in bollingerBands.');
         }
+        if (!Array.isArray(range)) {
+            throw new Error('If set, "range" must be a array of column names in bollingerBands.');
+        }
+        if (!Array.isArray(zScore)) {
+            throw new Error('If set, "zScore" must be a array of column names in bollingerBands.');
+        }
+        if (typeof height !== 'number' || height < size) {
+            throw new Error('"height" must be a number greater than or equal to "size" in bollingerBands.');
+        } 
     
-        this.inputParams.push({key: 'bollingerBands', params: [size, stdDev, {target, height, range}]});
+        this.inputParams.push({key: 'bollingerBands', params: [size, stdDev, {target, height, range, zScore}]});
         this.priceBased.push('bollinger_bands_middle', 'bollinger_bands_upper', 'bollinger_bands_lower');
     
         return this;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ohlcv-indicators",
-  "version": "2.0.5",
+  "version": "2.0.6",
   "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/moving-averages/bollingerBands.js

@@ -1,79 +1,132 @@
-import {FasterBollingerBands, FasterSMA} from 'trading-signals';
+import { FasterBollingerBands, FasterSMA } from 'trading-signals';
 import { classifySize } from '../utilities/classification.js';
 
-let defaultTarget = 'close'
-
-export const bollingerBands = (main, index, size, times, options) => {
-
-    const {height, range, target} = options
-    let suffix = (target === defaultTarget) ? '' : `_${target}`
-
-    if (index === 0) {
-
-        if(!main.verticalOhlcv.hasOwnProperty(target))
-        {
-            throw new Error(`bollingerBands could not find target "${target}"`)
-        }
-
-        Object.assign(main.instances, {
-            [`bollinger_bands${suffix}`]: {
-                instance: new FasterBollingerBands(size, times),
-                heightInstance: height ? new FasterSMA(size) : null
-            }
-        })
-        
-        Object.assign(main.verticalOhlcv, {
-            [`bollinger_bands_upper${suffix}`]: [...main.nullArray],
-            [`bollinger_bands_middle${suffix}`]: [...main.nullArray],
-            [`bollinger_bands_lower${suffix}`]: [...main.nullArray],
-            ...(height && {
-                [`bollinger_bands_height${suffix}`]: [...main.nullArray]
-            }),
-            ...(range && {
-                [`bollinger_bands_range${suffix}`]: [...main.nullArray],
-            })
-        })
-    }
+const defaultTarget = 'close';
 
-    
-    const { instance, heightInstance } = main.instances[`bollinger_bands${suffix}`]
-    const value = main.verticalOhlcv[target][index]
-    instance.update(value, main.lastIndexReplace)
+export const bollingerBands = (main, index, size, stdDev, options) => {
+  // Destructure options; ensure range and zScore default to empty arrays if not provided.
+  const { height, range = [], zScore = [], target } = options;
+  const suffix = target === defaultTarget ? '' : `_${target}`;
+  const indicatorKey = `${size}_${stdDev}${suffix}`;
+  let prefix; // Will be computed during initialization
 
-    let result;
-    try {
-        result = instance.getResult();
-    } catch (err) {
-       //do nothing
+  // Initialize indicator instances and output arrays on the first call.
+  if (index === 0) {
+    if (!(target in main.verticalOhlcv)) {
+      throw new Error(`bollingerBands could not find target "${target}"`);
     }
 
-    if(!result) return true
+    const numberOfIndicators = main.inputParams.filter(o => o.key === 'bollingerBands').length;
+    // Choose a prefix based on the number of indicators.
+    prefix = numberOfIndicators > 1
+      ? `bollinger_bands_${indicatorKey}`
+      : `bollinger_bands${suffix}`;
+
+    // Ensure the container exists.
+    if (!main.instances.bollinger_bands) {
+      main.instances.bollinger_bands = {
+        numberOfIndicators,
+        settings: {}
+      };
+    }
 
-    const { upper, middle, lower } = result;
-    main.verticalOhlcv[`bollinger_bands_upper${suffix}`][index] = upper;
-    main.verticalOhlcv[`bollinger_bands_middle${suffix}`][index] = middle;
-    main.verticalOhlcv[`bollinger_bands_lower${suffix}`][index] = lower;
+    // Create the Bollinger Bands (and optional height) indicator instance.
+    main.instances.bollinger_bands.settings[indicatorKey] = {
+      instance: new FasterBollingerBands(size, stdDev),
+      heightInstance: height >= size ? new FasterSMA(height) : null
+    };
 
-    if (!height && !range) return true;
+    // Build the base output arrays.
+    const ohlcvSetup = {
+      [`${prefix}_upper`]: [...main.nullArray],
+      [`${prefix}_middle`]: [...main.nullArray],
+      [`${prefix}_lower`]: [...main.nullArray],
+      ...(height >= size && { [`${prefix}_height`]: [...main.nullArray] })
+    };
 
-    let heightMean;
-    const rangeValue = (value - lower) / (upper - lower);
-    const heightValue = upper - lower;
 
-    heightInstance.update(heightValue, main.lastIndexReplace);
 
-    try {
-        heightMean = heightInstance.getResult();
-    } catch (err) {
-        //do nothing
+
+    // Set up additional arrays for each range property.
+    for (const rangeKey of range) {
+      if (!(rangeKey in main.verticalOhlcv) || !main.priceBased.includes(rangeKey)) {
+        throw new Error(`Invalid range item value "${rangeKey}" property for bollingerBands. Only price based key names are accepted:\n${JSON.stringify(main.priceBased)}`);
+      }
+      ohlcvSetup[`${prefix}_range_${rangeKey}`] = [...main.nullArray];
     }
 
-    main.verticalOhlcv[`bollinger_bands_range${suffix}`][index] = rangeValue;
+    // Set up additional arrays for each zScore property.
+    for (const zScoreKey of zScore) {
+      if (!(zScoreKey in main.verticalOhlcv) || !main.priceBased.includes(zScoreKey)) {
+        throw new Error(`Invalid zScore item value "${zScoreKey}" for bollingerBands. Only price based key names are accepted:\n${JSON.stringify(main.priceBased)}`);
+      }
+      ohlcvSetup[`${prefix}_zscore_${zScoreKey}`] = [...main.nullArray];
+    }
 
-    if(heightMean)
-    {
-        main.verticalOhlcv[`bollinger_bands_height${suffix}`][index] = classifySize(heightValue, heightMean, 1.5);
+    // Merge the new arrays into verticalOhlcv.
+    Object.assign(main.verticalOhlcv, ohlcvSetup);
+  }
+
+  // For subsequent calls, if prefix wasn’t computed (i.e. index > 0), derive it.
+  if (!prefix) {
+    const num = main.instances.bollinger_bands.numberOfIndicators;
+    prefix = num > 1 ? `bollinger_bands_${indicatorKey}` : `bollinger_bands${suffix}`;
+  }
+  // Use the same prefix for output keys.
+  const subPrefix = prefix;
+
+  // Retrieve the indicator instance(s) and update with the current value.
+  const { instance, heightInstance } = main.instances.bollinger_bands.settings[indicatorKey];
+  const value = main.verticalOhlcv[target][index];
+  instance.update(value, main.lastIndexReplace);
+
+  let result;
+  try {
+    result = instance.getResult();
+  } catch (err) {
+    // If the result is not available yet, simply exit.
+  }
+  if (!result) return true;
+
+  const { upper, middle, lower } = result;
+  main.pushToMain({index, key: `${subPrefix}_upper`, value: upper})
+  main.pushToMain({index, key: `${subPrefix}_middle`, value: middle})
+  main.pushToMain({index, key: `${subPrefix}_lower`, value: lower})
+
+  // Exit early if neither height nor range are requested.
+  if (!height && !range) return true;
+
+  // Process height if a height instance exists.
+  if (heightInstance) {
+    const heightValue = upper - lower;
+    heightInstance.update(heightValue, main.lastIndexReplace);
+    let heightMean;
+    try {
+      heightMean = heightInstance.getResult();
+    } catch (err) {
+      // Swallow error if the height result is not ready.
+    }
+    if (heightMean) {
+      main.pushToMain({index, key: `${subPrefix}_height`, value: classifySize(heightValue, heightMean, 0.5, 7)})
     }
-    
-    return true;
+  }
+
+  // Process each range property.
+  for (const rangeKey of range) {
+    const rangeValue = (main.verticalOhlcv[rangeKey][index] - lower) / (upper - lower);
+    main.pushToMain({index, key: `${subPrefix}_range_${rangeKey}`, value: rangeValue})
+  }
+
+  // Process each zScore property.
+  for (const zScoreKey of zScore) {
+    const denominator = upper - lower;
+    const zScoreValue = denominator !== 0
+      ? (2 * stdDev * (main.verticalOhlcv[zScoreKey][index] - middle)) / denominator
+      : 0;
+
+      
+    main.pushToMain({index, key: `${subPrefix}_zscore_${zScoreKey}`, value: zScoreValue})
+  }
+
+  return true;
 };

package/src/moving-averages/donchianChannel.js

@@ -1,91 +1,112 @@
-import {FasterSMA} from 'trading-signals'
-import { classifySize } from '../utilities/classification.js'
-
+import { FasterSMA } from 'trading-signals';
+import { classifySize } from '../utilities/classification.js';
 
 export const donchianChannels = (main, index, size, offset, options) => {
-
-    const highs = main.verticalOhlcv.high
-    const lows = main.verticalOhlcv.low
-    const {height, range} = options
-
-
-    // Ensure that the required arrays exist
-    if (index === 0) {
-
-        Object.assign(main.verticalOhlcv, {
-            donchian_channel_upper: [...main.nullArray],
-            donchian_channel_basis: [...main.nullArray],
-            donchian_channel_lower: [...main.nullArray],
-            ...(height && {
-                [`donchian_channel_height`]: [...main.nullArray]
-            }),
-            ...(range && {
-                [`donchian_channel_range`]: [...main.nullArray],
-            })
-        })
-
-        Object.assign(main.instances, {
-            ['donchian_channel']: {
-                heightInstance: height ? new FasterSMA((typeof height === 'number' && height > 0) ? height : size) : null
-            }
-        })
+  const { height, range } = options;
+  const indicatorKey = `${size}_${offset}`;
+
+  // Initialization: create output arrays and indicator instance on the first call.
+  if (index === 0) {
+    const numberOfIndicators = main.inputParams.filter(o => o.key === 'donchianChannels').length;
+    const prefix = numberOfIndicators > 1 ? `donchian_channel_${indicatorKey}` : 'donchian_channel';
+
+    Object.assign(main.verticalOhlcv, {
+      [`${prefix}_upper`]: [...main.nullArray],
+      [`${prefix}_basis`]: [...main.nullArray],
+      [`${prefix}_lower`]: [...main.nullArray],
+      ...(height && { [`${prefix}_height`]: [...main.nullArray] }),
+      ...(range && { [`${prefix}_range`]: [...main.nullArray] })
+    });
+
+    if (!main.instances.hasOwnProperty('donchian_channel')) {
+      main.instances.donchian_channel = { numberOfIndicators, settings: {} };
     }
 
-    const { heightInstance } = main.instances['donchian_channel']
-
-    // Compute the slice start and end to get exactly 'size' bars
-    const endIdx = (index - offset) + 1          // inclusive end of the slice
-    const startIdx = endIdx - size             // start index for slicing
-
-    // If any of these indices is out of bounds, return
-    if (startIdx < 0 || endIdx > main.len) return true
-
-    // Extract the relevant chunks of data
-    const highChunk = highs.slice(startIdx, endIdx)
-    const lowChunk = lows.slice(startIdx, endIdx)
-
-    // Compute the Donchian channels
-    const upper = Math.max(...highChunk)
-    const lower = Math.min(...lowChunk)
-    const basis = (upper + lower) / 2
-    const close = main.verticalOhlcv.close[index]
-    const rangeValue = (close - lower) / (upper - lower)
-    const heightValue = upper - lower
-
-    if(height)
-    {
-        heightInstance.update(heightValue, main.lastIndexReplace)
+    // In addition to your heightInstance, also initialize deques for highs and lows.
+    main.instances.donchian_channel.settings[indicatorKey] = {
+      heightInstance: height
+        ? new FasterSMA(typeof height === 'number' && height > 0 ? height : size)
+        : null,
+      maxDeque: [], // will hold indices for highs in descending order
+      minDeque: []  // will hold indices for lows in ascending order
+    };
+  }
+
+  const numberOfIndicators = main.instances.donchian_channel.numberOfIndicators;
+  const subPrefix = numberOfIndicators > 1 ? `donchian_channel_${indicatorKey}` : 'donchian_channel';
+  const state = main.instances.donchian_channel.settings[indicatorKey];
+  const { heightInstance, maxDeque, minDeque } = state;
+
+  // Compute the “current bar index” for the window.
+  // Note: We use index - offset so that the window is built on the proper part of the array.
+  const currentBarIdx = index - offset;
+  const endIdx = currentBarIdx + 1;    // currentBarIdx is inclusive
+  const startIdx = endIdx - size;        // window: [startIdx, endIdx)
+
+  // If the window is not fully available, exit early.
+  if (startIdx < 0 || endIdx > main.len) return true;
+
+  const highs = main.verticalOhlcv.high;
+  const lows = main.verticalOhlcv.low;
+
+  // **Update the maximum deque:**
+  // Remove indices that are out of the current window.
+  while (maxDeque.length && maxDeque[0] < startIdx) {
+    maxDeque.shift();
+  }
+  // Remove indices whose corresponding high value is less than or equal to the current high.
+  while (maxDeque.length && highs[maxDeque[maxDeque.length - 1]] <= highs[currentBarIdx]) {
+    maxDeque.pop();
+  }
+  // Add the current index.
+  maxDeque.push(currentBarIdx);
+
+  // **Update the minimum deque:**
+  // Remove indices that are out of the current window.
+  while (minDeque.length && minDeque[0] < startIdx) {
+    minDeque.shift();
+  }
+  // Remove indices whose corresponding low value is greater than or equal to the current low.
+  while (minDeque.length && lows[minDeque[minDeque.length - 1]] >= lows[currentBarIdx]) {
+    minDeque.pop();
+  }
+  // Add the current index.
+  minDeque.push(currentBarIdx);
+
+  // Now the maximum high is at the front of maxDeque and the minimum low is at the front of minDeque.
+  const upper = highs[maxDeque[0]];
+  const lower = lows[minDeque[0]];
+  const basis = (upper + lower) / 2;
+  const close = main.verticalOhlcv.close[index];
+  const rangeValue = (close - lower) / (upper - lower);
+  const heightValue = upper - lower;
+
+  // Update the height indicator if requested.
+  if (height && heightInstance) {
+    heightInstance.update(heightValue, main.lastIndexReplace);
+  }
+
+  // Update the computed values in the output arrays.
+
+  main.pushToMain({index, key: `${subPrefix}_upper`, value: upper})
+  main.pushToMain({index, key: `${subPrefix}_basis`, value: basis})
+  main.pushToMain({index, key: `${subPrefix}_lower`, value: lower})
+
+  if (range) {
+    main.pushToMain({index, key: `${subPrefix}_range`, value: rangeValue})
+  }
+  if (height && heightInstance) {
+    let heightMean;
+    try {
+      heightMean = heightInstance.getResult();
+    } catch (err) {
+      // Ignore errors if the result isn't ready.
     }
+    if (heightMean) {
 
-    // Place the result at index
-    const placementIndex = index
-
-    if (placementIndex >= 0 && placementIndex < main.len) {
-
-        main.verticalOhlcv['donchian_channel_upper'][placementIndex] = upper
-        main.verticalOhlcv['donchian_channel_basis'][placementIndex] = basis
-        main.verticalOhlcv['donchian_channel_lower'][placementIndex] = lower
-
-        if(range)
-        {
-            main.verticalOhlcv['donchian_channel_range'][placementIndex] = rangeValue
-        }
-        if(height)
-        {
-            let heightMean
-
-            try {
-                heightMean = heightInstance.getResult();
-            } catch (err) {
-                //do nothing
-            }
-
-            if(heightMean)
-            {
-                main.verticalOhlcv['donchian_channel_height'][placementIndex] = classifySize(heightValue, heightMean, 1.5)
-            }
-        }
+      main.pushToMain({index, key: `${subPrefix}_height`, value: classifySize(heightValue, heightMean, 1.5)})
     }
+  }
 
-    return true
-}
+  return true;
+};

package/src/moving-averages/ema.js

@@ -26,7 +26,7 @@ export const ema = (main, index, size, target) => {
 
   if(currEma)
   {
-    main.verticalOhlcv[keyName][index] = currEma
+    main.pushToMain({index, key: keyName, value: currEma})
   }
 
 }

package/src/moving-averages/macd.js

@@ -1,27 +1,56 @@
 import {FasterEMA, FasterMACD} from 'trading-signals';
 
-export const macd = (main, index, fast, slow, signal) => {
+const defaultTarget = 'close'
 
-    const value = main.verticalOhlcv.close[index]
+export const macd = (main, index, fast, slow, signal, options) => {
+
+    const {target} = options
+    const suffix = target === defaultTarget ? '' : `_${target}`;
+    const indicatorKey = `${fast}_${slow}_${signal}${suffix}`;
 
     if (index === 0) {
 
-        main.crossPairsList.push({fast: 'macd_diff', slow: 'macd_dea', isDefault: true});
+        if(!main.verticalOhlcv.hasOwnProperty(target))
+        {
+            throw new Error(`Target property ${target} not found in verticalOhlcv for macd.`)
+        }
+
+        const numberOfIndicators = main.inputParams.filter(o => o.key === 'macd').length;
+        const prefix =
+          numberOfIndicators > 1
+            ? `macd_${indicatorKey}`
+            : `macd${suffix}`;
+
+        main.crossPairsList.push({fast: `${prefix}_diff`, slow: `${prefix}_dea`, isDefault: true});
+
+        if(!main.instances.hasOwnProperty('macd'))
+        {
+            main.instances.macd = {
+                numberOfIndicators,
+                settings: {}
+              }
+        }
 
-        main.instances['macd'] = new FasterMACD(
+        main.instances.macd.settings[indicatorKey] = new FasterMACD(
             new FasterEMA(fast),
             new FasterEMA(slow),
             new FasterEMA(signal)
         );
 
         Object.assign(main.verticalOhlcv, {
-            macd_diff: [...main.nullArray],
-            macd_dea: [...main.nullArray],
-            macd_histogram: [...main.nullArray],
+            [`${prefix}_diff`]: [...main.nullArray],
+            [`${prefix}_dea`]: [...main.nullArray],
+            [`${prefix}_histogram`]: [...main.nullArray],
         })
     }
 
-    const macdInstance = main.instances[`macd`];
+    
+    const subPrefix = main.instances.macd.numberOfIndicators > 1
+        ? `macd_${indicatorKey}`
+        : `macd${suffix}`;
+
+    const macdInstance = main.instances.macd.settings[indicatorKey];
+    const value = main.verticalOhlcv[target][index]
     macdInstance.update(value, main.lastIndexReplace);
 
     let macdResult;
@@ -34,9 +63,10 @@ export const macd = (main, index, fast, slow, signal) => {
 
 
     if (macdResult) {
-        main.verticalOhlcv['macd_diff'][index] = macdResult.macd;
-        main.verticalOhlcv['macd_dea'][index] = macdResult.signal;
-        main.verticalOhlcv['macd_histogram'][index] = macdResult.histogram;
+
+        main.pushToMain({index, key: `${subPrefix}_diff`, value: macdResult.macd})
+        main.pushToMain({index, key: `${subPrefix}_dea`, value: macdResult.signal})
+        main.pushToMain({index, key: `${subPrefix}_histogram`, value: macdResult.histogram})
     }
 
     return true;

package/src/moving-averages/relativeVolume.js

@@ -2,39 +2,43 @@ import {FasterSMA} from 'trading-signals';
 
 export const relativeVolume = (main, index, size = 10) => {
 
-    const value = main.verticalOhlcv.volume[index]
+    const key = `relative_volume_${size}`
 
     if (index === 0) {
-        main.instances[`relative_volume_${size}`] = {
+        main.instances[key] = {
             instance: new FasterSMA(size),
             prevRelativeVolumeSma: null
         }
 
         Object.assign(main.verticalOhlcv, {
-            [`relative_volume_${size}`]: [...main.nullArray],
+            [key]: [...main.nullArray],
         })
     }
 
-    const smaInstance = main.instances[`relative_volume_${size}`].instance
+
+    const value = main.verticalOhlcv.volume[index]
+    
+    const smaInstance = main.instances[key].instance
     smaInstance.update(value, main.lastIndexReplace)
 
     let smaValue;
     try {
         smaValue = smaInstance.getResult()
+
+        
     } catch (err) {
         //do nothing
     }
 
-    const {prevRelativeVolumeSma} = main.instances[`relative_volume_${size}`]
-
-    if (smaValue !== null && prevRelativeVolumeSma !== null) {
-        main.verticalOhlcv[`relative_volume_${size}`][index] = value / prevRelativeVolumeSma;
-    } else {
-        main.verticalOhlcv[`relative_volume_${size}`][index] = null;
-    }
+    const {prevRelativeVolumeSma} = main.instances[key]
 
+    main.pushToMain({
+        index, 
+        key,
+        value: (smaValue !== null && prevRelativeVolumeSma !== null) ? value / prevRelativeVolumeSma : null
+    })
 
-    main.instances[`relative_volume_${size}`].prevRelativeVolumeSma = smaValue
+    main.instances[key].prevRelativeVolumeSma = smaValue
 
     return true;
 };

package/src/moving-averages/sma.js

@@ -27,7 +27,7 @@ export const sma = (main, index, size, target) => {
 
   if(currSma)
   {
-    main.verticalOhlcv[keyName][index] = currSma
+    main.pushToMain({index, key: keyName, value: currSma})
   }
 
 }

package/src/oscillators/rsi.js

@@ -35,7 +35,7 @@ export const rsi = (main, index, size) => {
     
     if(currentRsi)
     {
-        main.verticalOhlcv[`rsi_${size}`][index] = currentRsi
+        main.pushToMain({index, key: `rsi_${size}`, value: currentRsi})
         main.instances[`rsi_sma_${size}`].update(currentRsi, main.lastIndexReplace)
     }
 
@@ -49,7 +49,7 @@ export const rsi = (main, index, size) => {
 
     if(smoothedRsi)
     {
-        main.verticalOhlcv[`rsi_sma_${size}`][index] = smoothedRsi
+        main.pushToMain({index, key: `rsi_sma_${size}`, value: smoothedRsi})
     }
 
     return true

package/src/oscillators/volumeOscillator.js

@@ -3,6 +3,7 @@ import { FasterEMA } from 'trading-signals';
 export const volumeOscillator = (main, index, fast, slow) => {
 
     const value = main.verticalOhlcv.volume[index]
+    const key = 'volume_oscillator'
 
     if (index === 0) {
 
@@ -13,11 +14,11 @@ export const volumeOscillator = (main, index, fast, slow) => {
             }
         })
 
-        main.verticalOhlcv[`volume_oscillator`] = [...main.nullArray];
-        main.crossPairsList.push({ fast: `volume_oscillator`, slow: 0, isDefault: true });
+        main.verticalOhlcv[key] = [...main.nullArray];
+        main.crossPairsList.push({ fast: key, slow: 0, isDefault: true });
     }
 
-    const { fastEMA, slowEMA } = main.instances[`volume_oscillator`];
+    const { fastEMA, slowEMA } = main.instances[key];
 
     fastEMA.update(value, main.lastIndexReplace);
     slowEMA.update(value, main.lastIndexReplace);
@@ -38,9 +39,10 @@ export const volumeOscillator = (main, index, fast, slow) => {
     }
 
     if (typeof fastValue === 'number' && typeof slowValue === 'number' && slowValue !== 0) {
-        main.verticalOhlcv[`volume_oscillator`][index] = 100 * (fastValue - slowValue) / slowValue
+
+        main.pushToMain({index, key, value:  100 * (fastValue - slowValue) / slowValue})
     } else {
-        main.verticalOhlcv[`volume_oscillator`][index] = null;
+        main.pushToMain({index, key, value:  null})
     }
 
     return true;

package/src/studies/candleStudies.js

@@ -112,45 +112,54 @@ export const candleStudies = (main, index, size, classify = true, classification
             // If there's not enough data, means remain null
         }
 
-        main.verticalOhlcv.candle_body_size[index] = isUp
-            ? classifySize(candleBodySize, bodySizeMean, 2, changeLevel)
-            : -Math.abs(classifySize(candleBodySize, bodySizeMean, 2, changeLevel)) || 0;
+        main.pushToMain({
+            index, 
+            key: 'candle_body_size', 
+            value: isUp 
+                ? classifySize(candleBodySize, bodySizeMean, 2, changeLevel)
+                : -Math.abs(classifySize(candleBodySize, bodySizeMean, 2, changeLevel)) || 0
+        })
+
+        
 
-        main.verticalOhlcv.candle_gap_size[index] = isUp
+        main.pushToMain({index, key: 'candle_gap_size', value: isUp
             ? classifySize(gapSize, gapMean, 2, changeLevel)
-            : -Math.abs(classifySize(gapSize, gapMean, 2, changeLevel)) || 0;
+            : -Math.abs(classifySize(gapSize, gapMean, 2, changeLevel)) || 0})
+
 
-        main.verticalOhlcv.candle_close_direction[index] = isUp
+        main.pushToMain({index, key: 'candle_close_direction', value: isUp
             ? classifySize(closeDirection, closeDirectionMean, 2, changeLevel)
-            : -Math.abs(classifySize(closeDirection, closeDirectionMean, 2, changeLevel)) || 0;
+            : -Math.abs(classifySize(closeDirection, closeDirectionMean, 2, changeLevel)) || 0})
 
-        main.verticalOhlcv.candle_high_direction[index] = isUp
+
+        main.pushToMain({index, key: 'candle_high_direction', value: isUp
             ? classifySize(highDirection, highDirectionMean, 2, changeLevel)
-            : -Math.abs(classifySize(highDirection, highDirectionMean, 2, changeLevel)) || 0;
+            : -Math.abs(classifySize(highDirection, highDirectionMean, 2, changeLevel)) || 0})
 
-        main.verticalOhlcv.candle_low_direction[index] = isUp
+        main.pushToMain({index, key: 'candle_low_direction', value: isUp
             ? classifySize(lowDirection, lowDirectionMean, 2, changeLevel)
-            : -Math.abs(classifySize(lowDirection, lowDirectionMean, 2, changeLevel)) || 0;
+            : -Math.abs(classifySize(lowDirection, lowDirectionMean, 2, changeLevel)) || 0})
 
-        main.verticalOhlcv.candle_open_direction[index] = isUp
+        main.pushToMain({index, key: 'candle_open_direction', value: isUp
             ? classifySize(openDirection, openDirectionMean, 2, changeLevel)
-            : -Math.abs(classifySize(openDirection, openDirectionMean, 2, changeLevel)) || 0;
+            : -Math.abs(classifySize(openDirection, openDirectionMean, 2, changeLevel)) || 0})
+
+        main.pushToMain({index, key: 'candle_top_size', value: classifySize(topSize, topSizeMean, 0.5, sizeLevel)})
+        main.pushToMain({index, key: 'candle_bottom_size', value: classifySize(bottomSize, bottomSizeMean, 0.5, sizeLevel)})
+        main.pushToMain({index, key: 'candle_shadow_size', value: classifySize(shadowSize, shadowSizeMean, 0.5, sizeLevel)})
 
-        main.verticalOhlcv.candle_top_size[index] = classifySize(topSize, topSizeMean, 0.5, sizeLevel);
-        main.verticalOhlcv.candle_bottom_size[index] = classifySize(bottomSize, bottomSizeMean, 0.5, sizeLevel);
-        main.verticalOhlcv.candle_shadow_size[index] = classifySize(shadowSize, shadowSizeMean, 0.5, sizeLevel);
     } else {
         // Without classification, just store raw values
-        main.verticalOhlcv.candle_body_size[index] = isUp ? candleBodySize : -candleBodySize;
-        main.verticalOhlcv.candle_gap_size[index] = isUp ? gapSize : -gapSize;
-        main.verticalOhlcv.candle_close_direction[index] = isUp ? closeDirection : -closeDirection;
-        main.verticalOhlcv.candle_high_direction[index] = isUp ? highDirection : -highDirection;
-        main.verticalOhlcv.candle_low_direction[index] = isUp ? lowDirection : -lowDirection;
-        main.verticalOhlcv.candle_open_direction[index] = isUp ? openDirection : -openDirection;
-
-        main.verticalOhlcv.candle_top_size[index] = topSize;
-        main.verticalOhlcv.candle_bottom_size[index] = bottomSize;
-        main.verticalOhlcv.candle_shadow_size[index] = shadowSize;
+
+        main.pushToMain({index, key: 'candle_body_size', value: isUp ? candleBodySize : -candleBodySize})
+        main.pushToMain({index, key: 'candle_gap_size', value: isUp ? gapSize : -gapSize})
+        main.pushToMain({index, key: 'candle_close_direction', value: isUp ? closeDirection : -closeDirection})
+        main.pushToMain({index, key: 'candle_high_direction', value: isUp ? highDirection : -highDirection})
+        main.pushToMain({index, key: 'candle_low_direction', value: isUp ? lowDirection : -lowDirection})
+        main.pushToMain({index, key: 'candle_open_direction', value: isUp ? openDirection : -openDirection})
+        main.pushToMain({index, key: 'candle_top_size', value: topSize})
+        main.pushToMain({index, key: 'candle_bottom_size', value: bottomSize})
+        main.pushToMain({index, key: 'candle_shadow_size', value: shadowSize})
     }
 
     return true;

package/src/studies/dateTime.js

@@ -48,15 +48,14 @@ export const dateTime = (main, index) => {
         main.instances.dateTime.sessionIntradayIndexCount = 0
     }
 
-
-    main.verticalOhlcv.session_daily_index[index] = main.instances.dateTime.sessionDailyIndexCount
-    main.verticalOhlcv.session_intraday_index[index] =  main.instances.dateTime.sessionIntradayIndexCount
-    main.verticalOhlcv.day_of_the_week[index] = day_of_the_week
-    main.verticalOhlcv.day_of_the_month[index] = day_of_the_month
-    main.verticalOhlcv.week_of_the_month[index] = week_of_the_month
-    main.verticalOhlcv.month[index] = month
-    main.verticalOhlcv.year[index] = year
-    main.verticalOhlcv.hour[index] = hour
+    main.pushToMain({index, key: 'session_daily_index', value:  main.instances.dateTime.sessionDailyIndexCount})
+    main.pushToMain({index, key: 'session_intraday_index', value: main.instances.dateTime.sessionIntradayIndexCount})
+    main.pushToMain({index, key: 'day_of_the_week', value: day_of_the_week})
+    main.pushToMain({index, key: 'day_of_the_month', value: day_of_the_month})
+    main.pushToMain({index, key: 'week_of_the_month', value: week_of_the_month})
+    main.pushToMain({index, key: 'month', value: month})
+    main.pushToMain({index, key: 'year', value: year})
+    main.pushToMain({index, key: 'hour', value: hour})
 
 }
 

package/src/studies/findCrosses.js

@@ -188,7 +188,7 @@ export const crossPairs = (main, index) => {
             main.instances[crossName].update({fast: fastValue, slow: slowValue})
         }
 
-        main.verticalOhlcv[crossName][index] = main.instances[crossName].getResult()
+        main.pushToMain({index, key: crossName, value: main.instances[crossName].getResult()})
     }
 
 }

package/src/studies/lag.js

@@ -8,6 +8,19 @@ export const lag = (main, index) => {
 
         const params = findParams.map(o => o.params)
 
+        for (const [colKeys, lags] of params)
+        {
+            for (const colKey of colKeys)
+            {
+                if(main.priceBased.includes(colKey))
+                {
+                    for (let lag = 1; lag <= lags; lag++) {
+                        main.priceBased.push(`${colKey}_lag_${lag}`)
+                    }
+                }
+            }
+        }
+
         main.instances.lag = {
             lagParams: params
         }
@@ -33,7 +46,7 @@ export const lag = (main, index) => {
 
                 if(laggedIndex <= 0) break
     
-                main.verticalOhlcv[key][index] = currentColumn[laggedIndex]
+                main.pushToMain({index, key, value: currentColumn[laggedIndex]})
             }
         }
     }

package/src/studies/priceVariations.js

@@ -9,14 +9,15 @@ export const priceVariations = (main, index) => {
             mid_price_open_close: [...main.nullArray],
             mid_price_high_low: [...main.nullArray]
         })
+
+
     }
 
     const open = main.verticalOhlcv.open[index]
     const high = main.verticalOhlcv.high[index]
     const low = main.verticalOhlcv.low[index]
     const close = main.verticalOhlcv.close[index]
-
-    main.verticalOhlcv.mid_price_open_close[index] = (open + close) / 2
-    main.verticalOhlcv.mid_price_high_low[index] = (high + low) / 2
-
+    
+    main.pushToMain({index, key: 'mid_price_open_close', value: (open + close) / 2})
+    main.pushToMain({index, key: 'mid_price_high_low', value: (high + low) / 2})
 }

package/src/utilities/parsing-utilities.js

@@ -1,110 +1,174 @@
-import { validateInputParams } from "./validators.js"
-import { rsi } from "../oscillators/rsi.js"
-import { sma } from "../moving-averages/sma.js"
-import { ema } from "../moving-averages/ema.js"
-import { macd } from "../moving-averages/macd.js"
-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 { candleStudies } from "../studies/candleStudies.js"
-import { lag } from "../studies/lag.js"
-import {crossPairs} from "../studies/findCrosses.js"
-import { dateTime } from "../studies/dateTime.js"
-import { priceVariations } from "../studies/priceVariations.js"
-
-
+import { validateInputParams } from "./validators.js";
+import { rsi } from "../oscillators/rsi.js";
+import { sma } from "../moving-averages/sma.js";
+import { ema } from "../moving-averages/ema.js";
+import { macd } from "../moving-averages/macd.js";
+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 { candleStudies } from "../studies/candleStudies.js";
+import { lag } from "../studies/lag.js";
+import { crossPairs } from "../studies/findCrosses.js";
+import { dateTime } from "../studies/dateTime.js";
+import { priceVariations } from "../studies/priceVariations.js";
+
+// Helper to clean non-numeric characters (except "-" at the start and decimal point)
+const cleanNumStr = str => str.replace(/(?!^-)[^0-9.]/g, '');
+
+// Map indicator keys to their respective functions
 const indicatorFunctions = {
-    dateTime,
-    priceVariations,
-    rsi,
-    sma,
-    ema,
-    macd,
-    relativeVolume,
-    donchianChannels,
-    bollingerBands,
-    volumeOscillator,
-    candleStudies
-}
-
-
-export const parseOhlcvToVertical = (input, main, startIndex = 0) => {
-    const { len, inputParams } = main
-
-    main.nullArray = new Array(len).fill(null)
-
-    if (startIndex === 0) {
-
-        validateInputParams(main)
-
-        const baseKeys = ['open', 'high', 'low', 'close', 'volume'];
-        const baseKeysSet = new Set(baseKeys);
+  dateTime,
+  priceVariations,
+  rsi,
+  sma,
+  ema,
+  macd,
+  relativeVolume,
+  donchianChannels,
+  bollingerBands,
+  volumeOscillator,
+  candleStudies
+};
 
-        // Fresh initialization
-        for (let i = 0; i < baseKeys.length; i++) {
-            main.verticalOhlcv[baseKeys[i]] = [...main.nullArray]
-        }
+// 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
+      }))
+    : [];
+
+// Sets the input types for each key based on the first row of data
+const setInputTypes = (row0, main) => {
+  const isValidNumberString = str => /^(\d+(\.\d*)?|\.\d+)$/.test(str);
+
+  for (const key of Object.keys(main.inputTypes)) {
+    if (!(key in row0)) {
+      throw new Error(`Property "${key}" not found in ohlcv array. ${main.ticker}`);
+    }
 
-        const inputKeys = Object.keys(input[0]);
-        const otherKeys = [];
-        for (let i = 0; i < inputKeys.length; i++) {
-            const key = inputKeys[i]
-            if (!baseKeysSet.has(key)) {
-                main.verticalOhlcv[key] = [...main.nullArray]
-                otherKeys.push(key)
-            }
-        }
-        main.otherKeys = otherKeys;
+    let value = row0[key];
 
+    
 
+    if (typeof value === 'number' && value > 0) {
+      main.inputTypes[key] = 'number';
+    } else if (typeof value === 'string' && isValidNumberString(value)) {
+      main.inputTypes[key] = 'string';
+      value = cleanNumStr(value);
     } else {
-        if (!main.otherKeys) {
-            throw new Error("otherKeys not found in main. Ensure you run with startIndex=0 first to initialize.");
-        }
+      throw new Error(`Invalid property "${key}" in ohlcv array. ${main.ticker}`);
     }
 
-    const indicatorCalls = processIndicatorCalls(inputParams);
-
-
-    for (let x = startIndex; x < len; x++) {
-        const current = input[x];
-
-        main.verticalOhlcv.open[x] = current.open;
-        main.verticalOhlcv.high[x] = current.high;
-        main.verticalOhlcv.low[x] = current.low;
-        main.verticalOhlcv.close[x] = current.close;
-        main.verticalOhlcv.volume[x] = current.volume;
-
-        for (let i = 0; i < main.otherKeys.length; i++) {
-            const k = main.otherKeys[i];
-            main.verticalOhlcv[k][x] = current[k];
-        }
-
-        for (let i = 0; i < indicatorCalls.length; i++) {
-            const { fn, args, key } = indicatorCalls[i];
-            if (key === 'crossPairs' || key === 'lag') continue;
-
-            fn(main, x, ...args)
-        }
-
-        lag(main, x);
-        crossPairs(main, x);
-        main.lastComputedIndex++;
+    // Determine precisionMultiplier if not already set
+    if (main.precisionMultiplier === 0) {
+      const [, decimals = ''] = String(value).split('.');
+      const decimalPrecision = Math.max(4, decimals.length);
+      main.precisionMultiplier = decimalPrecision > 1 ? Math.pow(10, decimalPrecision - 1) : 1;
     }
+  }
 };
 
+// Parses a number from either a numeric or string input, applying a multiplier to fix precision issues
+const parseNumber = (num, type, precisionMultiplier) => {
+  const addMultiplier = cNum =>
+    precisionMultiplier > 1 ? cNum * precisionMultiplier : cNum;
+
+  if (type === 'number') {
+    return addMultiplier(num);
+  } else if (type === 'string') {
+    const cleanedStr = cleanNumStr(num);
+    return addMultiplier(Number(cleanedStr));
+  } else
+  {
+    return 0 // Optionally: throw an error if type is not recognized
+  }
+  
+};
+
+const parseVolume = (volume, type) => {
 
-const processIndicatorCalls = inputParams => {
-    if (!inputParams || typeof inputParams !== 'object') return []
+  if(type === 'number') return volume
+  else if(type === 'string'){
+    return Number(cleanNumStr(volume))
+  }
+  else
+  {
+    return 0 // Optionally: throw an error if type is not recognized
+  }
+}
 
-    const indicatorCalls = []
+export const parseOhlcvToVertical = (input, main, startIndex = 0) => {
+  const { len, inputParams } = main;
+  main.nullArray = new Array(len).fill(null);
+
+  const BASE_KEYS = ['open', 'high', 'low', 'close', 'volume'];
+  const baseKeysSet = new Set(BASE_KEYS);
+
+  if (startIndex === 0) {
+    // Validate parameters and initialize base keys in verticalOhlcv
+    validateInputParams(main);
+    BASE_KEYS.forEach(key => {
+      main.verticalOhlcv[key] = [...main.nullArray];
+    });
+
+    // Identify any additional keys from the first input row and initialize them
+    const inputKeys = Object.keys(input[0]);
+    const otherKeys = inputKeys.filter(key => !baseKeysSet.has(key));
+    otherKeys.forEach(key => {
+      main.verticalOhlcv[key] = [...main.nullArray];
+    });
+    main.otherKeys = otherKeys;
+
+    // Set the input types once using the first row
+    setInputTypes(input[0], main);
+  } else if (!main.otherKeys) {
+    throw new Error(
+      "otherKeys not found in main. Ensure you run with startIndex=0 first to initialize."
+    );
+  }
+
+  // Prepare the list of indicator function calls
+  const indicatorCalls = processIndicatorCalls(inputParams);
+
+  // Process each row in the input
+  for (let x = startIndex; x < len; x++) {
+    const current = input[x];
+    // Destructure the base keys and use the rest for other properties
+    const { open, high, low, close, volume, ...rest } = current
+    const {precisionMultiplier} = main
+
+    const parsedOpen = parseNumber(open, main.inputTypes.open, precisionMultiplier)
+    const parsedHigh = parseNumber(open, main.inputTypes.high, precisionMultiplier)
+    const parsedLow = parseNumber(open, main.inputTypes.low, precisionMultiplier)
+    const parsedClose = parseNumber(open, main.inputTypes.close, precisionMultiplier)
+    const parsedVolume = parseVolume (volume, main.inputTypes.volume)
+
+    main.pushToMain({index: x, key: 'open', value: parsedOpen})
+    main.pushToMain({index: x, key: 'high', value: parsedHigh})
+    main.pushToMain({index: x, key: 'low', value: parsedLow})
+    main.pushToMain({index: x, key: 'close', value: parsedClose})
+    main.pushToMain({index: x, key: 'volume', value: parsedVolume})
+
+
+    // Populate any extra keys identified during initialization
+    for (const key of main.otherKeys) {
+      main.pushToMain({index: x, key, value: rest[key]})
+    }
 
-    for(let x = 0; x < inputParams.length; x++)
-    {
-        const {key, params} = inputParams[x]
-        indicatorCalls.push({key, fn: indicatorFunctions[key], args: params})
+    // 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);
     }
 
-    return indicatorCalls;
+    // Process these indicators separately (ensuring their execution order)
+    lag(main, x);
+    crossPairs(main, x);
+
+    main.lastComputedIndex++;
+  }
 };