ohlcv-indicators 3.5.54 → 3.5.56

package/index.js

@@ -924,13 +924,19 @@ export default class OHLCV_INDICATORS {
 
         validateObject(options, 'options', methodName)
 
-        const {lag = 0} = options
+        const {lag = 0, isPriceBased = false} = options
 
         validateArray(newCols, 'newCols', methodName)
         validateNumber(lag, {min: 0, allowDecimals: false}, 'options.lag', methodName)
+        validateBoolean(isPriceBased, 'isPriceBased', 'mapCols')
+
+        if(this.precision === false && isPriceBased) {
+            throw new Error(`Invalid param: If "mapCols.options.isPriceBased" is true, the "constructor.precision" param must be also true.`)
+        }
+
         const order = getOrderFromArray(newCols, methodName)
 
-        this.inputParams.push({key: methodName, order, params: [newCols, callback, {lag}]})
+        this.inputParams.push({key: methodName, order, params: [newCols, callback, {lag, isPriceBased}]})
 
         return this
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ohlcv-indicators",
-  "version": "3.5.54",
+  "version": "3.5.56",
   "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/machine-learning/classifier.js

@@ -291,7 +291,7 @@ export const classifier = (
       {
         uniqueLabels[loopIdx] = countUniqueLabels(yRows)
         
-        if(uniqueLabels[loopIdx] < 2)
+        if(uniqueLabels[loopIdx] < 1)
         {
           throw new Error(`Invalid number or labels in ${prefix}. Check the logic of your "yCallback" function.`)
         }

package/src/moving-averages/movingAverages.js

@@ -8,8 +8,6 @@ const indicatorClasses = {
 
 export const movingAverages = (main, index, methodName, size, { target, lag }) => {
 
-  
-
   const { verticalOhlcv, instances, priceBased } = main
   const suffix = (target !== 'close') ?  `_${target}` : ''
   const keyName = `${methodName}_${size}${suffix}`

package/src/moving-averages/relativeVolume.js

@@ -2,8 +2,6 @@ import { FasterSMA } from 'trading-signals';
 
 export const relativeVolume = (main, index, size, {lag}) => {
 
-  
-
   const key = `relative_volume_${size}`;
   const { instances, verticalOhlcv } = main;
 

package/src/moving-averages/vidya.js

@@ -9,11 +9,11 @@ export const vidya = (main, index, size, momentum, options = {}) => {
   // Initialization on the first bar
   if (index === 0) {
     if (!(target in verticalOhlcv)) {
-      throw new Error(`VIDYA could not find target "${target}"`);
+      throw new Error(`VIDYA could not find target "${target}"`)
     }
 
-    const prefix = `vidya_${indicatorKey}`;
-    const keyBase = target === 'close' ? prefix : `${prefix}_${target}`;
+    const prefix = `vidya_${indicatorKey}`
+    const keyBase = target === 'close' ? prefix : `${prefix}_${target}`
     const keys = {
       vidya: keyBase,
       upper: `${prefix}_upper`, 
@@ -21,7 +21,7 @@ export const vidya = (main, index, size, momentum, options = {}) => {
       delta_vol: `${prefix}_delta_vol`,
       cross: `${prefix}_cross`,
       liquidity: `${prefix}_liquidity`,
-    };
+    }
 
     const priceBasedVidyaKeys = [keyBase, keys.upper, keys.lower, keys.liquidity]
 
@@ -63,13 +63,13 @@ export const vidya = (main, index, size, momentum, options = {}) => {
   };
 
   // Series inputs
-  const price = verticalOhlcv[target][index];
-  const high  = verticalOhlcv.high[index];
-  const low   = verticalOhlcv.low[index];
-  const close = verticalOhlcv.close[index];
-  const open  = verticalOhlcv.open[index];
-  const vol   = verticalOhlcv.volume[index];
-  const prevCross = index > 0 ? verticalOhlcv[keys.cross][index - 1] : 0;
+  const price = verticalOhlcv[target][index]
+  const high  = verticalOhlcv.high[index]
+  const low   = verticalOhlcv.low[index]
+  const close = verticalOhlcv.close[index]
+  const open  = verticalOhlcv.open[index]
+  const vol   = verticalOhlcv.volume[index]
+  const prevCross = index > 0 ? verticalOhlcv[keys.cross][index - 1] : 0
 
   const highestHigh = (inst.liquidity.high.length === liquidityLookback) ? Math.max(...inst.liquidity.high) : NaN
   const lowestLow = (inst.liquidity.low.length === liquidityLookback) ? Math.min(...inst.liquidity.low) : NaN
@@ -81,77 +81,77 @@ export const vidya = (main, index, size, momentum, options = {}) => {
       high - low,
       Math.abs(high - prevClose),
       Math.abs(low - prevClose)
-    );
-    inst.atrBuffer.push(tr);
-    if (inst.atrBuffer.length > atrLength) inst.atrBuffer.shift();
+    )
+    inst.atrBuffer.push(tr)
+    if (inst.atrBuffer.length > atrLength) inst.atrBuffer.shift()
   }
   const atr = inst.atrBuffer.length === atrLength
     ? inst.atrBuffer.reduce((a, b) => a + b, 0) / atrLength
-    : NaN;
+    : NaN
 
   // Compute raw VIDYA
-  let rawVidya = NaN;
-  let mom = NaN;
-  if (index > 0) mom = price - verticalOhlcv[target][index - 1];
-  inst.momentumBuffer.push(mom);
-  if (inst.momentumBuffer.length > momentum) inst.momentumBuffer.shift();
+  let rawVidya = NaN
+  let mom = NaN
+  if (index > 0) mom = price - verticalOhlcv[target][index - 1]
+  inst.momentumBuffer.push(mom)
+  if (inst.momentumBuffer.length > momentum) inst.momentumBuffer.shift()
   if (inst.momentumBuffer.length === momentum) {
-    let sumPos = 0, sumNeg = 0;
+    let sumPos = 0, sumNeg = 0
     inst.momentumBuffer.forEach(m => m >= 0 ? sumPos += m : sumNeg += -m);
-    const denom = sumPos + sumNeg;
+    const denom = sumPos + sumNeg
     const cmo = denom === 0 ? 0 : Math.abs((sumPos - sumNeg) / denom) * 100;
-    const alpha = 2 / (size + 1);
-    const a = alpha * (cmo / 100);
+    const alpha = 2 / (size + 1)
+    const a = alpha * (cmo / 100)
     rawVidya = isNaN(inst.prevVidya) ? price : (a * price + (1 - a) * inst.prevVidya);
-    inst.prevVidya = rawVidya;
+    inst.prevVidya = rawVidya
   }
 
   // Smooth VIDYA using fixed 15-bar SMA
-  inst.sma.update(rawVidya);
-  let smoothedVidya = NaN;
-  try { smoothedVidya = inst.sma.getResult(); } catch {}
+  inst.sma.update(rawVidya)
+  let smoothedVidya = NaN
+  try { smoothedVidya = inst.sma.getResult() } catch {}
 
   // Bands
   const upper = (!isNaN(atr) && !isNaN(smoothedVidya))
     ? smoothedVidya + atr * bandDistance
-    : NaN;
+    : NaN
   const lower = (!isNaN(atr) && !isNaN(smoothedVidya))
     ? smoothedVidya - atr * bandDistance
-    : NaN;
+    : NaN
 
   // Detect crosses
-  const prevPrice = index > 0 ? verticalOhlcv[target][index - 1] : NaN;
-  const prevUpper = index > 0 ? verticalOhlcv[keys.upper][index - 1] : NaN;
-  const prevLower = index > 0 ? verticalOhlcv[keys.lower][index - 1] : NaN;
-  const crossUp   = index > 0 && prevPrice <= prevUpper && price > upper;
-  const crossDown = index > 0 && prevPrice >= prevLower && price < lower;
+  const prevPrice = index > 0 ? verticalOhlcv[target][index - 1] : NaN
+  const prevUpper = index > 0 ? verticalOhlcv[keys.upper][index - 1] : NaN
+  const prevLower = index > 0 ? verticalOhlcv[keys.lower][index - 1] : NaN
+  const crossUp   = index > 0 && prevPrice <= prevUpper && price > upper
+  const crossDown = index > 0 && prevPrice >= prevLower && price < lower
 
   // Update trend state
-  if (crossUp) inst.isTrendUp = true;
-  if (crossDown) inst.isTrendUp = false;
+  if (crossUp) inst.isTrendUp = true
+  if (crossDown) inst.isTrendUp = false
 
   // Cumulative cross counter: positive when uptrend, negative when downtrend
   let cross = 0;
   if (index > 0) {
     if (inst.isTrendUp) {
-      cross = prevCross > 0 ? prevCross + 1 : 1;
+      cross = prevCross > 0 ? prevCross + 1 : 1
     } else {
-      cross = prevCross < 0 ? prevCross - 1 : -1;
+      cross = prevCross < 0 ? prevCross - 1 : -1
     }
   }
 
   // Volume accumulation
   if (crossUp || crossDown) {
-    inst.upVol = inst.downVol = 0;
+    inst.upVol = inst.downVol = 0
   } else {
-    inst.upVol   += (close > open ? vol : 0);
-    inst.downVol += (close < open ? vol : 0);
+    inst.upVol   += (close > open ? vol : 0)
+    inst.downVol += (close < open ? vol : 0)
   }
-  const avgVol = (inst.upVol + inst.downVol) / 2 || 1;
-  const deltaPct = (inst.upVol - inst.downVol) / avgVol;
+  const avgVol = (inst.upVol + inst.downVol) / 2 || 1
+  const deltaPct = (inst.upVol - inst.downVol) / avgVol
 
   // Trend-based boundary (reset on crossover)
-  const trendValue = (inst.isTrendUp) ? lower : upper;
+  const trendValue = (inst.isTrendUp) ? lower : upper
   let liquidity = NaN
 
   if(cross > 0)
@@ -164,12 +164,12 @@ export const vidya = (main, index, size, momentum, options = {}) => {
   }
 
   // Push outputs
-  main.pushToMain({ index, key: keys.vidya, value: trendValue });
-  main.pushToMain({ index, key: keys.upper, value: upper });
-  main.pushToMain({ index, key: keys.lower, value: lower });
-  main.pushToMain({ index, key: keys.delta_vol, value: deltaPct });
-  main.pushToMain({ index, key: keys.cross, value: cross });
-  main.pushToMain({ index, key: keys.liquidity, value: liquidity });
+  main.pushToMain({ index, key: keys.vidya, value: trendValue })
+  main.pushToMain({ index, key: keys.upper, value: upper })
+  main.pushToMain({ index, key: keys.lower, value: lower })
+  main.pushToMain({ index, key: keys.delta_vol, value: deltaPct })
+  main.pushToMain({ index, key: keys.cross, value: cross })
+  main.pushToMain({ index, key: keys.liquidity, value: liquidity })
 
   inst.liquidity.high.push(high)
   inst.liquidity.low.push(low)
@@ -177,5 +177,5 @@ export const vidya = (main, index, size, momentum, options = {}) => {
   if(inst.liquidity.high.length > liquidityLookback) inst.liquidity.high.shift()
   if(inst.liquidity.low.length > liquidityLookback) inst.liquidity.low.shift()
 
-  return true;
-};
+  return true
+}

package/src/studies/mapCols.js

@@ -1,12 +1,9 @@
-export const mapCols = (main, index, newCols, callback, {lag}) => {
+export const mapCols = (main, index, newCols, callback, {lag, isPriceBased}) => {
 
-    
-
-    const {verticalOhlcv, len} = main
+    const {verticalOhlcv, len, priceBased, precision} = main
 
     if(index === 0)
     {
-
         for(const key of newCols)
         {
             if(verticalOhlcv.hasOwnProperty(key)) {
@@ -14,6 +11,11 @@ export const mapCols = (main, index, newCols, callback, {lag}) => {
             }
 
             verticalOhlcv[key] = new Array(len).fill(0)
+
+            if(precision && isPriceBased)
+            {
+                priceBased.add(key)
+            }
         }
 
         if(lag > 0)
@@ -35,12 +37,10 @@ export const mapCols = (main, index, newCols, callback, {lag}) => {
 export const defaultMapColsCallback = ({main, index}) => {
     const {verticalOhlcv} = main
 
-    const currClose = verticalOhlcv.close[index]
-    const prevClose = verticalOhlcv.close[index-1]
+    const close = verticalOhlcv.close[index]
+    const open = verticalOhlcv.open[index-1]
     
-    if(typeof prevClose === 'undefined') return null
-
     return {
-        change: (currClose - prevClose) / prevClose
+        change: ((close - open) / open) * 100
     }
 } 

package/src/utilities/precisionMultiplier.js

@@ -1,98 +1,109 @@
-// ------------------------------
-// calcPrecisionMultiplier (unchanged semantics)
-// ------------------------------
+
+//calcPrecisionMultiplier is calculated once in the class constructor, using the open, high, low and close values of the first row
+//the multiplier (min 10000) is store in constructor
+
 export const calcPrecisionMultiplier = main => {
-  const { precision, firstRow, initialPriceBased } = main;
+  const { precision, firstRow, initialPriceBased } = main
   if (precision === false) return 1
 
-  const multipliers = []
-
-  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.'
+  let maxMultiplier = 1
 
   for (const [key, strNum] of Object.entries(firstRow)) {
+    if (!initialPriceBased.has(key)) continue
+
+    if (typeof strNum !== 'string' || !/^\d+(\.\d+)?$/.test(strNum))  {
+      throw new Error(
+        `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. Property "${key}" had the value "${strNum}" type ${typeof strNum}.`
+      )
+    }
+
+    const [integerStr, decimals = ''] = strNum.split('.')
+    const integer = Number(integerStr)
+
+    let decimalPrecision = 4
+
+    // Treat any non-zero integer (positive or negative) as "normal"
+    if (Math.abs(integer) === 0) {
+      const decimalsLen = decimals.length
+      const countDecimals = Math.max(4, decimalsLen)
+
+      // index of first non-zero decimal digit, -1 if none
+      const firstNonZeroIndex = decimals.search(/[1-9]/)
 
-    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}.`)
+      if (firstNonZeroIndex === -1) {
+        // 0, 0.0, 0.0000... -> nothing special to preserve
+        decimalPrecision = countDecimals
+      } else {
+        // Give extra headroom after the first non-zero digit
+        const extra = 5 // tweak as you like
+        const needed = firstNonZeroIndex + 1 + extra
+        decimalPrecision = Math.max(countDecimals, needed)
+      }
     }
 
-    if (!new Set(['open', 'high', 'low', 'close']).has(key)) continue;
+    // Optional: cap exponent to keep numbers sane
+    const multiplier = 10 ** decimalPrecision
 
-    const [, decimals = ''] = strNum.split('.')
-    const decimalPrecision = Math.max(4, decimals.length)
-    multipliers.push(Math.pow(10, decimalPrecision)) // returns Number
+    if (multiplier > maxMultiplier) maxMultiplier = multiplier
   }
 
-  if (multipliers.length === 0) return 1
-  return Math.max(...multipliers)
+  return maxMultiplier
 }
 
-// ------------------------------
-// Precise BigInt-based helpers (no `n` literals)
-// ------------------------------
-export const addPrecisionExact = (strNum, mul) => {
+
+//this function converts the strNum into a integer * multiplier
+export const addPrecisionAsNumber = (strNum, multiplier) => {
   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)
+  // Compute decimals from multiplier (multiplier expected as 10^decimals)
+  const mulStr = String(multiplier);
+  const decimals = (multiplier === 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
+  let result = parseInt(integerString || '0', 10)
+
   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
+//this function converts the outputs the number generated in addPrecisionAsNumber / multiplier
+export const revertPrecisionAsNumber = (num, multiplier) => {
+  if (typeof num !== 'number' || !Number.isFinite(num)) {
+    throw new Error('revertPrecisionAsNumber expects a finite number')
   }
 
-  const intPart = abs / mulBig
-  const fracPart = abs % mulBig
+  const negative = num < 0
+  let abs = Math.abs(num)
 
-  const decimals = String(mul).length - 1
-  const fracStr = fracPart.toString().padStart(decimals, '0')
+  // Make sure we're working with an integer, mirroring addPrecisionAsNumber
+  abs = Math.trunc(abs)
 
-  // Remove trailing zeros in fractional part (optional)
-  const trimmedFrac = fracStr.replace(/0+$/, '')
-  const result = trimmedFrac.length === 0
-    ? intPart.toString()
-    : `${intPart.toString()}.${trimmedFrac}`
+  const decimals = (multiplier === 1) ? 0 : (String(multiplier).length - 1)
 
-  return neg ? `-${result}` : result
-}
+  if (decimals === 0) {
+    // No fractional part; just restore sign
+    return negative ? -abs : abs
+  }
 
-// ------------------------------
-// Convenience wrappers (Numbers) — may lose precision
-// ------------------------------
-export const addPrecisionAsNumber = (strNum, mul) => {
+  // Integer division and remainder
+  const intPart = Math.trunc(abs / multiplier)
+  const fracPart = abs % multiplier
 
-  const big = addPrecisionExact(strNum, mul)
-  
-  return Number(big)
-}
+  // Build fractional string with leading zeros, then trim trailing zeros
+  let fracStr = String(fracPart).padStart(decimals, '0')
+  fracStr = fracStr.replace(/0+$/, '')
 
-export const revertPrecisionAsNumber = (num, mul) => {
+  const resultStr = fracStr.length === 0
+    ? String(intPart)
+    : `${intPart}.${fracStr}`
 
-  const asStr = revertPrecisionExact(num, mul)
-  return Number(asStr)
-}
+  return Number(negative ? `-${resultStr}` : resultStr)
+}

package/src/volatility/atr.js

@@ -2,7 +2,7 @@
 import {FasterATR, FasterWSMA} from 'trading-signals';
 
 export const atr = (main, index, size, {lag, percentage, upper, lower}) => {
-  const { verticalOhlcv, instances } = main
+  const { verticalOhlcv, instances, priceBased } = main
   const baseKeyName = `atr_${size}`
 
   if (index === 0) {
@@ -20,6 +20,7 @@ export const atr = (main, index, size, {lag, percentage, upper, lower}) => {
     for(const k of keyNames)
     { 
       verticalOhlcv[k] = new Float64Array(len).fill(NaN)
+      priceBased.add(k)
     }
 
     if(lag > 0)