ohlcv-indicators 3.3.2 → 3.3.5

package/src/core-functions/mainLoop.js

@@ -0,0 +1,85 @@
+import { validateInputParams } from "../utilities/validators.js";
+import { rsi } from "../oscillators/rsi.js";
+import { movingAverages } from "../moving-averages/movingAverages.js";
+import { macd } from "../moving-averages/macd.js";
+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 { lag } from "../studies/lag.js";
+import { crossPairs } from "../studies/findCrosses.js";
+import { dateTime } from "../studies/dateTime.js";
+import { Scaler } from "../studies/scaler.js";
+
+import { buildArray } from "../utilities/assignTypes.js";
+import {  numberFormater } from "../utilities/numberUtilities.js";
+import { dateFormaters } from "../utilities/dateUtilities.js";
+
+// Map indicator keys to their respective functions
+const indicatorFunctions = {
+  dateTime,
+  rsi,
+  ema: movingAverages,
+  sma: movingAverages,
+  macd,
+  relativeVolume,
+  donchianChannels,
+  bollingerBands,
+  volumeOscillator,
+  Scaler
+};
+
+
+export const mainLoop = (input, main) => {
+  const { len, inputParams, priceBased, precisionMultiplier, arrayTypes, verticalOhlcv, verticalOhlcvKeyNames, inputTypes } = main;
+
+  validateInputParams({inputParams, len})
+
+  for(const key of Object.keys(inputTypes))
+  {
+    verticalOhlcv[key] = buildArray(arrayTypes[key], len)
+  }
+
+  // Process each row in the input
+  for (let index = 0; index < len; index++) {
+    const curr = input[index]
+    
+    for(const [key, formaterKey] of Object.entries(inputTypes))
+    {
+      const value = curr[key]
+
+      if(numberFormater.hasOwnProperty(formaterKey))
+      {
+        let formatedValue = numberFormater[formaterKey](value)
+
+        if(precisionMultiplier > 1 && priceBased.has(key))
+        {
+          formatedValue = formatedValue * precisionMultiplier
+        }
+
+        main.pushToMain({index, key, value: formatedValue})
+      }
+      else if(dateFormaters.hasOwnProperty(formaterKey))
+      {
+        main.pushToMain({index, key, value: dateFormaters[formaterKey](value)})
+      }
+      else
+      {
+        main.pushToMain({index, key, value})
+      }
+    }
+  
+      // Run all indicator functions except for the ones processed later
+      for (const { key, params } of inputParams) {
+        if (key === 'lag' || key === 'crossPairs') continue;
+        // resolve fn on-demand, no per-item object allocation here
+        indicatorFunctions[key](main, index, ...params)
+      }
+  
+      // Process these indicators separately (ensuring their execution order)
+      lag(main, index)
+      crossPairs(main, index)
+  }
+
+  verticalOhlcvKeyNames.push(...Object.keys(verticalOhlcv))
+}

package/src/core-functions/pushToMain.js

@@ -0,0 +1,15 @@
+export const pushToMain = ({main, index, key, value}) => {
+
+    const {verticalOhlcv} = main
+
+    if(value === null || typeof value === 'undefined' || Number.isNaN(value))
+    {
+        main.invalidValueIndex = index
+        verticalOhlcv[key][index] = value
+        return false
+    }
+
+    verticalOhlcv[key][index] = value    
+
+    return true
+}

package/src/moving-averages/bollingerBands.js

@@ -1,10 +1,9 @@
 import { FasterBollingerBands } from 'trading-signals'
-import { calcMagnitude } from '../utilities/numberUtilities.js';
 
 const defaultTarget = 'close'
 
-export const bollingerBands = (main, index, size, stdDev, { height, range = [], target, scale, lag, autoMinMax }) => {
-  const { verticalOhlcv, instances, lastIndexReplace } = main;
+export const bollingerBands = (main, index, size, stdDev, { height, range = [], target, lag }) => {
+  const { verticalOhlcv, instances } = main;
   const suffix = target === defaultTarget ? '' : `_${target}`;
   const indicatorKey = `${size}_${stdDev}${suffix}`;
   let prefix;
@@ -12,7 +11,7 @@ export const bollingerBands = (main, index, size, stdDev, { height, range = [],
   // Initialization on the first call.
   if (index === 0) {
 
-    const { priceBased, inputParams, nullArray, verticalOhlcv } = main;
+    const { priceBased, inputParams, verticalOhlcv, len, arrayTypes } = main;
 
     if (!(target in verticalOhlcv)) {
       throw new Error(`bollingerBands could not find target "${target}"`);
@@ -46,19 +45,14 @@ export const bollingerBands = (main, index, size, stdDev, { height, range = [],
 
     // Set up additional arrays for each range property.
     for (const rangeKey of range) {
-      if (!(rangeKey in verticalOhlcv) || !priceBased.includes(rangeKey)) {
+      if (!(rangeKey in verticalOhlcv) || !priceBased.has(rangeKey)) {
         throw new Error(`Invalid range item value "${rangeKey}" property for bollingerBands. Only price based key names are accepted:\n${JSON.stringify(priceBased)}`);
       }
       keyNames.push(`${prefix}_range_${rangeKey}`)
 
-      if(autoMinMax)
-      {
-        main.autoMinMaxKeys.push(`${prefix}_range_${rangeKey}`)
-      }
-
     }
 
-    const verticalOhlcvSetup = Object.fromEntries(keyNames.map(v => [v, [...nullArray]]))
+    const verticalOhlcvSetup = Object.fromEntries(keyNames.map(v => [v, new Float64Array(len).fill(NaN)]))
     Object.assign(verticalOhlcv, {...verticalOhlcvSetup})
 
     if(lag > 0)
@@ -66,7 +60,14 @@ export const bollingerBands = (main, index, size, stdDev, { height, range = [],
       main.lag(keyNames, lag)
     }
 
-    priceBased.push(`${prefix}_upper`, `${prefix}_middle`, `${prefix}_lower`);
+    [`${prefix}_upper`, `${prefix}_middle`, `${prefix}_lower`].forEach(v => {
+      priceBased.add(v)
+    })
+
+    for(const key of keyNames)
+    {
+      arrayTypes[key] = 'Float64Array'
+    }
   }
 
   // Derive prefix for subsequent calls if not set.
@@ -79,20 +80,20 @@ export const bollingerBands = (main, index, size, stdDev, { height, range = [],
   // Update the indicator with the current value.
   const instance = instances.bollinger_bands.settings[indicatorKey];
   const value = verticalOhlcv[target][index];
-  instance.update(value, lastIndexReplace);
+  instance.update(value);
 
   // Attempt to retrieve the result.
-  let result = null;
+  let result = {};
   try {
     result = instance.getResult();
   } catch (err) {
-    // If not available, result stays null.
+    // If not available, result stays {}.
   }
 
-  // Use null fallbacks for the primary values.
-  const upper = result?.upper ?? null;
-  const middle = result?.middle ?? null;
-  const lower = result?.lower ?? null;
+  // Use NaN fallbacks for the primary values.
+  const upper = result?.upper ?? NaN;
+  const middle = result?.middle ?? NaN;
+  const lower = result?.lower ?? NaN;
 
   // Always push the indicator outputs.
   main.pushToMain({ index, key: `${subPrefix}_upper`, value: upper });
@@ -101,26 +102,19 @@ export const bollingerBands = (main, index, size, stdDev, { height, range = [],
 
   // Process height if requested.
   if (height) {
-    let heightValue = null;
-    if (typeof upper === 'number' && typeof lower === 'number' && lower !== 0) {
-      heightValue = calcMagnitude( ((upper - lower) / lower), 0.001)
+    let heightValue = NaN;
+    if (!Number.isNaN(lower) && !Number.isNaN(upper)) {
+      heightValue = ((upper - lower) / lower)
     }
     main.pushToMain({ index, key: `${subPrefix}_height`, value: heightValue });
   }
 
   // Process each range property.
   for (const rangeKey of range) {
-    let rangeValue = null;
+    let rangeValue = NaN;
     const priceValue = verticalOhlcv[rangeKey][index];
-    if (typeof priceValue === 'number' && typeof lower === 'number' && typeof upper === 'number' && (upper - lower) !== 0) {
-      rangeValue = (autoMinMax) 
-        ? Math.max(Math.min((priceValue - lower) / (upper - lower), 1), 0)
-        : (priceValue - lower) / (upper - lower)
-
-
-      if (scale) {
-        rangeValue = calcMagnitude(rangeValue, scale);
-      }
+    if (!Number.isNaN(priceValue) && !Number.isNaN(lower) && !Number.isNaN(upper)) {
+      rangeValue = (priceValue - lower) / (upper - lower)
     }
     main.pushToMain({ index, key: `${subPrefix}_range_${rangeKey}`, value: rangeValue });
   }

package/src/moving-averages/donchianChannel.js

@@ -1,12 +1,11 @@
-import { calcMagnitude } from "../utilities/numberUtilities.js"
 
-export const donchianChannels = (main, index, size, offset, { height, range, scale, lag, autoMinMax }) => {
+export const donchianChannels = (main, index, size, offset, { height, range, lag }) => {
   const indicatorKey = `${size}_${offset}`;
   const { verticalOhlcv, instances, len } = main;
 
   // Initialization: create output arrays and indicator instance on the first call.
   if (index === 0) {
-    const { inputParams, priceBased, nullArray } = main;
+    const { inputParams, priceBased, arrayTypes} = main;
     const numberOfIndicators = inputParams.filter(o => o.key === 'donchianChannels').length;
     const prefix = numberOfIndicators > 1 ? `donchian_channel_${indicatorKey}` : 'donchian_channel';
 
@@ -28,19 +27,14 @@ export const donchianChannels = (main, index, size, offset, { height, range, sca
 
     // Set up additional arrays for each range property.
     for (const rangeKey of range) {
-      if (!(rangeKey in verticalOhlcv) || !priceBased.includes(rangeKey)) {
+      if (!(rangeKey in verticalOhlcv) || !priceBased.has(rangeKey)) {
         throw new Error(`Invalid range item value "${rangeKey}" property for donchianChannels. Only price based key names are accepted:\n${JSON.stringify(priceBased)}`);
       }
       keyNames.push(`${prefix}_range_${rangeKey}`)
 
-      if(autoMinMax)
-      {
-        main.autoMinMaxKeys.push(`${prefix}_range_${rangeKey}`)
-      }
-
     }
 
-    const verticalOhlcvSetup = Object.fromEntries(keyNames.map(v => [v, [...nullArray]]))
+    const verticalOhlcvSetup = Object.fromEntries(keyNames.map(v => [v, new Float64Array(len).fill(NaN)]))
     Object.assign(verticalOhlcv, {...verticalOhlcvSetup})
 
     if(lag > 0)
@@ -48,12 +42,20 @@ export const donchianChannels = (main, index, size, offset, { height, range, sca
       main.lag(keyNames, lag)
     }
 
-    priceBased.push(`${prefix}_upper`, `${prefix}_basis`, `${prefix}_lower`);
+
+    [`${prefix}_upper`, `${prefix}_basis`, `${prefix}_lower`].forEach(v => {
+      priceBased.add(v)
+    })
 
     instances.donchian_channel.settings[indicatorKey] = {
       maxDeque: [], // will hold indices for highs in descending order
       minDeque: []  // will hold indices for lows in ascending order
     };
+
+    for(const key of keyNames)
+    {
+      arrayTypes[key] = 'Float64Array'
+    }
   }
 
   const numberOfIndicators = instances.donchian_channel.numberOfIndicators;
@@ -67,16 +69,16 @@ export const donchianChannels = (main, index, size, offset, { height, range, sca
   const endIdx = currentBarIdx + 1; // currentBarIdx is inclusive
   const startIdx = endIdx - size;     // window: [startIdx, endIdx)
 
-  // If the window is not fully available, push null values for all computed outputs.
+  // If the window is not fully available, push NaN values for all computed outputs.
   if (startIdx < 0 || endIdx > len) {
-    main.pushToMain({ index, key: `${subPrefix}_upper`, value: null });
-    main.pushToMain({ index, key: `${subPrefix}_basis`, value: null });
-    main.pushToMain({ index, key: `${subPrefix}_lower`, value: null });
+    main.pushToMain({ index, key: `${subPrefix}_upper`, value: NaN });
+    main.pushToMain({ index, key: `${subPrefix}_basis`, value: NaN });
+    main.pushToMain({ index, key: `${subPrefix}_lower`, value: NaN });
     if (height) {
-      main.pushToMain({ index, key: `${subPrefix}_height`, value: null });
+      main.pushToMain({ index, key: `${subPrefix}_height`, value: NaN });
     }
     for (const rangeKey of range) {
-      main.pushToMain({ index, key: `${subPrefix}_range_${rangeKey}`, value: null });
+      main.pushToMain({ index, key: `${subPrefix}_range_${rangeKey}`, value: NaN });
     }
     return true;
   }
@@ -103,9 +105,9 @@ export const donchianChannels = (main, index, size, offset, { height, range, sca
   minDeque.push(currentBarIdx);
 
   // Retrieve computed values with safety checks.
-  const upper = maxDeque.length ? highs[maxDeque[0]] : null;
-  const lower = minDeque.length ? lows[minDeque[0]] : null;
-  const basis = (typeof upper === 'number' && typeof lower === 'number') ? (upper + lower) / 2 : null;
+  const upper = maxDeque.length ? highs[maxDeque[0]] : NaN;
+  const lower = minDeque.length ? lows[minDeque[0]] : NaN;
+  const basis = (!Number.isNaN(upper) && !Number.isNaN(lower)) ? (upper + lower) / 2 : NaN;
 
   // Always push the main indicator values.
   main.pushToMain({ index, key: `${subPrefix}_upper`, value: upper });
@@ -114,30 +116,23 @@ export const donchianChannels = (main, index, size, offset, { height, range, sca
 
   // Process height if enabled.
   if (height) {
-    let heightValue = null;
-    if (typeof upper === 'number' && typeof lower === 'number' && lower !== 0) {
-      heightValue = calcMagnitude( ((upper - lower) / lower), 0.001)
+    let heightValue = NaN;
+    if (!Number.isNaN(upper) && !Number.isNaN(lower)) {
+      heightValue = ((upper - lower) / lower)
     }
     main.pushToMain({ index, key: `${subPrefix}_height`, value: heightValue });
   }
 
   // Process each range property.
   for (const rangeKey of range) {
-    let rangeValue = null;
-    const priceValue = verticalOhlcv[rangeKey][index];
+    let rangeValue = NaN;
+    const priceValue = verticalOhlcv[rangeKey][index]
     if (
-      typeof priceValue === 'number' &&
-      typeof upper === 'number' &&
-      typeof lower === 'number' &&
-      (upper - lower) !== 0
+      !Number.isNaN(priceValue) &&
+      !Number.isNaN(upper) &&
+      !Number.isNaN(lower)
     ) {
-      rangeValue = (autoMinMax) 
-        ? Math.max(Math.min((priceValue - lower) / (upper - lower), 1), 0)
-        : (priceValue - lower) / (upper - lower)
-
-      if (scale) {
-        rangeValue = calcMagnitude(rangeValue, scale);
-      }
+      rangeValue = (priceValue - lower) / (upper - lower)
     }
     main.pushToMain({ index, key: `${subPrefix}_range_${rangeKey}`, value: rangeValue });
   }

package/src/moving-averages/macd.js

@@ -2,16 +2,16 @@ import { FasterEMA, FasterMACD } from 'trading-signals';
 
 const defaultTarget = 'close';
 
-export const macd = (main, index, fast, slow, signal, options) => {
-  const { target } = options;
-  const { verticalOhlcv, instances, lastIndexReplace } = main;
+export const macd = (main, index, fast, slow, signal, {target, lag}) => {
+
+  const { verticalOhlcv, instances } = main;
 
   // Create an instance key that includes the target if it isn't the default.
   const instanceKey = `${fast}_${slow}_${signal}${target === defaultTarget ? '' : `_${target}`}`;
 
   // Initialization on the first index.
   if (index === 0) {
-    const { inputParams, crossPairsList, nullArray, priceBased } = main;
+    const { inputParams, crossPairsList, priceBased, len , arrayTypes} = main;
 
     if (!verticalOhlcv.hasOwnProperty(target)) {
       throw new Error(`Target property ${target} not found in verticalOhlcv for macd.`);
@@ -42,12 +42,27 @@ export const macd = (main, index, fast, slow, signal, options) => {
     );
 
     Object.assign(verticalOhlcv, {
-      [diffKey]: [...nullArray],
-      [deaKey]: [...nullArray],
-      [histogramKey]: [...nullArray],
+      [diffKey]: new Float64Array(len).fill(NaN),
+      [deaKey]: new Float64Array(len).fill(NaN),
+      [histogramKey]: new Float64Array(len).fill(NaN),
     });
 
-    priceBased.push(diffKey, deaKey, histogramKey)
+    [diffKey, deaKey, histogramKey].forEach(v => {
+      priceBased.add(v)
+    })
+
+    const keyNames = [diffKey, deaKey, histogramKey]
+
+    if(lag > 0)
+    {
+      main.lag(keyNames, lag)
+    }
+
+    for(const key of keyNames)
+    {
+      arrayTypes[key] = 'Float64Array'
+    }
+
   }
 
   const { numberOfIndicators, settings } = instances.macd;
@@ -58,20 +73,19 @@ export const macd = (main, index, fast, slow, signal, options) => {
 
   const macdInstance = settings[instanceKey];
   const value = verticalOhlcv[target][index];
-  macdInstance.update(value, lastIndexReplace);
+  macdInstance.update(value);
 
-  let macdResult = null;
+  let macdResult = {}
   try {
     macdResult = macdInstance.getResult();
   } catch (err) {
-    // If the result is unavailable, macdResult remains null.
-    macdResult = null;
+    // If the result is unavailable, macdResult remains NaN.
   }
 
-  // Always push values; use null as fallback when macdResult is missing.
-  main.pushToMain({ index, key: diffKey, value: macdResult ? macdResult.macd : null });
-  main.pushToMain({ index, key: deaKey, value: macdResult ? macdResult.signal : null });
-  main.pushToMain({ index, key: histogramKey, value: macdResult ? macdResult.histogram : null });
+  // Always push values; use NaN as fallback when macdResult is missing.
+  main.pushToMain({ index, key: diffKey, value: macdResult ? macdResult.macd : NaN });
+  main.pushToMain({ index, key: deaKey, value: macdResult ? macdResult.signal : NaN });
+  main.pushToMain({ index, key: histogramKey, value: macdResult ? macdResult.histogram : NaN });
 
   return true;
 };

package/src/moving-averages/movingAverages.js

@@ -1,11 +1,10 @@
 
 import {FasterEMA, FasterSMA, FasterBollingerBands} from 'trading-signals';
-import { classifyBoll, calcZScore } from '../utilities/classification.js'
 
 const indicatorClasses = {ema: FasterEMA, sma: FasterSMA} 
 
-export const movingAverages = (main, index, indicatorName, size, { target, diff }) => {
-  const { verticalOhlcv, instances, priceBased, lastIndexReplace } = main;
+export const movingAverages = (main, index, indicatorName, size, { target, lag }) => {
+  const { verticalOhlcv, instances, priceBased } = main;
   let suffix =
     typeof target === 'string' &&
     verticalOhlcv.hasOwnProperty(target) &&
@@ -13,10 +12,9 @@ export const movingAverages = (main, index, indicatorName, size, { target, diff
       ? `_${target}`
       : '';
   const keyName = `${indicatorName}_${size}${suffix}`;
-  const diffKeyName = `${indicatorName}_${size}_diff${suffix}`;
 
   if (index === 0) {
-    const { nullArray } = main;
+    const { len, arrayTypes } = main;
 
     if (!verticalOhlcv.hasOwnProperty(target)) {
       throw new Error(
@@ -29,146 +27,34 @@ export const movingAverages = (main, index, indicatorName, size, { target, diff
       maInstance: new indicatorClasses[indicatorName](size)
     };
 
-    verticalOhlcv[keyName] = [...nullArray];
+    verticalOhlcv[keyName] = new Float64Array(len).fill(NaN)
 
-    // If diff configuration is provided, create the diff indicator.
-    if (diff !== null) {
-      instances[keyName].diffInstance = new FasterBollingerBands(
-        diff.size,
-        diff.stdDev
-      );
-
-      const lagDiffArr = [];
-
-      for (const targetKey of diff.targets) {
-        verticalOhlcv[`${diffKeyName}_${targetKey}`] = [...nullArray];
-
-        if(diff.autoMinMax)
-        {
-          main.autoMinMaxKeys.push(`${diffKeyName}_${targetKey}`)
-        }
-
-        if (diff.lag > 0) {
-          lagDiffArr.push(`${diffKeyName}_${targetKey}`);
-        }
-      }
+    priceBased.add(keyName);
 
-      if (diff.lag > 0) {
-        main.lag(lagDiffArr, diff.lag);
-      }
+    if(lag > 0)
+    {
+      main.lag([keyName], lag)
     }
 
-    priceBased.push(keyName);
+    arrayTypes[keyName] = 'Float64Array'
+
   }
 
   // Retrieve the current price value.
   const value = verticalOhlcv[target][index];
-  const { maInstance, diffInstance } = instances[keyName];
+  const { maInstance } = instances[keyName];
 
   // Update the moving average instance.
-  maInstance.update(value, lastIndexReplace);
-  let currMa = null;
+  maInstance.update(value);
+  let currMa = NaN;
   try {
     currMa = maInstance.getResult();
   } catch (err) {
-    currMa = null;
+    currMa = NaN;
   }
 
-  // Always push the MA value (even if null).
+  // Always push the MA value (even if NaN).
   main.pushToMain({ index, key: keyName, value: currMa });
 
-  // Process the diff values if a diff is requested.
-  if (diff !== null) {
-    for (const targetKey of diff.targets) {
-      // Compute diffValue only if we have a valid MA value.
-      let diffValue = null;
-      if (currMa !== null && typeof currMa === 'number') {
-        diffValue = verticalOhlcv[targetKey][index] - currMa;
-      }
-
-      // Update the diff indicator only if diffValue is a valid number.
-      if (diffValue !== null && typeof diffValue === 'number') {
-        diffInstance.update(Math.abs(diffValue), lastIndexReplace);
-      }
-
-      let diffBoll = null;
-      try {
-        diffBoll = diffInstance.getResult();
-      } catch (err) {
-        diffBoll = null;
-      }
-
-      const classified = classifyBoll(diffValue, diffBoll, diff.scale, diff.autoMinMax);
-      main.pushToMain({
-        index,
-        key: `${diffKeyName}_${targetKey}`,
-        value: classified
-      });
-    }
-  }
-
   return true;
-};
-
-
-export const getMovingAveragesParams = (indicatorName, size, options, validMagnitudeValues) => {
-  if (!options || typeof options !== 'object') {
-    throw new Error(`"options" must be an object in ${indicatorName}. eg: {target, height, range}`);
-  }
-
-  let { target = 'close', diff = null } = options;
-
-  if(typeof target !== 'string')
-  {
-    throw new Error(`"target" must be a valid keyName ${indicatorName}.`);
-  }
-
-  if (typeof size !== 'number' || size <= 0) {
-    throw new Error(`"size" must be a positive number in ${indicatorName}.`);
-  }
-
-  //diff can be null, true, false or an object with optional {stdDev, scale, targets, and size}
-  const optionArgs = { target, diff: null };
-
-  if (diff !== null && (typeof diff === 'object' || (typeof diff === 'boolean' && diff === true))) {
-
-    diff = (diff === true) ? ({}) : diff
-
-    const {
-      stdDev = 2,
-      scale = 0.05,
-      targets = ['close'],
-      size: diffSize = size,
-      lag = 0,
-      autoMinMax = false
-    } = diff;
-
-    if (typeof stdDev !== 'number' || stdDev <= 0) {
-      throw new Error(`"diff.stdDev" must be a number greater than 0 in ${indicatorName}.`);
-    }
-
-    if (typeof scale !== 'number' || !validMagnitudeValues.includes(scale)) {
-      throw new Error(`"diff.scale" must be a number between 0.01 and 1 in ${indicatorName}.`);
-    }
-
-    if (typeof diffSize !== 'number' || !Number.isInteger(diffSize) || diffSize <= 0) {
-      throw new Error(`"diff.size" must be an integer greater than or equal to size in ${indicatorName}.`);
-    }
-
-    if (!Array.isArray(targets)) {
-      throw new Error(`"diff.targest" must be an array of keyNames with at least 1 item in ${indicatorName}.`);
-    }
-
-    if (typeof lag !== 'number' || !Number.isInteger(lag) || lag < 0) {
-      throw new Error(`"diff.lag" must be an integer greater than 0 in ${indicatorName}.`);
-    }
-
-    if (typeof autoMinMax !== 'boolean') {
-      throw new Error(`"diff.autoMinMax" must be an boolean in ${indicatorName}.`);
-    }
-
-    optionArgs.diff = { stdDev, scale, size: diffSize, targets, lag, autoMinMax};
-  }
-
-  return optionArgs;
 }

package/src/moving-averages/relativeVolume.js

@@ -1,39 +1,45 @@
 import { FasterSMA } from 'trading-signals';
-import { calcMagnitude } from '../utilities/numberUtilities.js';
 
-export const relativeVolume = (main, index, size = 10, { scale }) => {
+export const relativeVolume = (main, index, size, {lag}) => {
+
   const key = `relative_volume_${size}`;
-  const { instances, verticalOhlcv, lastIndexReplace } = main;
+  const { instances, verticalOhlcv } = main;
 
   if (index === 0) {
-    const { nullArray } = main;
+    const { len, arrayTypes } = main;
+
     instances[key] = {
       instance: new FasterSMA(size),
-      prevRelativeVolumeSma: null
+      prevRelativeVolumeSma: NaN
     };
-    verticalOhlcv[key] = [...nullArray];
+    
+    verticalOhlcv[key] = new Float64Array(len).fill(NaN);
+
+    if(lag > 0)
+    {
+      main.lag([key], lag)
+    }
+  
+    arrayTypes[key] = 'Float64Array'
   }
 
   const value = verticalOhlcv.volume[index];
   const smaInstance = instances[key].instance;
-  smaInstance.update(value, lastIndexReplace);
+  smaInstance.update(value);
 
-  let smaValue = null;
+  let smaValue = NaN;
   try {
     smaValue = smaInstance.getResult();
   } catch (err) {
-    smaValue = null;
+
   }
 
   const prevSma = instances[key].prevRelativeVolumeSma;
-  let currRelativeVolume = null;
+  let currRelativeVolume = NaN;
 
   // Only calculate relative volume if both current SMA and previous SMA are valid numbers and prevSma is not zero.
-  if (typeof smaValue === 'number' && typeof prevSma === 'number' && prevSma !== 0) {
+  if (!Number.isNaN(smaValue) && !Number.isNaN(prevSma)) {
     currRelativeVolume = value / prevSma;
-    if (scale) {
-      currRelativeVolume = calcMagnitude(currRelativeVolume, scale);
-    }
   }
 
   main.pushToMain({ index, key, value: currRelativeVolume });