ohlcv-indicators 3.5.78 → 3.5.80

package/src/utilities/numberUtilities.js

@@ -1,15 +1,17 @@
 import { addPrecisionAsNumber, revertPrecisionAsNumber } from "./precisionMultiplier.js";
 
+export const isPositiveInteger = n => Number.isInteger(n) && n >= 0;
+
 export const inputNumberFormatter = {
   number: n => n,
   numberCleanString: n => Number(n),
-  precisionNumberCleanString: (strNum, multiplier) => addPrecisionAsNumber(strNum, multiplier)
+  precisionNumberCleanString: (strNum, multiplier, cachedDecimals) => addPrecisionAsNumber(strNum, multiplier, cachedDecimals)
 }
 
 export const outputNumberFormatter = {
   number: n => n,
   numberCleanString: n => n,
-  precisionNumberCleanString: (strNum, multiplier) => revertPrecisionAsNumber(strNum, multiplier)
+  precisionNumberCleanString: (strNum, multiplier, cachedDecimals) => revertPrecisionAsNumber(strNum, multiplier, cachedDecimals)
 }
 
 export const classifyNum = (num, throwError = false, precision = false) => {
@@ -32,4 +34,4 @@ export const classifyNum = (num, throwError = false, precision = false) => {
 
   if(throwError) throw new TypeError('Invalid input: expected a number or numeric string')
   return typeof num
-}
+}

package/src/utilities/precisionMultiplier.js

@@ -51,8 +51,14 @@ export const calcPrecisionMultiplier = main => {
 }
 
 
+// Keep the existing decimal-width rule, including scientific-notation multipliers.
+export const getPrecisionDecimals = multiplier => {
+  const mulStr = String(multiplier)
+  return multiplier === 1 ? 0 : mulStr.length - 1
+}
+
 //this function converts the strNum into a integer * multiplier
-export const addPrecisionAsNumber = (strNum, multiplier) => {
+export const addPrecisionAsNumber = (strNum, multiplier, cachedDecimals) => {
   if (typeof strNum !== 'string') throw new Error('addPrecisionExact expects a string when precision=true')
 
   const negative = strNum.charAt(0) === '-'
@@ -60,8 +66,7 @@ export const addPrecisionAsNumber = (strNum, multiplier) => {
   const [intPart, decPart = ''] = s.split('.')
 
   // Compute decimals from multiplier (multiplier expected as 10^decimals)
-  const mulStr = String(multiplier);
-  const decimals = (multiplier === 1) ? 0 : (mulStr.length - 1)
+  const decimals = cachedDecimals === undefined ? getPrecisionDecimals(multiplier) : cachedDecimals
 
   const decPadded = decPart.padEnd(decimals, '0').slice(0, decimals); // pad or trim
   const integerString = intPart + decPadded // e.g. "12" + "3400" => "123400"
@@ -75,7 +80,7 @@ export const addPrecisionAsNumber = (strNum, multiplier) => {
 
 
 //this function converts the outputs the number generated in addPrecisionAsNumber / multiplier
-export const revertPrecisionAsNumber = (num, multiplier) => {
+export const revertPrecisionAsNumber = (num, multiplier, cachedDecimals) => {
   if (typeof num !== 'number' || !Number.isFinite(num)) {
     throw new Error('revertPrecisionAsNumber expects a finite number')
   }
@@ -86,7 +91,7 @@ export const revertPrecisionAsNumber = (num, multiplier) => {
   // Make sure we're working with an integer, mirroring addPrecisionAsNumber
   abs = Math.trunc(abs)
 
-  const decimals = (multiplier === 1) ? 0 : (String(multiplier).length - 1)
+  const decimals = cachedDecimals === undefined ? getPrecisionDecimals(multiplier) : cachedDecimals
 
   if (decimals === 0) {
     // No fractional part; just restore sign
@@ -106,4 +111,4 @@ export const revertPrecisionAsNumber = (num, multiplier) => {
     : `${intPart}.${fracStr}`
 
   return Number(negative ? `-${resultStr}` : resultStr)
-}
+}

package/src/utilities/validators.js

@@ -5,7 +5,14 @@ export const validateInputParams = (inputParams, len) => {
         throw new Error('Property "inputParams" must be an "Array" or "Set".')
     }
 
-    for (const { params } of inputParams) {
+    for (const job of inputParams) {
+        if (!job || typeof job.key !== 'string' || !Array.isArray(job.params)) {
+            throw new TypeError('Each inputParams entry must have an indicator key and a params array.')
+        }
+        if (job.order !== undefined && !Number.isFinite(job.order)) {
+            throw new TypeError('Indicator order must be a finite number when provided.')
+        }
+        const { params } = job
         for (const v of params) {
             if (typeof v === 'number' && v > len) {
                 console.log(v, len);
@@ -16,6 +23,7 @@ export const validateInputParams = (inputParams, len) => {
 }
 
 export const isAlreadyComputed = main => {
+    if(main.isComputing === true) throw Error('You cannot add indicators while computation is in progress.')
     if(main.isComputed === true) throw Error('ohlcv is already computed, you can not add new indicators after "compute", "getLastValues" or "getData" methods are called.')
 }
 
@@ -117,3 +125,34 @@ export const validateString = (txt, paramName, callerName) => {
 
   return true
 }
+
+
+export const validateInputValues = (
+  requiredParams,
+  verticalOhlcv,
+  index,
+  callbackName
+) => {
+  if (index !== 0) return true;
+
+  const invalidParams = [];
+
+  for (const key of Object.keys(requiredParams)) {
+    const value = verticalOhlcv[key]?.[index];
+
+    const isValid = key === "volume"
+      ? Number.isInteger(value) && value >= 0
+      : Number.isFinite(value) && value > 0;
+
+    if (!isValid) invalidParams.push(key);
+  }
+
+  if (invalidParams.length > 0) {
+    throw new TypeError(
+      `Invalid or missing input value(s) [${invalidParams.join(", ")}] ` +
+      `at index ${index} in "${callbackName}".`
+    );
+  }
+
+  return true;
+};

package/src/utilities/verticalToHorizontal.js

@@ -1,5 +1,6 @@
 import { dateOutputFormaters } from "./dateUtilities.js" 
 import { outputNumberFormatter } from "./numberUtilities.js"
+import { getPrecisionDecimals } from "./precisionMultiplier.js"
 
 export const verticalToHorizontal = ({main, skipNull = false, startIndex = 0, dateFormat}) => {
 
@@ -8,34 +9,43 @@ export const verticalToHorizontal = ({main, skipNull = false, startIndex = 0, da
   
 
   if (verticalOhlcvKeyNames.length === 0) return []
+
+  const precisionDecimals = precision && typeof precisionMultiplier === 'number'
+    ? getPrecisionDecimals(precisionMultiplier)
+    : undefined
   
   const skipNullIndex = skipNull && invalidValueIndex >= 0 ? invalidValueIndex + 1 : 0
   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)){
     if(verticalOhlcvTempCols.has(key)) continue
 
-    for (let i = maxStartIndex; i < len; i++)
+    if(key === 'date')
+    {
+      const formatter = dateOutputFormaters[dateFormat]
+      for (let i = maxStartIndex; i < len; i++)
+      {
+        result[i - maxStartIndex][key] = formatter(arr[i])
+      }
+    }
+    else if(precision && priceBased.has(key))
     {
-      if(key === 'date')
+      const formatter = outputNumberFormatter.precisionNumberCleanString
+      for (let i = maxStartIndex; i < len; i++)
       {
-        result[i - maxStartIndex][key] = dateOutputFormaters[dateFormat](arr[i])
-      } 
-      else
+        const value = arr[i]
+        result[i - maxStartIndex][key] = value == null || Number.isNaN(value)
+          ? value
+          : formatter(value, precisionMultiplier, precisionDecimals)
+      }
+    }
+    else
+    {
+      for (let i = maxStartIndex; i < len; i++)
       {
-        result[i - maxStartIndex][key] = formatter[key](arr[i], precisionMultiplier)
+        result[i - maxStartIndex][key] = arr[i]
       }
     }
   }

package/src/volatility/adx.js

@@ -1,5 +1,7 @@
-import { FasterADX } from 'trading-signals';
+import { FasterADX } from '../core-indicators/index.js';
 import { mathLog } from '../utilities/math.js';
+import { validateInputValues } from '../utilities/validators.js';
+import { initializeColumns } from '../core-functions/initializeColumns.js';
 
 export const adx = (main, index, size, { lag, retLogs }) => {
   const { verticalOhlcv, instances, useFullNames } = main;
@@ -10,7 +12,7 @@ export const adx = (main, index, size, { lag, retLogs }) => {
 
   // Initialization on the first index.
   if (index === 0) {
-    const { len } = main;
+    validateInputValues({ high: true, low: true, close: true }, verticalOhlcv, index, 'adx');
 
     if (!verticalOhlcv.hasOwnProperty('high')) {
       throw new Error('Property high not found in verticalOhlcv for adx.');
@@ -28,32 +30,17 @@ export const adx = (main, index, size, { lag, retLogs }) => {
       [instanceKey]: new FasterADX(size)
     });
 
-    Object.assign(verticalOhlcv, {
-      [adxKey]: new Float64Array(len).fill(NaN)
-    })
-
-
-    if (lag > 0) {
-      main.lag([adxKey], lag);
-    }
+    initializeColumns(main, [{ key: adxKey }], { lag });
   }
 
   const high = verticalOhlcv.high[index];
   const low = verticalOhlcv.low[index];
   const close = verticalOhlcv.close[index];
 
-  let currentAdx = NaN;
-
   // Update the ADX indicator.
   instances[instanceKey].update({ high, low, close });
 
-  try {
-    currentAdx = instances[instanceKey].getResult();
-
-    instances[instanceKey].get
-  } catch (err) {
-    currentAdx = NaN;
-  }
+  const currentAdx = instances[instanceKey].isStable ? instances[instanceKey].getResult() : NaN;
 
 
   const adxVal = Number.isNaN(currentAdx)
@@ -62,4 +49,4 @@ export const adx = (main, index, size, { lag, retLogs }) => {
 
 
   main.pushToMain({ index, key: adxKey, value: adxVal });
-};
+};

package/src/volatility/atr.js

@@ -1,29 +1,22 @@
 
-import {FasterATR, FasterWSMA} from 'trading-signals';
+import {FasterATR, FasterWSMA} from '../core-indicators/index.js';
 import { mathLog } from '../utilities/math.js';
+import { validateInputValues } from '../utilities/validators.js';
+import { initializeColumns } from '../core-functions/initializeColumns.js';
 
 export const atr = (main, index, size, {lag, retLogs}) => {
-  const { verticalOhlcv, instances, priceBased } = main
+  const { verticalOhlcv, instances } = main
   const baseKeyName = retLogs ? `ret_log_atr_${size}` : `atr_${size}`
 
   if (index === 0) {
 
-    const {instances, verticalOhlcv, len} = main
+    const {instances, verticalOhlcv} = main
 
-    instances[baseKeyName] = new FasterATR(size, FasterWSMA)
-
-    const keyNames = [baseKeyName]
+    validateInputValues({ high: true, low: true, close: true }, verticalOhlcv, index, 'atr')
 
-    for(const k of keyNames)
-    { 
-      verticalOhlcv[k] = new Float64Array(len).fill(NaN)
-      priceBased.add(k)
-    }
+    instances[baseKeyName] = new FasterATR(size, FasterWSMA)
 
-    if(lag > 0)
-    {
-      main.lag(keyNames, lag)
-    }
+    initializeColumns(main, [{ key: baseKeyName, priceBased: !retLogs }], { lag })
   }
 
   // Retrieve the current price value.
@@ -36,15 +29,9 @@ export const atr = (main, index, size, {lag, retLogs}) => {
 
   // Update the moving average instance.
   instance.update(curr);
-  let currAtr = NaN;
-  try {
-    currAtr = instance.getResult();
-  } catch (err) {
-
-  }
+  const currAtr = instance.isStable ? instance.getResult() : NaN;
 
   // Always push the MA value (even if NaN).
   main.pushToMain({ index, key: baseKeyName, value: Number.isNaN(currAtr) ? NaN : (retLogs ? mathLog(currAtr, curr.close) : currAtr) });
 
-  return true;
-}
+}