ohlcv-indicators 3.5.52 → 3.5.54

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;
-}