ohlcv-indicators 3.5.68 → 3.5.69

package/index.js

@@ -17,8 +17,6 @@ import { dateOutputFormaters } from './src/utilities/dateUtilities.js'
 import { defaultMapColsCallback } from './src/studies/mapCols.js'
 import { calcPrecisionMultiplier } from './src/utilities/precisionMultiplier.js'
 
-import { normalizeMinMax } from './src/machine-learning/ml-utilities.js'
-
 /**
  * Class OHLCV_INDICATORS
  *
@@ -28,13 +26,14 @@ import { normalizeMinMax } from './src/machine-learning/ml-utilities.js'
  */
 
 export default class OHLCV_INDICATORS {
-    constructor({input, ticker = null, inputParams = null, chunkProcess = 2000, precision = false}) {
+    constructor({input, ticker = null, inputParams = null, chunkProcess = 2000, precision = false, useFullNames = false}) {
 
         validateArray(input, 'input', (ticker !== null) ? `contructor ${ticker}` : 'constuctor')
         if(input.length === 0) throw Error('input OHLCV must not be empty: ' + ticker)
 
         validateNumber(chunkProcess, {min: 100, max: 50000, allowDecimals: false}, 'chunkProcess', 'constructor')
         validateBoolean(precision, 'precision', 'contructor')
+        validateBoolean(precision, 'useFullNames', 'contructor')
 
         this.chunkProcess = chunkProcess
         
@@ -42,6 +41,7 @@ export default class OHLCV_INDICATORS {
         this.len = this.input.length
         this.firstRow = this.input[0]
         this.precision = precision
+        this.useFullNames = useFullNames
 
         const initialPriceBasedArr = ['open', 'high', 'low', 'close', 'mid_price']
         this.initialPriceBased = new Set(initialPriceBasedArr)
@@ -410,14 +410,11 @@ export default class OHLCV_INDICATORS {
         validateNumber(stdDev, {min: 0.01, max: 50, allowDecimals: true}, 'stdDev', methodName)
         validateObject(options, 'options', methodName)
 
-        const {target = 'close', height = false, range = [],  lag = 0} = options
+        const { lag = 0} = options
 
-        validateString(target, 'options.target', methodName)
-        validateArray(range, 'options.range', methodName)
         validateNumber(lag, {min: 0, max: this.len, allowDecimals: false}, 'options.lag', methodName)
-        validateBoolean(height, 'options.height', methodName)
   
-        this.inputParams.push({key: methodName, params: [size, stdDev, {target, height, range, lag}]});
+        this.inputParams.push({key: methodName, params: [size, stdDev, {lag}]});
     
         return this;
     }
@@ -450,13 +447,11 @@ export default class OHLCV_INDICATORS {
         validateNumber(offset, {min: 0, max: this.len, allowDecimals: false}, 'offset', methodName)
       
         validateObject(options, 'options', methodName)
-        const { height = false, range = [], lag = 0} = options;
+        const {  lag = 0} = options;
       
-        validateArray(range, 'options.range', methodName)
         validateNumber(lag, {min: 0, max: this.len, allowDecimals: false}, 'options.lag', methodName)
-        validateBoolean(height, 'options.height', methodName)
       
-        this.inputParams.push({ key: methodName, order: 0, params: [size, offset, { height, range, lag}] });
+        this.inputParams.push({ key: methodName, order: 0, params: [size, offset, {lag}] });
       
         return this;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ohlcv-indicators",
-  "version": "3.5.68",
+  "version": "3.5.69",
   "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/bollingerBands.js

@@ -1,126 +1,80 @@
 import { FasterBollingerBands } from 'trading-signals'
-const defaultTarget = 'close'
 
-export const bollingerBands = (main, index, size, stdDev, { height, range = [], target, lag }) => {
-
-  const { verticalOhlcv, instances } = main;
-  const indicatorKey = `${size}_${stdDev}`;
+export const bollingerBands = (main, index, size, stdDev, { lag } = {}) => {
+  const { verticalOhlcv, instances, useFullNames } = main
+  const indicatorKey = `${size}_${stdDev}`
   const prefix = 'bollinger_bands'
+  const target = 'close'
 
   // Initialization on the first call.
   if (index === 0) {
-
-    const {inputParams, verticalOhlcv, len, priceBased } = main;
+    const { inputParams, verticalOhlcv, len, priceBased } = main
 
     if (!(target in verticalOhlcv)) {
-      throw new Error(`bollingerBands could not find target "${target}"`);
+      throw new Error(`bollingerBands could not find target "${target}"`)
     }
 
     let numberOfIndicators = 0
 
     for (const o of inputParams) {
-      if (o.key === 'bollingerBands') numberOfIndicators++;
+      if (o.key === 'bollingerBands') numberOfIndicators++
     }
 
-    // Only create the container if it doesn't already exist.
     if (!instances.bollinger_bands) {
       instances.bollinger_bands = {
         numberOfIndicators,
         settings: {}
-      };
+      }
     }
-    // Add (or override) the indicator instance keyed by indicatorKey.
-    instances.bollinger_bands.settings[indicatorKey] = new FasterBollingerBands(size, stdDev);
-
-    let suffix = ''
-    if((numberOfIndicators > 1)) suffix += `_${indicatorKey}`
-    if(target !== defaultTarget) suffix += `_${target}`
-
-    const keyNames = [
-      `${prefix}_upper`,
-      `${prefix}_middle`,
-      `${prefix}_lower`,
-    ].map(v => `${v}${suffix}`)
 
+    instances.bollinger_bands.settings[indicatorKey] = new FasterBollingerBands(size, stdDev)
 
-    if (height) {
-      keyNames.push(
-        `${prefix}_height${suffix}`
-      )
-    }
+    const suffix = (numberOfIndicators > 1 || useFullNames) ? `_${indicatorKey}` : ''
 
-    // Set up additional arrays for each range property.
-    for (const rangeKey of range) {
-      if (!(rangeKey in verticalOhlcv)) {
-        throw new Error(`Invalid range item value "${rangeKey}" property for bollingerBands.`);
-      }
-      keyNames.push(`${prefix}_range_${rangeKey}${suffix}`)
-
-    }
+    const keyNames = [
+      `${prefix}_upper${suffix}`,
+      `${prefix}_middle${suffix}`,
+      `${prefix}_lower${suffix}`,
+    ]
 
-    if(priceBased.has(target)) {
-      for(const k of keyNames) {
+    if (priceBased.has(target)) {
+      for (const k of keyNames) {
         priceBased.add(k)
       }
     }
 
+    const verticalOhlcvSetup = Object.fromEntries(
+      keyNames.map(v => [v, new Float64Array(len).fill(NaN)])
+    )
 
-    const verticalOhlcvSetup = Object.fromEntries(keyNames.map(v => [v, new Float64Array(len).fill(NaN)]))
-    Object.assign(verticalOhlcv, {...verticalOhlcvSetup})
+    Object.assign(verticalOhlcv, { ...verticalOhlcvSetup })
 
-    if(lag > 0)
-    {
+    if (lag > 0) {
       main.lag(keyNames, lag)
     }
   }
 
-  const {numberOfIndicators} = instances.bollinger_bands
+  const { numberOfIndicators } = instances.bollinger_bands
+  const suffix = (numberOfIndicators > 1 || useFullNames) ? `_${indicatorKey}` : ''
 
-  let suffix = ''
-  if((numberOfIndicators > 1)) suffix += `_${indicatorKey}`
-  if(target !== defaultTarget) suffix += `_${target}`
-  
-  // Update the indicator with the current value.
   const instance = instances.bollinger_bands.settings[indicatorKey]
   const value = verticalOhlcv[target][index]
   instance.update(value)
 
-  // Attempt to retrieve the result.
-  let result = {};
+  let result = {}
   try {
-    result = instance.getResult();
+    result = instance.getResult()
   } catch (err) {
     // If not available, result stays {}.
   }
 
-  // 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: `${prefix}_upper${suffix}`, value: upper });
-  main.pushToMain({ index, key: `${prefix}_middle${suffix}`, value: middle });
-  main.pushToMain({ index, key: `${prefix}_lower${suffix}`, value: lower });
-
-  // Process height if requested.
-  if (height) {
-    let heightValue = NaN;
-    if (!Number.isNaN(lower) && !Number.isNaN(upper)) {
-      heightValue = ((upper - lower) / lower)
-    }
-    main.pushToMain({ index, key: `${prefix}_height${suffix}`, value: heightValue });
-  }
+  const upper = result?.upper ?? NaN
+  const middle = result?.middle ?? NaN
+  const lower = result?.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(lower) && !Number.isNaN(upper)) {
-      rangeValue = (priceValue - lower) / (upper - lower)
-    }
-    main.pushToMain({ index, key: `${prefix}_range_${rangeKey}${suffix}`, value: rangeValue });
-  }
+  main.pushToMain({ index, key: `${prefix}_upper${suffix}`, value: upper })
+  main.pushToMain({ index, key: `${prefix}_middle${suffix}`, value: middle })
+  main.pushToMain({ index, key: `${prefix}_lower${suffix}`, value: lower })
 
-  return true;
-}
+  return true
+}

package/src/moving-averages/donchianChannel.js

@@ -1,120 +1,82 @@
-
 export const donchianChannels = (main, index, size, offset, options) => {
-
-  
-
-  const {verticalOhlcv, instances, len, inputParams, lag, priceBased} = main
-  const { height: includeHeight, range: rangeKeys } = options
+  const { verticalOhlcv, instances, len, inputParams, priceBased, useFullNames } = main
+  const { lag: outputLag = 0 } = options
   const indicatorKey = `${size}_${offset}`
 
   // ---- INIT (only at first bar) ----
   if (index === 0) {
-    // 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)) {
-        throw new Error(
-          `Invalid range key "${rk}".`
-        );
-      }
-      keys.push(`${prefix}_range_${rk}`);
-    }
+    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}`
 
-    for(const k of keys) {
+    const keys = ['upper', 'basis', 'lower'].map(getKey)
+
+    for (const k of keys) {
       priceBased.add(k)
     }
 
-    // bootstrap instance
     if (!instances.donchian_channel) {
-      instances.donchian_channel = { numberOfIndicators, settings: {} };
+      instances.donchian_channel = { numberOfIndicators, settings: {} }
     }
-    instances.donchian_channel.numberOfIndicators = numberOfIndicators;
-    instances.donchian_channel.settings[indicatorKey] = { maxDeque: [], minDeque: [] };
 
-    // allocate & fill NaNs
+    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)]))
-    );
+    )
 
-    // apply lag if requested
-    if (lag > 0) main.lag(keys, lag)
+    if (outputLag > 0) {
+      main.lag(keys, outputLag)
+    }
   }
 
   // ---- PER-BAR COMPUTATION ----
-  const { numberOfIndicators, settings } = instances.donchian_channel;
-  const prefix = numberOfIndicators > 1
-    ? `donchian_channel_${indicatorKey}`
-    : 'donchian_channel';
+  const { numberOfIndicators, settings } = instances.donchian_channel
+  const useIndexedKeys = numberOfIndicators > 1 || useFullNames
 
-  const { maxDeque, minDeque } = settings[indicatorKey];
-  const current = index - offset;
-  const start   = current - size + 1;
+  const getKey = name =>
+    useIndexedKeys
+      ? `donchian_channel_${name}_${indicatorKey}`
+      : `donchian_channel_${name}`
 
-  // 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}`);
+  const { maxDeque, minDeque } = settings[indicatorKey]
+  const current = index - offset
+  const start = current - size + 1
+
+  const outKeys = ['upper', 'basis', 'lower'].map(getKey)
 
-  // not enough data → push NaNs
   if (start < 0 || current + 1 > len) {
-    [...outKeys, ...rangeOut].forEach(key =>
+    outKeys.forEach(key =>
       main.pushToMain({ index, key, value: NaN })
-    );
-    return true;
+    )
+    return true
   }
 
-  const { high: highs, low: lows } = verticalOhlcv;
+  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 });
+    while (dq.length && dq[0] < start) dq.shift()
+    while (dq.length && cmp(arr[dq.at(-1)], arr[current])) dq.pop()
+    dq.push(current)
   }
 
-  // precompute spread once
-  const spread = hasBounds ? (upper - lower) : NaN;
+  update(maxDeque, highs, (a, b) => a <= b)
+  update(minDeque, lows, (a, b) => a >= b)
 
-  // for each extra range key, use price===price to skip NaNs
+  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
 
-  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 });
-  }
+  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;
-};
+  return true
+}

package/src/moving-averages/heikenAshi.js

@@ -2,14 +2,25 @@ import { FasterEMA } from 'trading-signals';
 
 export const heikenAshi = (main, index, smoothLength, afterSmoothLength, { lag = 0, bothNull = false } = {}) => {
   const { verticalOhlcv, instances, len, priceBased } = main;
-  const prefix = (bothNull) ?  'heiken_ashi' : `heiken_ashi_${smoothLength}_${afterSmoothLength}`;
+  const indicatorKey = `${smoothLength}_${afterSmoothLength}`;
   const keys = ['open', 'high', 'low', 'close'];
 
+  const getKey = key =>
+    bothNull
+      ? `heiken_ashi_${key}`
+      : `heiken_ashi_${key}_${indicatorKey}`;
+
+  const crossKey = bothNull
+    ? 'heiken_ashi_cross'
+    : `heiken_ashi_cross_${indicatorKey}`;
+
+  const instanceKey = bothNull
+    ? 'heiken_ashi'
+    : `heiken_ashi_${indicatorKey}`;
+
   // ---- INIT ----
   if (index === 0) {
-    // Initialize state
-    instances[prefix] = {
-      // Only allocate EMAs when smoothing is requested
+    instances[instanceKey] = {
       emaPre: !bothNull
         ? Object.fromEntries(keys.map(k => [k, new FasterEMA(smoothLength)]))
         : null,
@@ -21,13 +32,13 @@ export const heikenAshi = (main, index, smoothLength, afterSmoothLength, { lag =
       isTrendUp: false,
     };
 
-    const keyNames = keys.map(k => `${prefix}_${k}`);
+    const keyNames = keys.map(getKey);
     const verticalOhlcvSetup = Object.fromEntries(
-      [...keyNames, `${prefix}_cross`].map(v => [v, new Float64Array(len).fill(NaN)])
+      [...keyNames, crossKey].map(v => [v, new Float64Array(len).fill(NaN)])
     );
 
-    for(const k of keyNames) {
-      priceBased.add(k)
+    for (const k of keyNames) {
+      priceBased.add(k);
     }
 
     Object.assign(verticalOhlcv, { ...verticalOhlcvSetup });
@@ -42,7 +53,7 @@ export const heikenAshi = (main, index, smoothLength, afterSmoothLength, { lag =
   const high = verticalOhlcv.high[index];
   const low = verticalOhlcv.low[index];
   const close = verticalOhlcv.close[index];
-  const inst = instances[prefix];
+  const inst = instances[instanceKey];
 
   let sOpen, sHigh, sLow, sClose;
 
@@ -59,17 +70,16 @@ export const heikenAshi = (main, index, smoothLength, afterSmoothLength, { lag =
       sLow = inst.emaPre.low.getResult();
       sClose = inst.emaPre.close.getResult();
     } catch {
-      return true; // skip if not enough data
+      return true;
     }
   } else {
-    // No pre-smoothing: use raw OHLC
     sOpen = open;
     sHigh = high;
     sLow = low;
     sClose = close;
   }
 
-  // ---- HEIKEN ASHI CORE (from s*) ----
+  // ---- HEIKEN ASHI CORE ----
   const haClose = (sOpen + sHigh + sLow + sClose) / 4;
   const haOpen = (Number.isNaN(inst.prevHaOpen) || Number.isNaN(inst.prevHaClose))
     ? (sOpen + sClose) / 2
@@ -77,7 +87,6 @@ export const heikenAshi = (main, index, smoothLength, afterSmoothLength, { lag =
   const haHigh = Math.max(sHigh, haOpen, haClose);
   const haLow = Math.min(sLow, haOpen, haClose);
 
-  // Store for next round
   inst.prevHaOpen = haOpen;
   inst.prevHaClose = haClose;
 
@@ -96,20 +105,19 @@ export const heikenAshi = (main, index, smoothLength, afterSmoothLength, { lag =
       smLow = inst.emaPost.low.getResult();
       smClose = inst.emaPost.close.getResult();
     } catch {
-      return true; // skip if not enough data
+      return true;
     }
   } else {
-    // No post-smoothing: final values are plain HA
     smOpen = haOpen;
     smHigh = haHigh;
     smLow = haLow;
     smClose = haClose;
   }
 
-  // ---- TREND/CROSS LOGIC (works for both modes) ----
-  const prevCross = index > 0 ? verticalOhlcv[`${prefix}_cross`][index - 1] : 0;
-  const prevHaOpenArr = index > 0 ? verticalOhlcv[`${prefix}_open`][index - 1] : NaN;
-  const prevHaCloseArr = index > 0 ? verticalOhlcv[`${prefix}_close`][index - 1] : NaN;
+  // ---- TREND/CROSS LOGIC ----
+  const prevCross = index > 0 ? verticalOhlcv[crossKey][index - 1] : 0;
+  const prevHaOpenArr = index > 0 ? verticalOhlcv[getKey('open')][index - 1] : NaN;
+  const prevHaCloseArr = index > 0 ? verticalOhlcv[getKey('close')][index - 1] : NaN;
 
   const crossUp = !Number.isNaN(prevHaCloseArr) && prevHaCloseArr <= prevHaOpenArr && smClose > smOpen;
   const crossDown = !Number.isNaN(prevHaCloseArr) && prevHaCloseArr >= prevHaOpenArr && smClose < smOpen;
@@ -127,11 +135,11 @@ export const heikenAshi = (main, index, smoothLength, afterSmoothLength, { lag =
   }
 
   // ---- PUSH OUTPUTS ----
-  main.pushToMain({ index, key: `${prefix}_open`, value: smOpen });
-  main.pushToMain({ index, key: `${prefix}_high`, value: smHigh });
-  main.pushToMain({ index, key: `${prefix}_low`, value: smLow });
-  main.pushToMain({ index, key: `${prefix}_close`, value: smClose });
-  main.pushToMain({ index, key: `${prefix}_cross`, value: cross });
+  main.pushToMain({ index, key: getKey('open'), value: smOpen });
+  main.pushToMain({ index, key: getKey('high'), value: smHigh });
+  main.pushToMain({ index, key: getKey('low'), value: smLow });
+  main.pushToMain({ index, key: getKey('close'), value: smClose });
+  main.pushToMain({ index, key: crossKey, value: cross });
 
   return true;
-};
+};

package/src/moving-averages/macd.js

@@ -1,13 +1,10 @@
-import { FasterEMA, FasterMACD } from 'trading-signals';
+import { FasterEMA, FasterMACD } from 'trading-signals'
 
-const defaultTarget = 'close';
+const defaultTarget = 'close'
 
-export const macd = (main, index, fast, slow, signal, {target, lag, precomputed}) => {
-
-  
-
-  const { verticalOhlcv, instances, priceBased } = main
-  const {instanceKey} = precomputed
+export const macd = (main, index, fast, slow, signal, { target, lag, precomputed }) => {
+  const { verticalOhlcv, instances, priceBased, useFullNames } = main
+  const { instanceKey } = precomputed
 
   // Initialization on the first index.
   if (index === 0) {
@@ -23,13 +20,25 @@ export const macd = (main, index, fast, slow, signal, {target, lag, precomputed}
       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 useIndexedKeys = numberOfIndicators > 1 || useFullNames
+    const indicatorSuffix = `${fast}_${slow}_${signal}`
+
+    const getKey = name => {
+      if (target === defaultTarget) {
+        return useIndexedKeys
+          ? `macd_${name}_${indicatorSuffix}`
+          : `macd_${name}`
+      }
+
+      return useIndexedKeys
+        ? `macd_${name}_${target}_${indicatorSuffix}`
+        : `macd_${name}_${target}`
+    }
 
     // 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 = getKey('diff')
+    const deaKey = getKey('dea')
+    const histogramKey = getKey('histogram')
 
     if (!instances.hasOwnProperty('macd')) {
       instances.macd = {
@@ -52,22 +61,34 @@ export const macd = (main, index, fast, slow, signal, {target, lag, precomputed}
 
     const keyNames = [diffKey, deaKey, histogramKey]
 
-    for(const k of keyNames) {
+    for (const k of keyNames) {
       priceBased.add(k)
     }
 
-    if(lag > 0)
-    {
+    if (lag > 0) {
       main.lag(keyNames, 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 useIndexedKeys = numberOfIndicators > 1 || useFullNames
+  const indicatorSuffix = `${fast}_${slow}_${signal}`
+
+  const getKey = name => {
+    if (target === defaultTarget) {
+      return useIndexedKeys
+        ? `macd_${name}_${indicatorSuffix}`
+        : `macd_${name}`
+    }
+
+    return useIndexedKeys
+      ? `macd_${name}_${target}_${indicatorSuffix}`
+      : `macd_${name}_${target}`
+  }
+
+  const diffKey = getKey('diff')
+  const deaKey = getKey('dea')
+  const histogramKey = getKey('histogram')
 
   const macdInstance = settings[instanceKey]
   const value = verticalOhlcv[target][index]
@@ -86,4 +107,4 @@ export const macd = (main, index, fast, slow, signal, {target, lag, precomputed}
   main.pushToMain({ index, key: histogramKey, value: macdResult ? macdResult.histogram : NaN })
 
   return true
-};
+}

package/src/oscillators/stochastic.js

@@ -4,11 +4,11 @@ export const stochastic = (main, index, kPeriod, kSlowingPeriod, dPeriod, {lag})
 
     
 
-    const { verticalOhlcv, instances } = main;
+    const { verticalOhlcv, instances , useFullNames} = main;
 
-    const paramsKey = `${kPeriod}_${kSlowingPeriod}_${dPeriod}`
-    const stochD = `stoch_d_${paramsKey}`;
-    const stochK = `stoch_k_${paramsKey}`;
+    const paramsKey = ((kPeriod === 14 && kSlowingPeriod === 3 && dPeriod === 3) && !useFullNames) ? '' : `_${kPeriod}_${kSlowingPeriod}_${dPeriod}`
+    const stochD = `stoch_d${paramsKey}`;
+    const stochK = `stoch_k${paramsKey}`;
     const instanceKey = paramsKey
 
   // Initialization on the first index.