ohlcv-indicators 3.5.44 → 3.5.46

package/index.js

@@ -14,8 +14,7 @@ import {
 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 { buildArray } 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'
@@ -39,16 +38,14 @@ import { normalizeMinMax } from './src/machine-learning/ml-utilities.js'
  */
 
 export default class OHLCV_INDICATORS {
-    constructor({input, ticker = null, precision = true, inputParams = null, chunkProcess = 2000, ML = {}}) {
+    constructor({input, ticker = null, inputParams = null, chunkProcess = 2000, ML = {}}) {
 
         validateArray(input, 'input', (ticker !== null) ? `contructor ${ticker}` : 'constuctor')
         if(input.length === 0) throw Error('input OHLCV must not be empty: ' + ticker)
 
-        validateBoolean(precision, 'precision', 'constructor')
         validateNumber(chunkProcess, {min: 100, max: 50000, allowDecimals: false}, 'chunkProcess', 'constructor')
         validateObject(ML, 'ML', 'constructor')
 
-        this.notNumberKeys = new Set()
         this.chunkProcess = chunkProcess
         
         this.input = [...input]
@@ -74,8 +71,6 @@ export default class OHLCV_INDICATORS {
         }
 
         this.invalidValueIndex = -1
-        this.precision = precision
-        this.precisionMultiplier = calcPrecisionMultiplier(this, this.firstRow)
         this.scaledGroups = {}
         this.isAlreadyComputed = new Set()
 
@@ -119,14 +114,10 @@ export default class OHLCV_INDICATORS {
         validateObject(options, 'options', 'getDataAsCols')
       
         const {
-          precisionMultiplier,
-          precision,
           len,
           invalidValueIndex,
           verticalOhlcv,
-          arrayTypes,
           verticalOhlcvTempCols,
-          notNumberKeys
         } = this
         const result = {}
 
@@ -137,16 +128,13 @@ export default class OHLCV_INDICATORS {
 
             if(verticalOhlcvTempCols.has(key)) continue
 
-            const shouldApplyPrecision = precision && !notNumberKeys.has(key)
-            result[key] = buildArray(arrayTypes[key], newLen)
+            const thisArrType = getArrayType(key, verticalOhlcv[key])
+
+            result[key] = buildArray(thisArrType, newLen)
 
             for (let x = startIndex; x < len; x++)
             {
-                if(shouldApplyPrecision)
-                {
-                    result[key][x] = arr[x] / precisionMultiplier 
-                }
-                else if(key === 'date')
+                if(key === 'date')
                 {
                     result[key][x] = dateOutputFormaters[dateFormat](arr[x])
                 }
@@ -377,10 +365,13 @@ export default class OHLCV_INDICATORS {
         validateNumber(smoothing, {min: size, max: this.len, allowDecimals: false}, 'smoothing', methodName)
         validateObject(options, 'options', methodName)
 
-        const {target = 'close', lag = 0} = options
+        const {target = 'close', lag = 0, atrLength = 200, bandDistance = 2, liquidityLookback = 20} = options
 
         validateString(target, 'options.target', methodName)
         validateNumber(lag, {min: 0, max: this.len, allowDecimals: false}, 'options.lag', methodName)
+        validateNumber(bandDistance, {min: 0.01, max: 10, allowDecimals: true}, 'options.bandDistance', methodName)
+        validateNumber(atrLength, {min: 2, max: this.len, allowDecimals: false}, 'options.atrLength', methodName)
+        validateNumber(liquidityLookback, {min: 1, max: this.len, allowDecimals: false}, 'options.liquidityLookback', methodName)
 
         const order = getOrderFromArray([target], methodName)
 

package/package.json

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

@@ -47,13 +47,11 @@ const mainFunctions = {
 export const mainLoop = (input, main) => {
   const { len, 
     inputParams, 
-    precisionMultiplier, 
     arrayTypes, 
     verticalOhlcv, 
     verticalOhlcvKeyNames, 
     inputTypes, 
     chunkProcess, 
-    notNumberKeys, 
     processSecondaryLoop,
   } = main;
 
@@ -77,12 +75,7 @@ export const mainLoop = (input, main) => {
 
           if(numberFormater.hasOwnProperty(formaterKey))
           {
-            let formatedValue = numberFormater[formaterKey](value)
-
-            if(precisionMultiplier > 1 && !notNumberKeys.has(key))
-            {
-              formatedValue = formatedValue * precisionMultiplier
-            }
+            const formatedValue = numberFormater[formaterKey](value)
 
             main.pushToMain({index, key, value: formatedValue})
           }

package/src/machine-learning/balancing.js

@@ -0,0 +1,65 @@
+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,6 +1,7 @@
-import { getFeaturedKeys, computeFlatFeaturesLen, countUniqueLabels, logMlTraining, updateClassifierMetrics, findGroupsFunc } from "./ml-utilities.js"
+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'
 
@@ -246,9 +247,9 @@ export const classifier = (
 
       const {train} = modelConfig
 
-      console.log(yRows)
+      const {X: overX, Y: overY} = oversampleXY(xRows, yRows)      
 
-      const trainedModel = train({modelClass, xRows, yRows, modelArgs, uniqueLabels: uniqueLabels[loopIdx]})
+      const trainedModel = train({modelClass, xRows: overX, yRows: overY, modelArgs, uniqueLabels: uniqueLabels[loopIdx]})
 
       allModels[predictionKey].push(
        trainedModel

package/src/machine-learning/ml-utilities.js

@@ -69,24 +69,6 @@ export const computeFlatFeaturesLen = (featureCols, verticalOhlcv, index) => {
 }
 
 
-export const countUniqueLabels = Y => {
-  // If Y[0] isn't an array, treat Y as a single-column 2D array
-  const data = Array.isArray(Y[0]) ? Y : Y.map(v => [v]);
-
-  // Number of columns in our (possibly wrapped) data
-  const nCols = data[0].length;
-
-  // Sum up the unique values in each column
-  const totalLabels = Array.from({ length: nCols }).reduce((sum, _, col) => {
-    const uniques = new Set(data.map(row => row[col]));
-    return sum + uniques.size;
-  }, 0);
-
-  // Return count + 1 (same as before)
-  return totalLabels + 1;
-}
-
-
 export const getFeaturedKeys = ({trainingCols, findGroups, verticalOhlcv, scaledGroups}) => {
 
   const featureCols = [...trainingCols, ...(findGroupsFunc(findGroups, scaledGroups))]

package/src/machine-learning/pca.js

@@ -22,7 +22,6 @@ export const pca = (main, index, {prefix, trainingSize, findGroups, trainingCols
         }
         
         verticalOhlcv[prefix] = new Array(len).fill(null)
-        main.notNumberKeys.add(prefix)
     }
     else if(index < startIndex || index < lookbackAbs)
     {

package/src/machine-learning/scaler.js

@@ -5,7 +5,7 @@ export const scaler = (main, index, size, colKeys, {type, group, range, lag, pre
     
 
     const {groupKey, groupKeyLen} = precomputed
-    const { verticalOhlcv, instances, arrayTypes, invalidValueIndex } = main;
+    const { verticalOhlcv, instances, invalidValueIndex } = main;
     const prefix = `${type}_${size}`;
   
     if(index === 0) {
@@ -37,8 +37,7 @@ export const scaler = (main, index, size, colKeys, {type, group, range, lag, pre
         }
   
         const key = `${prefix}_${target}`;
-        verticalOhlcv[key] = new Float64Array(len).fill(NaN);
-        arrayTypes[key] = 'Float64Array'
+        verticalOhlcv[key] = new Float64Array(len).fill(NaN)
   
         const winKey = group ? groupKey : target;
         instances.scaler[prefix].windows[winKey] = [];

package/src/moving-averages/bollingerBands.js

@@ -14,7 +14,7 @@ export const bollingerBands = (main, index, size, stdDev, { height, range = [],
   // Initialization on the first call.
   if (index === 0) {
 
-    const {inputParams, verticalOhlcv, len, arrayTypes } = main;
+    const {inputParams, verticalOhlcv, len } = main;
 
     if (!(target in verticalOhlcv)) {
       throw new Error(`bollingerBands could not find target "${target}"`);
@@ -69,11 +69,6 @@ export const bollingerBands = (main, index, size, stdDev, { height, range = [],
     {
       main.lag(keyNames, lag)
     }
-
-    for(const key of keyNames)
-    {
-      arrayTypes[key] = 'Float64Array'
-    }
   }
 
   const {numberOfIndicators} = instances.bollinger_bands

package/src/moving-averages/donchianChannel.js

@@ -5,7 +5,7 @@ export const donchianChannels = (main, index, size, offset, options) => {
 
   
 
-  const {verticalOhlcv, instances, len, inputParams, arrayTypes, lag} = main
+  const {verticalOhlcv, instances, len, inputParams, lag} = main
   const { height: includeHeight, range: rangeKeys, decimals } = options
   const indicatorKey = `${size}_${offset}`
 
@@ -44,10 +44,7 @@ export const donchianChannels = (main, index, size, offset, options) => {
     );
 
     // apply lag if requested
-    if (lag > 0) main.lag(keys, lag);
-
-    // mark price-based outputs
-    keys.forEach(k => arrayTypes[k] = 'Float64Array');
+    if (lag > 0) main.lag(keys, lag)
   }
 
   // ---- PER-BAR COMPUTATION ----

package/src/moving-averages/macd.js

@@ -11,7 +11,7 @@ export const macd = (main, index, fast, slow, signal, {target, lag, precomputed}
 
   // Initialization on the first index.
   if (index === 0) {
-    const { inputParams, len , arrayTypes} = main
+    const { inputParams, len } = main
 
     if (!verticalOhlcv.hasOwnProperty(target)) {
       throw new Error(`Target property ${target} not found in verticalOhlcv for macd.`)
@@ -57,11 +57,6 @@ export const macd = (main, index, fast, slow, signal, {target, lag, precomputed}
       main.lag(keyNames, lag)
     }
 
-    for(const key of keyNames)
-    {
-      arrayTypes[key] = 'Float64Array'
-    }
-
   }
 
   const { numberOfIndicators, settings } = instances.macd

package/src/moving-averages/movingAverages.js

@@ -16,7 +16,7 @@ export const movingAverages = (main, index, methodName, size, { target, lag }) =
 
   if (index === 0) {
 
-    const {arrayTypes, len} = main
+    const {len} = main
 
     if (!verticalOhlcv.hasOwnProperty(target)) {
       throw new Error(
@@ -33,8 +33,6 @@ export const movingAverages = (main, index, methodName, size, { target, lag }) =
     {
       main.lag([keyName], lag)
     }
-
-    arrayTypes[keyName] = 'Float64Array'
   }
 
   // Retrieve the current price value

package/src/moving-averages/relativeVolume.js

@@ -8,7 +8,7 @@ export const relativeVolume = (main, index, size, {lag}) => {
   const { instances, verticalOhlcv } = main;
 
   if (index === 0) {
-    const { len, arrayTypes } = main;
+    const { len } = main;
 
     instances[key] = {
       instance: new FasterSMA(size),
@@ -21,8 +21,7 @@ export const relativeVolume = (main, index, size, {lag}) => {
     {
       main.lag([key], lag)
     }
-  
-    arrayTypes[key] = 'Float64Array'
+
   }
 
   const value = verticalOhlcv.volume[index];

package/src/moving-averages/vidya.js

@@ -2,8 +2,8 @@ import { FasterSMA } from 'trading-signals';
 // Variable Index Dynamic Average (VIDYA) indicator with volume stats
 
 export const vidya = (main, index, size, momentum, options = {}) => {
-  const { verticalOhlcv, instances, len, arrayTypes, lag } = main;
-  const { target = 'close', atrLength = 200, bandDistance = 2, liquidityLookback = 20 } = options
+  const { verticalOhlcv, instances, len } = main;
+  const { target, lag, atrLength = 200, bandDistance = 2, liquidityLookback = 5 } = options
   const indicatorKey = `${size}_${momentum}`;
 
   // Initialization on the first bar
@@ -37,9 +37,9 @@ export const vidya = (main, index, size, momentum, options = {}) => {
 
     // Allocate output arrays
     Object.values(keys).forEach(key => {
-      verticalOhlcv[key] = new Float64Array(len).fill(NaN);
-      arrayTypes[key] = 'Float64Array';
-    });
+      verticalOhlcv[key] = new Float64Array(len).fill(NaN)
+    })
+    
     if (lag > 0) main.lag(Object.values(keys), lag);
   }
 

package/src/oscillators/rsi.js

@@ -15,7 +15,7 @@ export const rsi = (main, index, size, { target, lag, parser, prefix, minmax })
   // Initialization on the first index.
   if (index === 0) {
 
-    const {len, arrayTypes } = main;
+    const {len } = main;
 
     if (!verticalOhlcv.hasOwnProperty(target)) {
       throw new Error(`Target property ${target} not found in verticalOhlcv for rsi.`);
@@ -50,11 +50,6 @@ export const rsi = (main, index, size, { target, lag, parser, prefix, minmax })
       group.push(...keyNames);
     }
 
-    for(const key of keyNames)
-    {
-      arrayTypes[key] = 'Float64Array'
-    }
-
   }
 
   const value = verticalOhlcv[target][index];

package/src/oscillators/stochastic.js

@@ -5,7 +5,7 @@ export const stochastic = (main, index, kPeriod, kSlowingPeriod, dPeriod, {minma
 
     
 
-    const { verticalOhlcv, instances, scaledGroups } = main;
+    const { verticalOhlcv, instances } = main;
 
     const paramsKey = (kPeriod === 14 && kSlowingPeriod === 3 && dPeriod === 3) ? '' : `${kPeriod}_${kSlowingPeriod}_${dPeriod}`
     const stochD = `${prefix}stoch_d${paramsKey}`;
@@ -15,7 +15,7 @@ export const stochastic = (main, index, kPeriod, kSlowingPeriod, dPeriod, {minma
   // Initialization on the first index.
     if (index === 0) {
 
-        const {len, arrayTypes } = main;
+        const {len } = main;
 
         Object.assign(instances, {
             [instanceKey]: new FasterStochasticOscillator(kPeriod, kSlowingPeriod, dPeriod)
@@ -44,11 +44,6 @@ export const stochastic = (main, index, kPeriod, kSlowingPeriod, dPeriod, {minma
             const group = main.scaledGroups.minmax_rsi ??= [];
             group.push(...keyNames)
         }
-
-        for(const key of keyNames)
-        {
-            arrayTypes[key] = 'Float64Array'
-        }
     }
 
     const close = verticalOhlcv['close'][index]

package/src/oscillators/volumeOscillator.js

@@ -10,7 +10,7 @@ export const volumeOscillator = (main, index, fast, slow, {lag}) => {
 
     if (index === 0) {
 
-        const {len, arrayTypes} = main
+        const {len} = main
         Object.assign(instances, {
             [key]: {
                 fastEMA: new FasterEMA(fast),
@@ -24,8 +24,6 @@ export const volumeOscillator = (main, index, fast, slow, {lag}) => {
         {
             main.lag([key], lag)
         }
-
-        arrayTypes[key] = 'Float64Array'
     }
 
     const { fastEMA, slowEMA } = instances[key];

package/src/studies/dateTime.js

@@ -4,12 +4,12 @@ export const dateTime = (main, index, {lag, oneHot, precompute}) => {
 
     
 
-    const {instances, verticalOhlcv, notNumberKeys} = main
+    const {instances, verticalOhlcv} = main
     const {prefix} = precompute
 
     if(index === 0)
     {
-        const {len, dateType, arrayTypes} = main
+        const {len, dateType} = main
         if(!dateType) throw Error('dateTime method found and invalid "date" in input ohlcv')
 
         const startYear = verticalOhlcv.date[0].getUTCFullYear()
@@ -31,18 +31,12 @@ export const dateTime = (main, index, {lag, oneHot, precompute}) => {
         // choose your ctor, fill-value and type-name once
         const ctor     = oneHot ? Array     : Int16Array
         const fillVal  = oneHot ? null      : NaN
-        const typeName = oneHot ? 'Array'   : 'Int16Array'
 
         // single loop instead of three
         for (const key of colKeys) {
-        // 1) set the arrayType
-        arrayTypes[key] = typeName
 
-        // 2) allocate and fill the backing array
-        verticalOhlcv[key] = new ctor(len).fill(fillVal)
+            verticalOhlcv[key] = new ctor(len).fill(fillVal)
 
-        // 3) mark as non-numeric
-        notNumberKeys.add(key)
         }
 
         // finally, apply lag once

package/src/studies/findCrosses.js

@@ -134,7 +134,7 @@ class CrossInstance {
 
 export const crossPairs = (main, index, crossPairsList, {limit, oneHot}) => {
 
-  const {verticalOhlcv, verticalOhlcvTempCols, instances, len, arrayTypes, notNumberKeys} = main
+  const {verticalOhlcv, verticalOhlcvTempCols, instances, len} = main
 
   for (const { fast, slow } of crossPairsList) {
 
@@ -147,7 +147,6 @@ export const crossPairs = (main, index, crossPairsList, {limit, oneHot}) => {
 
             const col = slow.toString()
             verticalOhlcvTempCols.add(col)
-            notNumberKeys.add(col)
 
             let slowNumArrType = 'Int16Array'
 
@@ -160,7 +159,6 @@ export const crossPairs = (main, index, crossPairsList, {limit, oneHot}) => {
             }
 
             verticalOhlcv[col] =  buildArray(slowNumArrType, len)
-            arrayTypes[col] = 'slowNumArrType'
         }
 
         if(!instances.hasOwnProperty('crossPairs'))
@@ -187,13 +185,8 @@ export const crossPairs = (main, index, crossPairsList, {limit, oneHot}) => {
         if(oneHot)
         {
             verticalOhlcv[`one_hot_${crossName}`] = buildArray('Array', len)
-            notNumberKeys.add(`one_hot_${crossName}`)
         }
 
-        notNumberKeys.add(crossName)
-        
-        arrayTypes[crossName] = 'crossArrType'
-
     }  else if(index + 1 === len) {
         // sanity checks
         if (fast !== "price" && !verticalOhlcv.hasOwnProperty(fast)) {

package/src/studies/lag.js

@@ -1,24 +1,25 @@
-import { buildArray } from "../utilities/assignTypes.js"
+import { buildArray, getArrayType } from "../utilities/assignTypes.js"
 
 export const lag = (main, index, colKeys, lookback) => {
 
   
   
-  const { verticalOhlcv, len, arrayTypes } = main
+  const { verticalOhlcv, len } = main
 
   if(index === 0)
   {
     for (const colKey of colKeys) {
-      if (!arrayTypes.hasOwnProperty(colKey)) {
+      if (!verticalOhlcv.hasOwnProperty(colKey)) {
           throw new Error(
-          `Lag processing invoked by "${colKey}" expected arrayTypes to have a "${colKey}" property, but it wasn’t found.`
+          `Lag processing invoked by col "${colKey}" was not found in "verticalOhlcv".`
           )
       }
 
       for (let step = 1; step <= lookback; step++) {
           const key = `${colKey}_lag_${step}`
-          verticalOhlcv[key] = buildArray(arrayTypes[colKey], len)
-          arrayTypes[key] = arrayTypes[colKey]
+          const thisArrType = getArrayType(colKey, verticalOhlcv[colKey])
+
+          verticalOhlcv[key] = buildArray(thisArrType, len)
       }   
     }
   }

package/src/studies/mapCols.js

@@ -2,7 +2,7 @@ export const mapCols = (main, index, newCols, callback, {lag}) => {
 
     
 
-    const {verticalOhlcv, len, arrayTypes} = main
+    const {verticalOhlcv, len} = main
 
     if(index === 0)
     {
@@ -14,7 +14,6 @@ export const mapCols = (main, index, newCols, callback, {lag}) => {
             }
 
             verticalOhlcv[key] = new Array(len).fill(0)
-            arrayTypes[key] = 'Array'
         }
 
         if(lag > 0)

package/src/utilities/assignTypes.js

@@ -25,7 +25,7 @@ export const buildArray = (arrayType, len) => {
 }
 
 export const assignTypes = main => {
-  const {firstRow, notNumberKeys} = main
+  const {firstRow} = main
   const inputTypes  = {}
   const arrayTypes  = {}
 
@@ -34,13 +34,11 @@ export const assignTypes = main => {
     if (colName === 'date') {
       inputTypes[colName] = selectDateFormatter(cellValue, true)
       arrayTypes[colName] = 'Array'
-      notNumberKeys.add(colName)
     }
     else if(colName === 'volume')
     {
       inputTypes[colName] = classifyNum(cellValue, true)
       arrayTypes[colName] = 'Int32Array'
-      notNumberKeys.add(colName)
     }
     else if(numberKeys.has(colName))
     {
@@ -50,14 +48,16 @@ export const assignTypes = main => {
       const thisType = classifyNum(cellValue, false)
       inputTypes[colName] = thisType
       arrayTypes[colName] = (thisType === 'number') ? 'Float64Array' : 'Array'
-
-      if(!thisType.startsWith('number'))
-      {
-        notNumberKeys.add(colName)
-      }
-
     }
   }
 
   return { inputTypes, arrayTypes }
 }
+
+
+export const getArrayType = (key, arr) => {
+  if (!arr || typeof arr !== 'object') {
+    throw new TypeError(`Invalid array type: "${key}"`);
+  }
+  return arr.constructor.name;
+}

package/src/utilities/verticalToHorizontal.js

@@ -2,7 +2,7 @@ import { dateOutputFormaters } from "./dateUtilities.js"
 
 export const verticalToHorizontal = ({main, skipNull = false, startIndex = 0, dateFormat}) => {
 
-  const {precisionMultiplier, precision, verticalOhlcv, invalidValueIndex, len, verticalOhlcvKeyNames, verticalOhlcvTempCols, notNumberKeys} = main
+  const {verticalOhlcv, invalidValueIndex, len, verticalOhlcvKeyNames, verticalOhlcvTempCols} = main
 
   if (verticalOhlcvKeyNames.length === 0) return []
   
@@ -13,16 +13,10 @@ export const verticalToHorizontal = ({main, skipNull = false, startIndex = 0, da
 
    for(const [key, arr] of Object.entries(verticalOhlcv)){
     if(verticalOhlcvTempCols.has(key)) continue
-    const shouldApplyPrecision = precision && !notNumberKeys.has(key)
 
     for (let i = maxStartIndex; i < len; i++)
     {
-      if(shouldApplyPrecision)
-      {
-        result[i - maxStartIndex][key] = arr[i] / precisionMultiplier 
-
-      }
-      else if(key === 'date')
+      if(key === 'date')
       {
         result[i - maxStartIndex][key] = dateOutputFormaters[dateFormat](arr[i])
       }