ohlcv-indicators 3.5.53 → 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}
@@ -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'
@@ -479,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;
     }
@@ -537,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.53",
+  "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;

package/src/moving-averages/heikenAshi.js

@@ -1,7 +1,7 @@
 import { FasterEMA } from 'trading-signals';
 
 export const heikenAshi = (main, index, smoothLength, afterSmoothLength, { lag = 0, bothNull = false } = {}) => {
-  const { verticalOhlcv, instances, len } = main;
+  const { verticalOhlcv, instances, len, priceBased } = main;
   const prefix = (bothNull) ?  'heiken_ashi' : `heiken_ashi_${smoothLength}_${afterSmoothLength}`;
   const keys = ['open', 'high', 'low', 'close'];
 
@@ -26,6 +26,10 @@ export const heikenAshi = (main, index, smoothLength, afterSmoothLength, { lag =
       [...keyNames, `${prefix}_cross`].map(v => [v, new Float64Array(len).fill(NaN)])
     );
 
+    for(const k of keyNames) {
+      priceBased.add(k)
+    }
+
     Object.assign(verticalOhlcv, { ...verticalOhlcvSetup });
 
     if (lag > 0) {

package/src/moving-averages/macd.js

@@ -6,7 +6,7 @@ export const macd = (main, index, fast, slow, signal, {target, lag, precomputed}
 
   
 
-  const { verticalOhlcv, instances } = main
+  const { verticalOhlcv, instances, priceBased } = main
   const {instanceKey} = precomputed
 
   // Initialization on the first index.
@@ -52,6 +52,10 @@ export const macd = (main, index, fast, slow, signal, {target, lag, precomputed}
 
     const keyNames = [diffKey, deaKey, histogramKey]
 
+    for(const k of keyNames) {
+      priceBased.add(k)
+    }
+
     if(lag > 0)
     {
       main.lag(keyNames, lag)

package/src/moving-averages/movingAverages.js

@@ -10,7 +10,7 @@ export const movingAverages = (main, index, methodName, size, { target, lag }) =
 
   
 
-  const { verticalOhlcv, instances } = main
+  const { verticalOhlcv, instances, priceBased } = main
   const suffix = (target !== 'close') ?  `_${target}` : ''
   const keyName = `${methodName}_${size}${suffix}`
 
@@ -29,6 +29,10 @@ export const movingAverages = (main, index, methodName, size, { target, lag }) =
 
     verticalOhlcv[keyName] = new Float64Array(len).fill(NaN)
 
+    if(priceBased.has(target)){
+      priceBased.add(keyName)
+    }
+
     if(lag > 0)
     {
       main.lag([keyName], lag)

package/src/moving-averages/vidya.js

@@ -2,7 +2,7 @@ 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 } = main;
+  const { verticalOhlcv, instances, len, priceBased } = main;
   const { target, lag, atrLength = 200, bandDistance = 2, liquidityLookback = 5 } = options
   const indicatorKey = `${size}_${momentum}`;
 
@@ -23,6 +23,12 @@ export const vidya = (main, index, size, momentum, options = {}) => {
       liquidity: `${prefix}_liquidity`,
     };
 
+    const priceBasedVidyaKeys = [keyBase, keys.upper, keys.lower, keys.liquidity]
+
+    for(const k of priceBasedVidyaKeys) {
+      priceBased.add(k)
+    }
+
     // Prepare instances container
     if (!instances.vidya) instances.vidya = { settings: {} };
     instances.vidya.settings[indicatorKey] = {

package/src/oscillators/volumeDelta.js

@@ -0,0 +1,74 @@
+export const volumeDelta = (main, index, { lag = 0 }) => {
+  const { verticalOhlcv, instances, len } = main;
+  const groupName = 'volume_delta';
+
+  if (index === 0) {
+    if (!instances[groupName]) instances[groupName] = { isBuyVolume: true, cross: 0 };
+
+    const keys = [
+      `${groupName}_open`,
+      `${groupName}_high`,
+      `${groupName}_low`,
+      `${groupName}_close`,
+      `${groupName}_cross`,
+    ];
+
+    // allocate outputs
+    for (const k of keys) verticalOhlcv[k] = new Float64Array(len).fill(NaN);
+
+    // optional lag
+    if (lag > 0) main.lag(keys, lag);
+  }
+
+  const inst = instances[groupName];
+
+  // inputs
+  const vol       = verticalOhlcv.volume[index];
+  const open      = verticalOhlcv.open[index];
+  const close     = verticalOhlcv.close[index];
+  const prevClose = index > 0 ? verticalOhlcv.close[index - 1] : NaN;
+
+  // TradingView tie-breaks:
+  // 1) close>open -> buy, 2) close<open -> sell,
+  // 3) equal: compare to prev close, 4) still equal: carry prior state
+  let isBuy = inst.isBuyVolume;
+  if (close > open) isBuy = true;
+  else if (close < open) isBuy = false;
+  else if (close > prevClose) isBuy = true;
+  else if (close < prevClose) isBuy = false;
+
+  inst.isBuyVolume = isBuy;
+
+  if(index < 1)
+  {
+    if(isBuy) inst.cross = 1
+    else inst.cross = -1
+  }
+  else {
+    if(isBuy)
+    {
+        if(inst.cross > 0) inst.cross = inst.cross + 1
+        else inst.cross = 1 //reset
+    } else {
+        if(inst.cross > 0) inst.cross = -1 //reset
+        else inst.cross = inst.cross - 1
+    }
+  }
+  
+
+  const delta = Number.isFinite(vol) ? (isBuy ? vol : -vol) : NaN;
+
+  // delta "candle"
+  const openVal  = Number.isNaN(delta) ? NaN : 0;
+  const closeVal = delta;
+  const highVal  = Number.isNaN(delta) ? NaN : Math.max(delta, 0);
+  const lowVal   = Number.isNaN(delta) ? NaN : Math.min(delta, 0);
+
+  main.pushToMain({ index, key: `${groupName}_open`,  value: openVal });
+  main.pushToMain({ index, key: `${groupName}_high`,  value: highVal });
+  main.pushToMain({ index, key: `${groupName}_low`,   value: lowVal });
+  main.pushToMain({ index, key: `${groupName}_close`, value: closeVal });
+  main.pushToMain({ index, key: `${groupName}_cross`, value: inst.cross });
+
+  return true;
+};

package/src/studies/findCrosses.js

@@ -1,5 +1,6 @@
 import { oneHotEncode } from "../machine-learning/ml-utilities.js"
 import { buildArray } from "../utilities/assignTypes.js"
+import { addPrecisionAsNumber } from "../utilities/precisionMultiplier.js"
 const eq = (fast, slow) => fast === slow
 const gt = (fast, slow) => fast > slow
 const lt = (fast, slow) => fast < slow
@@ -134,7 +135,7 @@ class CrossInstance {
 
 export const crossPairs = (main, index, crossPairsList, {oneHot, limit}) => {
 
-  const {verticalOhlcv, verticalOhlcvTempCols, instances, len} = main
+  const {verticalOhlcv, verticalOhlcvTempCols, instances, len, precision, precisionMultiplier, priceBased} = main
 
   for (const { fast, slow } of crossPairsList) {
 
@@ -147,8 +148,15 @@ export const crossPairs = (main, index, crossPairsList, {oneHot, limit}) => {
 
             const col = slow.toString()
             verticalOhlcvTempCols.add(col)
-            const numArrType = (slow >= -125 || slow <= 125) ? 'Int8Array' : 'Int16Array'
-            verticalOhlcv[col] =  buildArray(numArrType, len, slow)
+
+            const requiresPrecision = precision && (fast === 'price' || priceBased.has(fast))
+
+            const slowVal = requiresPrecision
+                ? addPrecisionAsNumber(col, precisionMultiplier) 
+                : slow
+
+            const numArrType = (slow >= -125 && slow <= 125 && requiresPrecision === false) ? 'Int8Array' : 'Float64Array'
+            verticalOhlcv[col] =  buildArray(numArrType, len, slowVal)
         }
 
         if(!instances.hasOwnProperty('crossPairs'))
@@ -163,7 +171,7 @@ export const crossPairs = (main, index, crossPairsList, {oneHot, limit}) => {
             max: -Infinity
         }
 
-        const crossArrType = (limit !== null && limit <= 125) ? 'Int8Array' : 'Int16Array'
+        const crossArrType = (limit !== null && limit <= 125) ? 'Int8Array' : 'Float64Array'
 
         verticalOhlcv[crossName] = buildArray(crossArrType, len, 0)
 

package/src/studies/lag.js

@@ -4,32 +4,37 @@ export const lag = (main, index, colKeys, lookback) => {
 
   
   
-  const { verticalOhlcv, len } = main
+  const { verticalOhlcv, len, priceBased } = main
 
   if(index === 0)
   {
-    for (const colKey of colKeys) {
-      if (!verticalOhlcv.hasOwnProperty(colKey)) {
-          throw new Error(
-          `Lag processing invoked by col "${colKey}" was not found in "verticalOhlcv".`
-          )
+    for (const targetKey of colKeys) {
+      if (!verticalOhlcv.hasOwnProperty(targetKey)) {
+        throw new Error(
+        `Lag processing invoked by col "${targetKey}" was not found in "verticalOhlcv".`
+        )
       }
 
+      const addToPriceBased = priceBased.has(targetKey)
+
       for (let step = 1; step <= lookback; step++) {
-          const key = `${colKey}_lag_${step}`
-          const thisArrType = getArrayType(colKey, verticalOhlcv[colKey])
+        const key = `${targetKey}_lag_${step}`
+
+        if(addToPriceBased) priceBased.add(key)
+
+        const thisArrType = getArrayType(targetKey, verticalOhlcv[targetKey])
 
-          verticalOhlcv[key] = buildArray(thisArrType, len)
+        verticalOhlcv[key] = buildArray(thisArrType, len)
       }   
     }
   }
 
-  for (const colKey of colKeys) {
-    const currentColumn = verticalOhlcv[colKey]
+  for (const targetKey of colKeys) {
+    const currentColumn = verticalOhlcv[targetKey]
 
     // Populate the lagged values each tick:
     for (let step = 1; step <= lookback; step++) {
-      const key = `${colKey}_lag_${step}`
+      const key = `${targetKey}_lag_${step}`
       const laggedIndex = index - step
       const value =
         laggedIndex < 0 || currentColumn[laggedIndex] === undefined

package/src/utilities/assignTypes.js

@@ -1,8 +1,6 @@
 import { classifyNum } from "./numberUtilities.js";
 import { selectDateFormatter } from "./dateUtilities.js";
 
-const numberKeys = new Set(['open', 'high', 'low', 'close'])
-
 export const buildArray = (arrayType, len, fallbackValue) => {
   const ctorMap = {
     Array:        Array,
@@ -35,7 +33,7 @@ export const buildArray = (arrayType, len, fallbackValue) => {
 }
 
 export const assignTypes = main => {
-  const {firstRow} = main
+  const {firstRow, precision, initialPriceBased} = main
   const inputTypes  = {}
   const arrayTypes  = {}
 
@@ -50,12 +48,12 @@ export const assignTypes = main => {
       inputTypes[colName] = classifyNum(cellValue, true)
       arrayTypes[colName] = 'Int32Array'
     }
-    else if(numberKeys.has(colName))
+    else if(initialPriceBased.has(colName))
     {
-      inputTypes[colName] = classifyNum(cellValue, true)
+      inputTypes[colName] = classifyNum(cellValue, true, precision)
       arrayTypes[colName] = 'Float64Array'
     } else {
-      const thisType = classifyNum(cellValue, false)
+      const thisType = classifyNum(cellValue, false, precision)
       inputTypes[colName] = thisType
       arrayTypes[colName] = (thisType === 'number') ? 'Float64Array' : 'Array'
     }

package/src/utilities/numberUtilities.js

@@ -1,52 +1,35 @@
-// Helper to clean non-numeric characters (except "-" at the start and decimal point)
-export const sanitizeDirtyNumberString = str => str.replace(/(?!^-)[^0-9.]/g, '');
+import { addPrecisionAsNumber, revertPrecisionAsNumber } from "./precisionMultiplier.js";
 
-export const numberFormater = {
+export const inputNumberFormatter = {
   number: n => n,
   numberCleanString: n => Number(n),
-  numberDirtyString: n => Number(sanitizeDirtyNumberString(n))
+  precisionNumberCleanString: (strNum, multiplier) => addPrecisionAsNumber(strNum, multiplier)
 }
 
+export const outputNumberFormatter = {
+  number: n => n,
+  numberCleanString: n => n,
+  precisionNumberCleanString: (strNum, multiplier) => revertPrecisionAsNumber(strNum, multiplier)
+}
 
-export const classifyNum = (num, throwError = false) => {
-  // 1) true numbers
-  if (typeof num === 'number' && !Number.isNaN(num)) {
-    return 'number';
-  }
+export const classifyNum = (num, throwError = false, precision = false) => {
 
-  // 2) strings
-  if (typeof num === 'string') {
-    const str = num.trim();
-    const cleanRe = /^-?\d+(\.\d+)?$/;
+  const cleanRe = /^-?\d+(\.\d+)?$/;
+  const isNumber = typeof num === 'number' && !Number.isNaN(num)
+  const isString = typeof num === 'string'
+  const isCleanString = isString && cleanRe.test(num)
 
-    // a) clean numeric string: only digits and an optional single period
-    if (cleanRe.test(str)) {
-      return 'numberCleanString';
-    }
+  if(precision === true) {
+    if(isCleanString) return 'precisionNumberCleanString'
 
-    // b) dirty numeric string: contains non-digits (dollar, commas, letters, etc.)
-    //    but once you strip those out, you're left with a valid number
-    const stripped = str.replace(/[^0-9.]/g, '');
-    if (stripped && cleanRe.test(stripped)) {
-      return 'numberDirtyString';
-    }
+    if(throwError) throw new Error('Invalid number forma')
+    return typeof num
   }
-
-
-  if(throwError)
-  {
-    throw new TypeError(
-      'Invalid input: expected a number or numeric string'
-    );
+  else {
+    if(isNumber) return 'number'
+    else if(isCleanString) return 'numberCleanString'
   }
 
+  if(throwError) throw new TypeError('Invalid input: expected a number or numeric string')
   return typeof num
-};
-
-
-export const roundDecimalPlaces = (value, decimals) => {
-
-  const factor = 10 ** decimals
-  // add a tiny epsilon to mitigate floating-point quirks around .5
-  return Math.round((value + Number.EPSILON) * factor) / factor
-};
+}

package/src/utilities/precisionMultiplier.js

@@ -1,23 +1,98 @@
-export const calcPrecisionMultiplier = (main, firstRow) => {
-    const {precision} = main
+// ------------------------------
+// calcPrecisionMultiplier (unchanged semantics)
+// ------------------------------
+export const calcPrecisionMultiplier = main => {
+  const { precision, firstRow, initialPriceBased } = main;
+  if (precision === false) return 1
 
-    if(precision === false) return 1
+  const multipliers = []
 
-    let output = 1
+  const err = 'If "precision" is set to true all the "open", "high", "low" and "close" values must be numeric strings like "123.45" with no commas or currency symbols.'
 
-    for(const [key, value] of Object.entries(firstRow))
-    {
-        if(new Set(['open', 'high', 'low', 'close']).has(key) === false) continue
-        const [, decimals = ''] = String(value).split('.')
-        const decimalPrecision = Math.max(4, decimals.length)
-        const multiplier = decimalPrecision > 1 ? Math.pow(10, decimalPrecision - 1) : 1
+  for (const [key, strNum] of Object.entries(firstRow)) {
 
-        if(multiplier > output)
-        {
-            output = multiplier
-        }
+    if(!initialPriceBased.has(key)) continue
+    
+    if (typeof strNum !== 'string' || !/^-?\d+(\.\d+)?$/.test(strNum)) {
+      throw new Error(`${err} 
+        Property "${key}" had the value "${strNum}" type ${typeof strNum}.`)
     }
 
-    return output
+    if (!new Set(['open', 'high', 'low', 'close']).has(key)) continue;
 
-}
+    const [, decimals = ''] = strNum.split('.')
+    const decimalPrecision = Math.max(4, decimals.length)
+    multipliers.push(Math.pow(10, decimalPrecision)) // returns Number
+  }
+
+  if (multipliers.length === 0) return 1
+  return Math.max(...multipliers)
+}
+
+// ------------------------------
+// Precise BigInt-based helpers (no `n` literals)
+// ------------------------------
+export const addPrecisionExact = (strNum, mul) => {
+  if (typeof strNum !== 'string') throw new Error('addPrecisionExact expects a string when precision=true')
+
+  const negative = strNum.charAt(0) === '-'
+  const s = negative ? strNum.slice(1) : strNum
+  const [intPart, decPart = ''] = s.split('.')
+
+  // Compute decimals from mul (mul expected as 10^decimals)
+  const mulStr = String(mul);
+  const decimals = (mul === 1) ? 0 : (mulStr.length - 1)
+
+  const decPadded = decPart.padEnd(decimals, '0').slice(0, decimals); // pad or trim
+  const integerString = intPart + decPadded // e.g. "12" + "3400" => "123400"
+
+  // Use BigInt constructor (no n-literals)
+  let result = BigInt(integerString || '0'); // handle "0" or empty
+  if (negative) result = -result
+  return result
+}
+
+export const revertPrecisionExact = (num, mul) => {
+
+
+  // Convert input to BigInt without using literal suffixes
+  const big = (typeof num === 'bigint') ? num : BigInt(parseInt(num))
+  const neg = big < BigInt(0)
+  const abs = neg ? -big : big
+
+  const mulBig = BigInt(mul);
+  if (mulBig === BigInt(1)) {
+    const s = abs.toString()
+    return neg ? `-${s}` : s
+  }
+
+  const intPart = abs / mulBig
+  const fracPart = abs % mulBig
+
+  const decimals = String(mul).length - 1
+  const fracStr = fracPart.toString().padStart(decimals, '0')
+
+  // Remove trailing zeros in fractional part (optional)
+  const trimmedFrac = fracStr.replace(/0+$/, '')
+  const result = trimmedFrac.length === 0
+    ? intPart.toString()
+    : `${intPart.toString()}.${trimmedFrac}`
+
+  return neg ? `-${result}` : result
+}
+
+// ------------------------------
+// Convenience wrappers (Numbers) — may lose precision
+// ------------------------------
+export const addPrecisionAsNumber = (strNum, mul) => {
+
+  const big = addPrecisionExact(strNum, mul)
+  
+  return Number(big)
+}
+
+export const revertPrecisionAsNumber = (num, mul) => {
+
+  const asStr = revertPrecisionExact(num, mul)
+  return Number(asStr)
+}

package/src/utilities/validators.js

@@ -16,7 +16,7 @@ export const validateInputParams = (inputParams, len) => {
 }
 
 export const isAlreadyComputed = main => {
-    if(main.isComputed === true) throw Error('ohlcv is already computed, you can not add new indicators after "compute", "getLastValues" , "getDataAsCols" or "getData" methods are called.')
+    if(main.isComputed === true) throw Error('ohlcv is already computed, you can not add new indicators after "compute", "getLastValues" or "getData" methods are called.')
 }
 
 export const validateArray = (arr, paramName, callerName) => {

package/src/utilities/verticalToHorizontal.js

@@ -1,8 +1,11 @@
 import { dateOutputFormaters } from "./dateUtilities.js" 
+import { outputNumberFormatter } from "./numberUtilities.js"
 
 export const verticalToHorizontal = ({main, skipNull = false, startIndex = 0, dateFormat}) => {
 
-  const {verticalOhlcv, invalidValueIndex, len, verticalOhlcvKeyNames, verticalOhlcvTempCols} = main
+  const {verticalOhlcv, invalidValueIndex, len, verticalOhlcvKeyNames, verticalOhlcvTempCols, priceBased, precision, precisionMultiplier} = main
+
+  
 
   if (verticalOhlcvKeyNames.length === 0) return []
   
@@ -10,8 +13,18 @@ export const verticalToHorizontal = ({main, skipNull = false, startIndex = 0, da
   const maxStartIndex = Math.max(skipNullIndex, startIndex)
   const diffLen = len - maxStartIndex
   const result = Array.from({ length: diffLen }, () => ({}))
+  const formatter = {}
+  
+  for(const key of verticalOhlcvKeyNames) {
+      if(precision && priceBased.has(key)) {
+          formatter[key] = (num, mul) => outputNumberFormatter.precisionNumberCleanString(num, mul)
+      }
+      else {
+          formatter[key] = v => v
+      }
+  }
 
-   for(const [key, arr] of Object.entries(verticalOhlcv)){
+  for(const [key, arr] of Object.entries(verticalOhlcv)){
     if(verticalOhlcvTempCols.has(key)) continue
 
     for (let i = maxStartIndex; i < len; i++)
@@ -22,7 +35,7 @@ export const verticalToHorizontal = ({main, skipNull = false, startIndex = 0, da
       } 
       else
       {
-        result[i - maxStartIndex][key] = arr[i]
+        result[i - maxStartIndex][key] = formatter[key](arr[i], precisionMultiplier)
       }
     }
   }

package/src/studies/correlation.js

@@ -1,98 +0,0 @@
-import { FasterSMA } from "trading-signals";
-
-// Normalize the array (z-score normalization)
-const smoothNormalize = (arr, smoothing) => {
-    const len = arr.length;
-    const instance = new FasterSMA(smoothing);
-    const smoothedArr = new Array(len);
-    let sum = 0;
-    let sumSq = 0;
-    let count = 0;
-
-    for (let x = 0; x < len; x++) {
-        instance.update(arr[x]);
-
-        if (instance.isStable) {
-            const value = instance.getResult();
-            smoothedArr[x] = value;
-            sum += value;
-            sumSq += value * value;
-            count++;
-        } else {
-            smoothedArr[x] = null;
-        }
-    }
-
-    const meanValue = sum / count;
-    const variance = (sumSq / count) - (meanValue * meanValue);
-    const stdDev = Math.sqrt(variance);
-
-    return smoothedArr.map(val => (val !== null ? (val - meanValue) / stdDev : null));
-}
-
-// Calculate Pearson Correlation
-export const correlation = (x, y, smoothing = 5) => {
-    if (x.length !== y.length) {
-        throw new Error('Both arrays must have the same length');
-    }
-
-    const normX = smoothNormalize(x, smoothing);
-    const normY = smoothNormalize(y, smoothing);
-    const n = x.length;
-    const result = [];
-
-    let sumX = 0, sumY = 0, sumXY = 0;
-    let sumXSquare = 0, sumYSquare = 0;
-    let count = 0;
-
-    // Find the first index where both normX and normY have valid values
-    let firstValidIndex = -1;
-    for (let i = 0; i < n; i++) {
-        if (normX[i] !== null && normY[i] !== null) {
-            firstValidIndex = i;
-            break;
-        } else {
-            result.push(0); // Fill initial invalid indices with 0
-        }
-    }
-
-    if (firstValidIndex === -1) {
-        // No valid data points
-        return new Array(n).fill(0);
-    }
-
-    for (let i = firstValidIndex; i < n; i++) {
-        const xVal = normX[i];
-        const yVal = normY[i];
-
-        if (xVal === null || yVal === null) {
-            // Reset sums and counts when encountering null values
-            sumX = sumY = sumXY = sumXSquare = sumYSquare = count = 0;
-            result.push(0);
-            continue;
-        }
-
-        sumX += xVal;
-        sumY += yVal;
-        sumXY += xVal * yVal;
-        sumXSquare += xVal * xVal;
-        sumYSquare += yVal * yVal;
-        count++;
-
-        if (count < 2) {
-            result.push(0); // Not enough data points to calculate correlation
-            continue;
-        }
-
-        const numerator = (count * sumXY) - (sumX * sumY);
-        const denominator = Math.sqrt(
-            (count * sumXSquare - sumX * sumX) *
-            (count * sumYSquare - sumY * sumY)
-        );
-
-        const correlation = denominator === 0 ? 0 : numerator / denominator;
-        result.push(correlation);
-    }
-
-    return result;
-}