ohlcv-indicators 3.4.1 → 3.4.3

package/index.js

@@ -16,6 +16,10 @@ import { assignTypes } from './src/utilities/assignTypes.js'
 import { calcPrecisionMultiplier } from './src/utilities/precisionMultiplier.js'
 import { buildArray } from './src/utilities/assignTypes.js'
 
+
+//precomputed
+import { precomputeMovingAverages } from './src/moving-averages/movingAverages.js'
+
 /**
  * Class OHLCV_INDICATORS
  *
@@ -235,7 +239,9 @@ export default class OHLCV_INDICATORS {
 
         validateNumber(lag, {min: 0, max: this.len, allowDecimals: false}, 'options.lag', methodName)
 
-        this.inputParams.push({key: methodName, params: [methodName, size, {target, lag}]})
+        const precomputed = precomputeMovingAverages({main: this, size, target, lag, methodName})
+
+        this.inputParams.push({key: methodName, params: [methodName, size, {target, lag, precomputed}]})
 
         return this
     }
@@ -252,7 +258,10 @@ export default class OHLCV_INDICATORS {
 
         validateNumber(lag, {min: 0, max: this.len, allowDecimals: false}, 'options.lag', methodName)
 
-        this.inputParams.push({key: methodName, params: [methodName, size, {target, lag}]})
+
+        const precomputed = precomputeMovingAverages({main: this, size, target, lag, methodName})
+
+        this.inputParams.push({key: methodName, params: [methodName, size, {target, lag, precomputed}]})
 
         return this
     }
@@ -273,7 +282,10 @@ export default class OHLCV_INDICATORS {
         
         validateNumber(lag, {min: 0, max: this.len, allowDecimals: false}, 'options.lag', methodName)
 
-        this.inputParams.push({key: methodName, params: [fast, slow, signal, {target, lag}]})
+        const instanceKey = `${fast}_${slow}_${signal}${target === 'close' ? '' : `_${target}`}`
+        const precomputed = {instanceKey}
+
+        this.inputParams.push({key: methodName, params: [fast, slow, signal, {target, lag, precomputed}]})
         
         return this
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ohlcv-indicators",
-  "version": "3.4.1",
+  "version": "3.4.3",
   "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/moving-averages/donchianChannel.js

@@ -1,146 +1,125 @@
 
-export const donchianChannels = (main, index, size, offset, { height, range, lag }) => {
+export const donchianChannels = (main, index, size, offset, options) => {
+  const {
+    verticalOhlcv,
+    instances,
+    len,
+    inputParams,
+    priceBased,
+    arrayTypes,
+    lag,
+  } = main;
+  const { height: includeHeight, range: rangeKeys } = options;
   const indicatorKey = `${size}_${offset}`;
-  const { verticalOhlcv, instances, len } = main;
 
-  // Initialization: create output arrays and indicator instance on the first call.
+  // ---- INIT (only at first bar) ----
   if (index === 0) {
-    const { inputParams, priceBased, arrayTypes} = main;
-    let numberOfIndicators = 0
-
-    for (const o of inputParams) {
-      if (o.key === 'donchianChannels') numberOfIndicators++;
-    }
-
-    const prefix = numberOfIndicators > 1 ? `donchian_channel_${indicatorKey}` : 'donchian_channel';
-
-    const keyNames = [
-      `${prefix}_upper`,
-      `${prefix}_basis`,
-      `${prefix}_lower`,
-    ]
-
-
-    if (height) {
-      keyNames.push(`${prefix}_height`)
-    }
-
-   
-    if (!instances.hasOwnProperty('donchian_channel')) {
-      instances.donchian_channel = { numberOfIndicators, settings: {} };
-    }
-
-    // Set up additional arrays for each range property.
-    for (const rangeKey of range) {
-      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)}`);
+    // how many donchianChannels calls in this session?
+    const numberOfIndicators = inputParams.filter(o => o.key === 'donchianChannels').length;
+    const basePrefix = 'donchian_channel';
+    const prefix = numberOfIndicators > 1
+      ? `${basePrefix}_${indicatorKey}`
+      : basePrefix;
+
+    // build all output keys once
+    const keys = ['upper', 'basis', 'lower'].map(n => `${prefix}_${n}`);
+    if (includeHeight) keys.push(`${prefix}_height`);
+    for (const rk of rangeKeys) {
+      if (!(rk in verticalOhlcv) || !priceBased.has(rk)) {
+        throw new Error(
+          `Invalid range key "${rk}". Only price-based keys are allowed: ${[...priceBased]}`
+        );
       }
-      keyNames.push(`${prefix}_range_${rangeKey}`)
-
+      keys.push(`${prefix}_range_${rk}`);
     }
 
-    const verticalOhlcvSetup = Object.fromEntries(keyNames.map(v => [v, new Float64Array(len).fill(NaN)]))
-    Object.assign(verticalOhlcv, {...verticalOhlcvSetup})
-
-    if(lag > 0)
-    {
-      main.lag(keyNames, lag)
+    // bootstrap instance
+    if (!instances.donchian_channel) {
+      instances.donchian_channel = { numberOfIndicators, settings: {} };
     }
+    instances.donchian_channel.numberOfIndicators = numberOfIndicators;
+    instances.donchian_channel.settings[indicatorKey] = { maxDeque: [], minDeque: [] };
 
+    // allocate & fill NaNs
+    Object.assign(
+      verticalOhlcv,
+      Object.fromEntries(keys.map(k => [k, new Float64Array(len).fill(NaN)]))
+    );
 
-    [`${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
-    };
+    // apply lag if requested
+    if (lag > 0) main.lag(keys, lag);
 
-    for(const key of keyNames)
-    {
-      arrayTypes[key] = 'Float64Array'
-    }
+    // mark price-based outputs
+    ['upper','basis','lower'].forEach(n => priceBased.add(`${prefix}_${n}`));
+    keys.forEach(k => arrayTypes[k] = 'Float64Array');
   }
 
-  const numberOfIndicators = instances.donchian_channel.numberOfIndicators;
-  const subPrefix = numberOfIndicators > 1 ? `donchian_channel_${indicatorKey}` : 'donchian_channel';
-  const state = instances.donchian_channel.settings[indicatorKey];
-  const { maxDeque, minDeque } = state;
-
-  // Compute the “current bar index” for the window.
-  // Note: We use index - offset so that the window is built on the proper part of the array.
-  const currentBarIdx = index - offset;
-  const endIdx = currentBarIdx + 1; // currentBarIdx is inclusive
-  const startIdx = endIdx - size;     // window: [startIdx, endIdx)
-
-  // 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: 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: NaN });
-    }
-    for (const rangeKey of range) {
-      main.pushToMain({ index, key: `${subPrefix}_range_${rangeKey}`, value: NaN });
-    }
+  // ---- PER-BAR COMPUTATION ----
+  const { numberOfIndicators, settings } = instances.donchian_channel;
+  const prefix = numberOfIndicators > 1
+    ? `donchian_channel_${indicatorKey}`
+    : 'donchian_channel';
+
+  const { maxDeque, minDeque } = settings[indicatorKey];
+  const current = index - offset;
+  const start   = current - size + 1;
+
+  // prepare key lists again (cheap)
+  const outKeys    = ['upper','basis','lower'].map(n => `${prefix}_${n}`);
+  if (includeHeight) outKeys.push(`${prefix}_height`);
+  const rangeOut   = rangeKeys.map(rk => `${prefix}_range_${rk}`);
+
+  // not enough data → push NaNs
+  if (start < 0 || current + 1 > len) {
+    [...outKeys, ...rangeOut].forEach(key =>
+      main.pushToMain({ index, key, value: NaN })
+    );
     return true;
   }
 
-  const highs = verticalOhlcv.high;
-  const lows = verticalOhlcv.low;
-
-  // **Update the maximum deque:**
-  while (maxDeque.length && maxDeque[0] < startIdx) {
-    maxDeque.shift();
-  }
-  while (maxDeque.length && highs[maxDeque[maxDeque.length - 1]] <= highs[currentBarIdx]) {
-    maxDeque.pop();
+  const { high: highs, low: lows } = verticalOhlcv;
+
+  // tiny helper to keep deques up-to-date
+  const update = (dq, arr, cmp) => {
+    while (dq.length && dq[0] < start)      dq.shift();
+    while (dq.length && cmp(arr[dq.at(-1)], arr[current])) dq.pop();
+    dq.push(current);
+  };
+  update(maxDeque, highs, (a,b) => a <= b);
+  update(minDeque, lows,  (a,b) => a >= b);
+
+  // single “bounds exist?” flag instead of repeated isNaN
+  const hasBounds = maxDeque.length && minDeque.length;
+  const upper     = hasBounds ? highs[maxDeque[0]] : NaN;
+  const lower     = hasBounds ? lows[minDeque[0]]  : NaN;
+  const basis     = hasBounds ? (upper + lower) / 2  : NaN;
+
+  main.pushToMain({ index, key: `${prefix}_upper`, value: upper });
+  main.pushToMain({ index, key: `${prefix}_basis`, value: basis });
+  main.pushToMain({ index, key: `${prefix}_lower`, value: lower });
+
+  if (includeHeight) {
+    // avoid divide-by-zero
+    const heightVal = hasBounds && lower
+      ? (upper - lower) / lower
+      : NaN;
+    main.pushToMain({ index, key: `${prefix}_height`, value: heightVal });
   }
-  maxDeque.push(currentBarIdx);
 
-  // **Update the minimum deque:**
-  while (minDeque.length && minDeque[0] < startIdx) {
-    minDeque.shift();
-  }
-  while (minDeque.length && lows[minDeque[minDeque.length - 1]] >= lows[currentBarIdx]) {
-    minDeque.pop();
-  }
-  minDeque.push(currentBarIdx);
-
-  // Retrieve computed values with safety checks.
-  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 });
-  main.pushToMain({ index, key: `${subPrefix}_basis`, value: basis });
-  main.pushToMain({ index, key: `${subPrefix}_lower`, value: lower });
-
-  // Process height if enabled.
-  if (height) {
-    let heightValue = NaN;
-    if (!Number.isNaN(upper) && !Number.isNaN(lower)) {
-      heightValue = ((upper - lower) / lower)
-    }
-    main.pushToMain({ index, key: `${subPrefix}_height`, value: heightValue });
-  }
+  // precompute spread once
+  const spread = hasBounds ? (upper - lower) : NaN;
 
-  // Process each range property.
-  for (const rangeKey of range) {
-    let rangeValue = NaN;
-    const priceValue = verticalOhlcv[rangeKey][index]
-    if (
-      !Number.isNaN(priceValue) &&
-      !Number.isNaN(upper) &&
-      !Number.isNaN(lower)
-    ) {
-      rangeValue = (priceValue - lower) / (upper - lower)
-    }
-    main.pushToMain({ index, key: `${subPrefix}_range_${rangeKey}`, value: rangeValue });
+  // for each extra range key, use price===price to skip NaNs
+
+  for(let i = 0; i < rangeKeys.length; i++)
+  {
+    const rk = rangeKeys[i]
+    const price = verticalOhlcv[rk][index];
+    const val   = hasBounds && price === price && spread
+      ? (price - lower) / spread
+      : NaN;
+    main.pushToMain({ index, key: rangeOut[i], value: val });
   }
 
   return true;
-}
+};

package/src/moving-averages/macd.js

@@ -2,55 +2,53 @@ import { FasterEMA, FasterMACD } from 'trading-signals';
 
 const defaultTarget = 'close';
 
-export const macd = (main, index, fast, slow, signal, {target, lag}) => {
+export const macd = (main, index, fast, slow, signal, {target, lag, precomputed}) => {
 
-  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}`}`;
+  const { verticalOhlcv, instances } = main
+  const {instanceKey} = precomputed
 
   // Initialization on the first index.
   if (index === 0) {
-    const { inputParams, crossPairsList, priceBased, len , arrayTypes} = main;
+    const { inputParams, crossPairsList, priceBased, len , arrayTypes} = main
 
     if (!verticalOhlcv.hasOwnProperty(target)) {
-      throw new Error(`Target property ${target} not found in verticalOhlcv for macd.`);
+      throw new Error(`Target property ${target} not found in verticalOhlcv for macd.`)
     }
 
     let numberOfIndicators = 0
 
     for (const o of inputParams) {
-      if (o.key === 'macd') numberOfIndicators++;
+      if (o.key === 'macd') numberOfIndicators++
     }
 
     // Choose a display prefix based on the number of indicators.
-    const displayPrefix = numberOfIndicators > 1 ? `macd_${fast}_${slow}_${signal}` : 'macd';
+    const displayPrefix = numberOfIndicators > 1 ? `macd_${fast}_${slow}_${signal}` : 'macd'
 
     // Build the keys.
-    const diffKey = target === defaultTarget ? `${displayPrefix}_diff` : `${displayPrefix}_diff_${target}`;
-    const deaKey = target === defaultTarget ? `${displayPrefix}_dea` : `${displayPrefix}_dea_${target}`;
-    const histogramKey = target === defaultTarget ? `${displayPrefix}_histogram` : `${displayPrefix}_histogram_${target}`;
+    const diffKey = target === defaultTarget ? `${displayPrefix}_diff` : `${displayPrefix}_diff_${target}`
+    const deaKey = target === defaultTarget ? `${displayPrefix}_dea` : `${displayPrefix}_dea_${target}`
+    const histogramKey = target === defaultTarget ? `${displayPrefix}_histogram` : `${displayPrefix}_histogram_${target}`
 
-    crossPairsList.push({ fast: diffKey, slow: deaKey, isDefault: true });
+    crossPairsList.push({ fast: diffKey, slow: deaKey, isDefault: true })
 
     if (!instances.hasOwnProperty('macd')) {
       instances.macd = {
         numberOfIndicators,
         settings: {}
-      };
+      }
     }
 
     instances.macd.settings[instanceKey] = new FasterMACD(
       new FasterEMA(fast),
       new FasterEMA(slow),
       new FasterEMA(signal)
-    );
+    )
 
     Object.assign(verticalOhlcv, {
       [diffKey]: new Float64Array(len).fill(NaN),
       [deaKey]: new Float64Array(len).fill(NaN),
       [histogramKey]: new Float64Array(len).fill(NaN),
-    });
+    })
 
     [diffKey, deaKey, histogramKey].forEach(v => {
       priceBased.add(v)
@@ -70,27 +68,27 @@ export const macd = (main, index, fast, slow, signal, {target, lag}) => {
 
   }
 
-  const { numberOfIndicators, settings } = instances.macd;
-  const displayPrefix = numberOfIndicators > 1 ? `macd_${fast}_${slow}_${signal}` : 'macd';
-  const diffKey = target === defaultTarget ? `${displayPrefix}_diff` : `${displayPrefix}_diff_${target}`;
-  const deaKey = target === defaultTarget ? `${displayPrefix}_dea` : `${displayPrefix}_dea_${target}`;
-  const histogramKey = target === defaultTarget ? `${displayPrefix}_histogram` : `${displayPrefix}_histogram_${target}`;
+  const { numberOfIndicators, settings } = instances.macd
+  const displayPrefix = numberOfIndicators > 1 ? `macd_${fast}_${slow}_${signal}` : 'macd'
+  const diffKey = target === defaultTarget ? `${displayPrefix}_diff` : `${displayPrefix}_diff_${target}`
+  const deaKey = target === defaultTarget ? `${displayPrefix}_dea` : `${displayPrefix}_dea_${target}`
+  const histogramKey = target === defaultTarget ? `${displayPrefix}_histogram` : `${displayPrefix}_histogram_${target}`
 
-  const macdInstance = settings[instanceKey];
-  const value = verticalOhlcv[target][index];
-  macdInstance.update(value);
+  const macdInstance = settings[instanceKey]
+  const value = verticalOhlcv[target][index]
+  macdInstance.update(value)
 
   let macdResult = {}
   try {
-    macdResult = macdInstance.getResult();
+    macdResult = macdInstance.getResult()
   } catch (err) {
     // If the result is unavailable, macdResult remains NaN.
   }
 
   // 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 });
+  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;
+  return true
 };

package/src/moving-averages/movingAverages.js

@@ -1,48 +1,24 @@
 
-import {FasterEMA, FasterSMA, FasterBollingerBands} from 'trading-signals';
+import {FasterEMA, FasterSMA} from 'trading-signals';
 
 const indicatorClasses = {ema: FasterEMA, sma: FasterSMA} 
 
-export const movingAverages = (main, index, indicatorName, size, { target, lag }) => {
-  const { verticalOhlcv, instances, priceBased } = main;
-  let suffix =
-    typeof target === 'string' &&
-    verticalOhlcv.hasOwnProperty(target) &&
-    target !== 'close'
-      ? `_${target}`
-      : '';
-  const keyName = `${indicatorName}_${size}${suffix}`;
+export const movingAverages = (main, index, indicatorName, size, { target, lag, precomputed }) => {
+  const { verticalOhlcv, instances } = main
+  const {keyName} = precomputed
 
   if (index === 0) {
-    const { len, arrayTypes } = main;
 
     if (!verticalOhlcv.hasOwnProperty(target)) {
       throw new Error(
         `Target property ${target} not found in verticalOhlcv for ${indicatorName}.`
       );
     }
-
-    // Create the main moving average instance.
-    instances[keyName] = {
-      maInstance: new indicatorClasses[indicatorName](size)
-    };
-
-    verticalOhlcv[keyName] = new Float64Array(len).fill(NaN)
-
-    priceBased.add(keyName);
-
-    if(lag > 0)
-    {
-      main.lag([keyName], lag)
-    }
-
-    arrayTypes[keyName] = 'Float64Array'
-
   }
 
   // Retrieve the current price value.
-  const value = verticalOhlcv[target][index];
-  const { maInstance } = instances[keyName];
+  const value = verticalOhlcv[target][index]
+  const { maInstance } = instances[keyName]
 
   // Update the moving average instance.
   maInstance.update(value);
@@ -50,11 +26,36 @@ export const movingAverages = (main, index, indicatorName, size, { target, lag }
   try {
     currMa = maInstance.getResult();
   } catch (err) {
-    currMa = NaN;
+
   }
 
   // Always push the MA value (even if NaN).
   main.pushToMain({ index, key: keyName, value: currMa });
 
   return true;
+}
+
+export const precomputeMovingAverages = ({main, size, target, lag, methodName}) => {
+
+  const {instances, verticalOhlcv, priceBased, arrayTypes, len} = main
+  const suffix = (target !== 'close') ?  `_${target}` : ''
+  const keyName = `${methodName}_${size}${suffix}`
+
+    // Create the main moving average instance.
+    instances[keyName] = {
+      maInstance: new indicatorClasses[methodName](size)
+    }
+
+    verticalOhlcv[keyName] = new Float64Array(len).fill(NaN)
+
+    priceBased.add(keyName)
+
+    if(lag > 0)
+    {
+      main.lag([keyName], lag)
+    }
+
+    arrayTypes[keyName] = 'Float64Array'
+  
+  return {keyName}
 }

package/src/oscillators/volumeOscillator.js

@@ -4,13 +4,13 @@ export const volumeOscillator = (main, index, fast, slow, {lag}) => {
 
     const {verticalOhlcv, instances} = main
     const value = verticalOhlcv.volume[index]
-    const key = 'volume_oscillator'
+    const key = `volume_oscillator_${fast}_${slow}`
 
     if (index === 0) {
 
         const {crossPairsList, len, arrayTypes} = main
         Object.assign(instances, {
-            volume_oscillator: {
+            [key]: {
                 fastEMA: new FasterEMA(fast),
                 slowEMA: new FasterEMA(slow)
             }

package/src/studies/dateTime.js

@@ -16,7 +16,7 @@ export const dateTime = (main, index, {lag}) => {
             }
         })
 
-        const colKeys = ['day_of_the_week', 'day_of_the_month', 'week_of_the_month', 'hour', 'month', 'year', 'session_daily_index', 'session_intraday_index']
+        const colKeys = ['day_of_the_week', 'day_of_the_month', 'week_of_the_month', 'minute', 'hour', 'month', 'year', 'session_daily_index', 'session_intraday_index']
 
         for(const key of colKeys)
         {
@@ -41,6 +41,7 @@ export const dateTime = (main, index, {lag}) => {
         month,
         year,
         hour,
+        minute
     } = getDateInfo(currDate)
 
 
@@ -63,6 +64,7 @@ export const dateTime = (main, index, {lag}) => {
     main.pushToMain({index, key: 'month', value: month})
     main.pushToMain({index, key: 'year', value: year})
     main.pushToMain({index, key: 'hour', value: hour})
+    main.pushToMain({index, key: 'minute', value: minute})
 
 
     instances.dateTime.sessionIntradayIndexCount++