ohlcv-indicators 3.5.54 → 3.5.55

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.55",
   "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/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,8 +1,9 @@
-// ------------------------------
-// calcPrecisionMultiplier (unchanged semantics)
-// ------------------------------
+
+//calcPrecisionMultiplier is calculated once, using the open, high, low and close values of the first row
+//the multiplier (min 10000 and max 1000000000) is store in constructor
+
 export const calcPrecisionMultiplier = main => {
-  const { precision, firstRow, initialPriceBased } = main;
+  const { precision, firstRow, initialPriceBased, priceBased } = main;
   if (precision === false) return 1
 
   const multipliers = []
@@ -18,81 +19,74 @@ export const calcPrecisionMultiplier = main => {
         Property "${key}" had the value "${strNum}" type ${typeof strNum}.`)
     }
 
-    if (!new Set(['open', 'high', 'low', 'close']).has(key)) continue;
+    if (!priceBased.has(key)) continue
 
-    const [, decimals = ''] = strNum.split('.')
-    const decimalPrecision = Math.max(4, decimals.length)
-    multipliers.push(Math.pow(10, decimalPrecision)) // returns Number
+    const [integerStr, decimals = ''] = strNum.split('.')
+    const integer = Number(integerStr)
+    const decimalPrecision = integer > 0 ? 4 : Math.max(4, decimals.length)
+    multipliers.push(Math.pow(10, decimalPrecision))
   }
 
   if (multipliers.length === 0) return 1
-  return Math.max(...multipliers)
+
+  const maxMultiplier = 10 ** 9 //1000000000
+
+  return Math.min(maxMultiplier, Math.max(...multipliers))
 }
 
-// ------------------------------
-// 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)