ohlcv-indicators 3.5.78 → 3.5.80

package/src/moving-averages/donchianChannel.js

@@ -1,39 +1,40 @@
+import { validateInputValues } from '../utilities/validators.js'
+import { initializeColumns } from '../core-functions/initializeColumns.js'
+import { mathLog } from '../utilities/math.js'
+
 export const donchianChannels = (main, index, size, offset, options) => {
-  const { verticalOhlcv, instances, len, inputParams, priceBased, useFullNames } = main
-  const { lag: outputLag = 0 } = options
+  const { verticalOhlcv, instances, len, inputParams, useFullNames } = main
+  const { lag: outputLag = 0, retLogs = false } = options
   const indicatorKey = `${size}_${offset}`
+  const instanceKey = `${retLogs ? 'ret_log_' : ''}${indicatorKey}`
+  const prefix = `${retLogs ? 'ret_log_' : ''}donchian_channel`
 
   // ---- INIT (only at first bar) ----
   if (index === 0) {
+    validateInputValues({ high: true, low: true }, verticalOhlcv, index, 'donchianChannels')
+    if (retLogs) validateInputValues({ close: true }, verticalOhlcv, index, 'donchianChannels')
+
     const numberOfIndicators = inputParams.filter(o => o.key === 'donchianChannels').length
     const useIndexedKeys = numberOfIndicators > 1 || useFullNames
 
     const getKey = name =>
       useIndexedKeys
-        ? `donchian_channel_${name}_${indicatorKey}`
-        : `donchian_channel_${name}`
+        ? `${prefix}_${name}_${indicatorKey}`
+        : `${prefix}_${name}`
 
-    const keys = ['upper', 'basis', 'lower'].map(getKey)
-
-    for (const k of keys) {
-      priceBased.add(k)
-    }
+    const keys = (retLogs ? ['width', 'position'] : ['upper', 'basis', 'lower']).map(getKey)
 
     if (!instances.donchian_channel) {
       instances.donchian_channel = { numberOfIndicators, settings: {} }
     }
 
     instances.donchian_channel.numberOfIndicators = numberOfIndicators
-    instances.donchian_channel.settings[indicatorKey] = { maxDeque: [], minDeque: [] }
-
-    Object.assign(
-      verticalOhlcv,
-      Object.fromEntries(keys.map(k => [k, new Float64Array(len).fill(NaN)]))
-    )
-
-    if (outputLag > 0) {
-      main.lag(keys, outputLag)
+    instances.donchian_channel.settings[instanceKey] = {
+      maxDeque: { indices: [], head: 0, length: 0 },
+      minDeque: { indices: [], head: 0, length: 0 }
     }
+
+    initializeColumns(main, keys.map(key => ({ key, priceBased: !retLogs })), { lag: outputLag })
   }
 
   // ---- PER-BAR COMPUTATION ----
@@ -42,41 +43,66 @@ export const donchianChannels = (main, index, size, offset, options) => {
 
   const getKey = name =>
     useIndexedKeys
-      ? `donchian_channel_${name}_${indicatorKey}`
-      : `donchian_channel_${name}`
+      ? `${prefix}_${name}_${indicatorKey}`
+      : `${prefix}_${name}`
 
-  const { maxDeque, minDeque } = settings[indicatorKey]
+  const { maxDeque, minDeque } = settings[instanceKey]
   const current = index - offset
   const start = current - size + 1
 
-  const outKeys = ['upper', 'basis', 'lower'].map(getKey)
-
-  if (start < 0 || current + 1 > len) {
-    outKeys.forEach(key =>
-      main.pushToMain({ index, key, value: NaN })
-    )
-    return true
-  }
+  // No source candle is available yet.
+  if (current < 0 || current >= len) return
 
   const { high: highs, low: lows } = verticalOhlcv
 
   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)
+    const { indices } = dq
+    while (dq.length && indices[dq.head] < start) {
+      dq.head = (dq.head + 1) % size
+      dq.length--
+    }
+    while (dq.length && cmp(arr[indices[(dq.head + dq.length - 1) % size]], arr[current])) {
+      dq.length--
+    }
+    // Reuse at most size slots instead of moving entries or growing with the input.
+    indices[(dq.head + dq.length) % size] = current
+    dq.length++
   }
 
   update(maxDeque, highs, (a, b) => a <= b)
   update(minDeque, lows, (a, b) => a >= b)
 
+  // Collect warm-up candles, but leave outputs as NaN until the window is complete.
+  if (start < 0) return
+
   const hasBounds = maxDeque.length && minDeque.length
-  const upper = hasBounds ? highs[maxDeque[0]] : NaN
-  const lower = hasBounds ? lows[minDeque[0]] : NaN
+  const upper = hasBounds ? highs[maxDeque.indices[maxDeque.head]] : NaN
+  const lower = hasBounds ? lows[minDeque.indices[minDeque.head]] : NaN
+
+  if (retLogs) {
+    let width = NaN
+    let position = NaN
+    const rangeRatio = upper / lower
+    if (lower > 0 && upper >= lower && Number.isFinite(upper) && Number.isFinite(rangeRatio)) {
+      const logRange = mathLog(rangeRatio, 1)
+      width = logRange / 2
+      // Offset applies to the channel window, not to the current close.
+      const close = verticalOhlcv.close[index]
+      const locationRatio = close / lower
+      if (logRange > 0 && close > 0 && locationRatio > 0 && Number.isFinite(locationRatio)) {
+        const normalized = 2 * mathLog(locationRatio, 1) / logRange - 1
+        if (Number.isFinite(normalized)) position = normalized
+      }
+    }
+    main.pushToMain({ index, key: getKey('width'), value: width })
+    main.pushToMain({ index, key: getKey('position'), value: position })
+    return
+  }
+
   const basis = hasBounds ? (upper + lower) / 2 : NaN
 
   main.pushToMain({ index, key: getKey('upper'), value: upper })
   main.pushToMain({ index, key: getKey('basis'), value: basis })
   main.pushToMain({ index, key: getKey('lower'), value: lower })
 
-  return true
-}
+}

package/src/moving-averages/heikenAshi.js

@@ -1,4 +1,6 @@
-import { FasterEMA } from 'trading-signals';
+import { FasterEMA } from '../core-indicators/index.js';
+import { validateInputValues } from '../utilities/validators.js';
+import { initializeColumns } from '../core-functions/initializeColumns.js';
 
 const isBadNumber = v => v == null || !Number.isFinite(v);
 
@@ -9,9 +11,8 @@ export const heikenAshi = (
   afterSmoothLength,
   { lag = 0, bothNull = false, retLogs = true } = {}
 ) => {
-  const { verticalOhlcv, instances, len, scaledGroups } = main;
+  const { verticalOhlcv, instances, scaledGroups } = main;
   const indicatorKey = `${smoothLength}_${afterSmoothLength}`;
-  const ohlcKeys = ['open', 'high', 'low', 'close'];
 
   const getRet = (next, prev) => retLogs
     ? Math.log(next / prev)
@@ -23,13 +24,6 @@ export const heikenAshi = (
 
   const getKey = key => `${prefix}heiken_ashi_${key}${paramsKey}`;
 
-  const featureKeys = [
-    'body',
-    'upper_wick',
-    'lower_wick',
-    'range'
-  ];
-
   const crossKey = bothNull
     ? 'heiken_ashi_cross'
     : `heiken_ashi_cross_${indicatorKey}`;
@@ -40,6 +34,10 @@ export const heikenAshi = (
 
   // ---- INIT ----
   if (index === 0) {
+    validateInputValues({ open: true, high: true, low: true, close: true }, verticalOhlcv, index, 'heikenAshi');
+    const ohlcKeys = ['open', 'high', 'low', 'close'];
+    const featureKeys = ['body', 'upper_wick', 'lower_wick', 'range'];
+
     instances[instanceKey] = {
       emaPre: !bothNull
         ? Object.fromEntries(ohlcKeys.map(k => [k, new FasterEMA(smoothLength)]))
@@ -56,19 +54,11 @@ export const heikenAshi = (
 
     const keyNames = featureKeys.map(getKey);
 
-    const verticalOhlcvSetup = Object.fromEntries(
-      [...keyNames, crossKey].map(k => [k, new Float64Array(len).fill(NaN)])
-    );
-
-    Object.assign(verticalOhlcv, verticalOhlcvSetup);
+    initializeColumns(main, [...keyNames, crossKey].map(key => ({ key })), { lag });
 
     if (scaledGroups) {
       scaledGroups.heikenAshi = keyNames;
     }
-
-    if (lag > 0) {
-      main.lag(keyNames, lag);
-    }
   }
 
   // ---- FETCH RAW INPUTS ----
@@ -84,7 +74,7 @@ export const heikenAshi = (
     isBadNumber(low) ||
     isBadNumber(close)
   ) {
-    return true;
+    return;
   }
 
   let sOpen, sHigh, sLow, sClose;
@@ -96,14 +86,12 @@ export const heikenAshi = (
     inst.emaPre.low.update(low);
     inst.emaPre.close.update(close);
 
-    try {
-      sOpen = inst.emaPre.open.getResult();
-      sHigh = inst.emaPre.high.getResult();
-      sLow = inst.emaPre.low.getResult();
-      sClose = inst.emaPre.close.getResult();
-    } catch {
-      return true;
-    }
+    if (!inst.emaPre.open.isStable || !inst.emaPre.high.isStable ||
+        !inst.emaPre.low.isStable || !inst.emaPre.close.isStable) return;
+    sOpen = inst.emaPre.open.getResult();
+    sHigh = inst.emaPre.high.getResult();
+    sLow = inst.emaPre.low.getResult();
+    sClose = inst.emaPre.close.getResult();
   } else {
     sOpen = open;
     sHigh = high;
@@ -117,7 +105,7 @@ export const heikenAshi = (
     isBadNumber(sLow) ||
     isBadNumber(sClose)
   ) {
-    return true;
+    return;
   }
 
   // ---- HEIKEN ASHI CORE ----
@@ -145,14 +133,12 @@ export const heikenAshi = (
     inst.emaPost.low.update(haLow);
     inst.emaPost.close.update(haClose);
 
-    try {
-      smOpen = inst.emaPost.open.getResult();
-      smHigh = inst.emaPost.high.getResult();
-      smLow = inst.emaPost.low.getResult();
-      smClose = inst.emaPost.close.getResult();
-    } catch {
-      return true;
-    }
+    if (!inst.emaPost.open.isStable || !inst.emaPost.high.isStable ||
+        !inst.emaPost.low.isStable || !inst.emaPost.close.isStable) return;
+    smOpen = inst.emaPost.open.getResult();
+    smHigh = inst.emaPost.high.getResult();
+    smLow = inst.emaPost.low.getResult();
+    smClose = inst.emaPost.close.getResult();
   } else {
     smOpen = haOpen;
     smHigh = haHigh;
@@ -170,7 +156,7 @@ export const heikenAshi = (
     smLow <= 0 ||
     smClose <= 0
   ) {
-    return true;
+    return;
   }
 
   // ---- TREND/CROSS LOGIC ----
@@ -214,21 +200,16 @@ export const heikenAshi = (
   const bodyTop = Math.max(smOpen, smClose);
   const bodyBottom = Math.min(smOpen, smClose);
 
-  const row = {
-    [getKey('body')]: getRet(smClose, smOpen),
-    [getKey('upper_wick')]: getRet(smHigh, bodyTop),
-    [getKey('lower_wick')]: getRet(bodyBottom, smLow),
-    [getKey('range')]: getRet(smHigh, smLow),
-  };
+  const body = getRet(smClose, smOpen);
+  const upperWick = getRet(smHigh, bodyTop);
+  const lowerWick = getRet(bodyBottom, smLow);
+  const range = getRet(smHigh, smLow);
 
-  for (const [key, value] of Object.entries(row)) {
-    if (!isBadNumber(value)) {
-      main.pushToMain({ index, key, value });
-    }
-  }
+  if (!isBadNumber(body)) main.pushToMain({ index, key: getKey('body'), value: body });
+  if (!isBadNumber(upperWick)) main.pushToMain({ index, key: getKey('upper_wick'), value: upperWick });
+  if (!isBadNumber(lowerWick)) main.pushToMain({ index, key: getKey('lower_wick'), value: lowerWick });
+  if (!isBadNumber(range)) main.pushToMain({ index, key: getKey('range'), value: range });
 
   // Do not add return logs to cross.
   main.pushToMain({ index, key: crossKey, value: cross });
-
-  return true;
-};
+};

package/src/moving-averages/macd.js

@@ -1,14 +1,18 @@
-import { FasterEMA, FasterMACD } from 'trading-signals'
+import { FasterEMA, FasterMACD } from '../core-indicators/index.js'
+import { validateInputValues } from '../utilities/validators.js'
+import { initializeColumns } from '../core-functions/initializeColumns.js'
 
 const defaultTarget = 'close'
 
 export const macd = (main, index, fast, slow, signal, { target, lag, precomputed }) => {
-  const { verticalOhlcv, instances, priceBased, useFullNames } = main
+  const { verticalOhlcv, instances, useFullNames } = main
   const { instanceKey } = precomputed
 
   // Initialization on the first index.
   if (index === 0) {
-    const { inputParams, len } = main
+    validateInputValues({ [target]: true }, verticalOhlcv, index, 'macd')
+
+    const { inputParams } = main
 
     if (!verticalOhlcv.hasOwnProperty(target)) {
       throw new Error(`Target property ${target} not found in verticalOhlcv for macd.`)
@@ -53,21 +57,8 @@ export const macd = (main, index, fast, slow, signal, { target, lag, precomputed
       new FasterEMA(signal)
     )
 
-    Object.assign(verticalOhlcv, {
-      [diffKey]: new Float64Array(len).fill(NaN),
-      [deaKey]: new Float64Array(len).fill(NaN),
-      [histogramKey]: new Float64Array(len).fill(NaN),
-    })
-
     const keyNames = [diffKey, deaKey, histogramKey]
-
-    for (const k of keyNames) {
-      priceBased.add(k)
-    }
-
-    if (lag > 0) {
-      main.lag(keyNames, lag)
-    }
+    initializeColumns(main, keyNames.map(key => ({ key, priceBased: true })), { lag })
   }
 
   const { numberOfIndicators, settings } = instances.macd
@@ -94,17 +85,10 @@ export const macd = (main, index, fast, slow, signal, { target, lag, precomputed
   const value = verticalOhlcv[target][index]
   macdInstance.update(value)
 
-  let macdResult = {}
-  try {
-    macdResult = macdInstance.getResult()
-  } catch (err) {
-    // If the result is unavailable, macdResult remains NaN.
-  }
+  const macdResult = macdInstance.isStable ? macdInstance.getResult() : 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,20 +1,22 @@
 
-import {FasterEMA, FasterSMA} from 'trading-signals';
+import {FasterEMA, FasterSMA} from '../core-indicators/index.js';
+import { validateInputValues } from '../utilities/validators.js';
+import { initializeColumns } from '../core-functions/initializeColumns.js';
+import { mathLog } from '../utilities/math.js';
 
 const indicatorClasses = {
   ema: FasterEMA, 
   sma: FasterSMA
 }
 
-export const movingAverages = (main, index, methodName, size, { target, lag }) => {
+export const movingAverages = (main, index, methodName, size, { target, lag, retLogs = false }) => {
 
   const { verticalOhlcv, instances, priceBased } = main
   const suffix = (target !== 'close') ?  `_${target}` : ''
-  const keyName = `${methodName}_${size}${suffix}`
+  const keyName = `${retLogs ? 'ret_log_' : ''}${methodName}_${size}${suffix}`
 
   if (index === 0) {
-
-    const {len} = main
+    validateInputValues({ [target]: true }, verticalOhlcv, index, methodName)
 
     if (!verticalOhlcv.hasOwnProperty(target)) {
       throw new Error(
@@ -25,16 +27,7 @@ export const movingAverages = (main, index, methodName, size, { target, lag }) =
     // Create the main moving average instance.
     instances[keyName] = new indicatorClasses[methodName](size)
 
-    verticalOhlcv[keyName] = new Float64Array(len).fill(NaN)
-
-    if(priceBased.has(target)){
-      priceBased.add(keyName)
-    }
-
-    if(lag > 0)
-    {
-      main.lag([keyName], lag)
-    }
+    initializeColumns(main, [{ key: keyName, priceBased: !retLogs && priceBased.has(target) }], { lag })
   }
 
   // Retrieve the current price value
@@ -44,16 +37,17 @@ export const movingAverages = (main, index, methodName, size, { target, lag }) =
   // Update the moving average instance.
   instance.update(value)
 
-  let currMa = NaN
-
-  try {
-    currMa = instance.getResult()
-  } catch (err) {
+  const currMa = instance.isStable ? instance.getResult() : NaN
 
+  let output = currMa
+  if (retLogs) {
+    const ratio = value / currMa
+    // Log-relative distance is defined only for finite, positive ratios and operands.
+    output = value > 0 && currMa > 0 && ratio > 0 && Number.isFinite(ratio)
+      ? mathLog(ratio, 1)
+      : NaN
   }
 
-  // Always push the MA value (even if NaN).
-  main.pushToMain({ index, key: keyName, value: currMa })
-
-  return true
-}
+  // Always push the selected value (even if NaN).
+  main.pushToMain({ index, key: keyName, value: output })
+}

package/src/moving-averages/relativeVolume.js

@@ -1,48 +1,54 @@
-import { FasterSMA } from 'trading-signals';
+import { FasterSMA } 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 relativeVolume = (main, index, size, {lag}) => {
 
-  const key = `relative_volume_${size}`;
+export const relativeVolume = (main, index, size, {lag, retLogs = false}) => {
+
+  const key = `${retLogs ? 'ret_log_' : ''}relative_volume_${size}`;
   const { instances, verticalOhlcv } = main;
+  
 
   if (index === 0) {
-    const { len } = main;
+    validateInputValues({ volume: true }, verticalOhlcv, index, 'relativeVolume');
 
     instances[key] = {
       instance: new FasterSMA(size),
       prevRelativeVolumeSma: NaN
     };
     
-    verticalOhlcv[key] = new Float64Array(len).fill(NaN);
-
-    if(lag > 0)
-    {
-      main.lag([key], lag)
-    }
+    initializeColumns(main, [{ key }], { lag });
 
   }
 
-  const value = verticalOhlcv.volume[index];
-  const smaInstance = instances[key].instance;
-  smaInstance.update(value);
-
-  let smaValue = NaN;
-  try {
-    smaValue = smaInstance.getResult();
-  } catch (err) {
+  const volume = verticalOhlcv.volume[index];
 
+  if(volume === 0) {
+    return;
   }
+  
+  const smaInstance = instances[key].instance;
+  smaInstance.update(volume);
+
+  const smaValue = smaInstance.isStable ? smaInstance.getResult() : NaN;
 
   const prevSma = instances[key].prevRelativeVolumeSma;
-  let currRelativeVolume = NaN;
 
-  // Only calculate relative volume if both current SMA and previous SMA are valid numbers and prevSma is not zero.
-  if (!Number.isNaN(smaValue) && !Number.isNaN(prevSma)) {
-    currRelativeVolume = value / prevSma;
+  // Save the current SMA for the next nonzero-volume row.
+  instances[key].prevRelativeVolumeSma = smaValue;
+
+  if(Number.isNaN(smaValue) || Number.isNaN(prevSma)) {
+    return
   }
 
+  const ratio = volume / prevSma;
+  const currRelativeVolume = retLogs
+    ? volume > 0 && prevSma > 0 && ratio > 0 && Number.isFinite(ratio)
+      ? mathLog(ratio, 1)
+      : NaN
+    : ratio;
+
   main.pushToMain({ index, key, value: currRelativeVolume });
-  instances[key].prevRelativeVolumeSma = smaValue;
 
-  return true;
 };

package/src/oscillators/mfi.js

@@ -0,0 +1,56 @@
+import { mathLog } from '../utilities/math.js';
+import { validateInputValues } from '../utilities/validators.js';
+import { initializeColumns } from '../core-functions/initializeColumns.js';
+
+export const mfi = (main, index, size, { lag, retLogs }) => {
+    const { verticalOhlcv, instances } = main;
+    const key = `${retLogs ? 'ret_log_' : ''}mfi_${size}`;
+
+    if (index === 0) {
+        validateInputValues({ high: true, low: true, close: true, volume: true }, verticalOhlcv, index, 'mfi');
+        // Raw and logged variants own separate state, even at the same period.
+        initializeColumns(main, [{ key }], { lag });
+        instances[key] = {
+            flows: new Float64Array(size),
+            next: 0,
+            count: 0,
+            previousTypical: NaN
+        };
+    }
+
+    const state = instances[key];
+    const typical = (verticalOhlcv.high[index] + verticalOhlcv.low[index] + verticalOhlcv.close[index]) / 3;
+    const change = typical - state.previousTypical;
+    state.previousTypical = typical;
+
+    // The first candle seeds the comparison; a size-period MFI needs size + 1 rows.
+    if (index === 0) return;
+
+    const flow = typical * verticalOhlcv.volume[index];
+    // A tie is neutral, but an invalid comparison must not silently become zero.
+    // Zero-volume candles contribute zero and still advance the candle window.
+    state.flows[state.next] = Number.isFinite(change) && Number.isFinite(flow) && flow >= 0
+        ? Math.sign(change) * flow : NaN;
+    state.next = (state.next + 1) % size;
+    if (state.count < size) state.count++;
+    if (state.count < size) return;
+
+    // Sum oldest to newest: bounded storage, no accumulated subtraction drift,
+    // and invalid values recover naturally after leaving the window.
+    let positive = 0;
+    let negative = 0;
+    let slot = state.next;
+    for (let step = 0; step < size; step++) {
+        const value = state.flows[slot];
+        if (Number.isNaN(value)) return;
+        if (value > 0) positive += value;
+        else if (value < 0) negative -= value;
+        if (++slot === size) slot = 0;
+    }
+
+    if (!Number.isFinite(positive) || !Number.isFinite(negative)) return;
+    // No directional money flow gives an undefined ratio, not a neutral signal.
+    const value = positive === 0 && negative === 0
+        ? NaN : 100 - 100 / (1 + positive / negative);
+    main.pushToMain({ index, key, value: Number.isNaN(value) ? NaN : retLogs ? mathLog(value, 50) : value });
+};

package/src/oscillators/rsi.js

@@ -1,6 +1,7 @@
-import { FasterRSI } from 'trading-signals';
-import { FasterSMA } from 'trading-signals';
+import { FasterRSI, FasterSMA } from '../core-indicators/index.js';
 import { mathLog } from '../utilities/math.js';
+import { validateInputValues } from '../utilities/validators.js';
+import { initializeColumns } from '../core-functions/initializeColumns.js';
 
 const defaultTarget = 'close'
 export const rsi = (main, index, size, { target, lag, retLogs }) => {
@@ -15,8 +16,7 @@ export const rsi = (main, index, size, { target, lag, retLogs }) => {
 
   // Initialization on the first index.
   if (index === 0) {
-
-    const {len } = main;
+    validateInputValues({ [target]: true }, verticalOhlcv, index, 'rsi');
 
     if (!verticalOhlcv.hasOwnProperty(target)) {
       throw new Error(`Target property ${target} not found in verticalOhlcv for rsi.`);
@@ -27,32 +27,17 @@ export const rsi = (main, index, size, { target, lag, retLogs }) => {
       [rsiSmaKey]: new FasterSMA(size)
     })
 
-    Object.assign(verticalOhlcv, {
-      [rsiKey]: new Float64Array(len).fill(NaN),
-      [rsiSmaKey]: new Float64Array(len).fill(NaN),
-    })
-
-    const baseKeys = [rsiKey, rsiSmaKey]
-
-    if (lag > 0) {
-      main.lag(baseKeys, lag);
-    }
+    initializeColumns(main, [{ key: rsiKey }, { key: rsiSmaKey }], { lag });
 
 
   }
 
   const value = verticalOhlcv[target][index];
-  let currentRsi = NaN;
-  let smoothedRsi = NaN;
 
   // Update the RSI indicator.
   instances[rsiKey].update(value);
 
-  try {
-    currentRsi = instances[rsiKey].getResult();
-  } catch (err) {
-    currentRsi = NaN;
-  }
+  const currentRsi = instances[rsiKey].isStable ? instances[rsiKey].getResult() : NaN;
 
 
     const rsiVal = Number.isNaN(currentRsi) ? NaN : (retLogs ? mathLog(currentRsi, 50) : currentRsi)
@@ -63,11 +48,7 @@ export const rsi = (main, index, size, { target, lag, retLogs }) => {
       instances[rsiSmaKey].update(currentRsi);
     }
 
-    try {
-      smoothedRsi = instances[rsiSmaKey].getResult();
-    } catch (err) {
-      smoothedRsi = NaN;
-    }
+    const smoothedRsi = instances[rsiSmaKey].isStable ? instances[rsiSmaKey].getResult() : NaN;
 
     const smoothedRsiVal = Number.isNaN(smoothedRsi) ? NaN : (retLogs ? mathLog(smoothedRsi, 50) : smoothedRsi)