ohlcv-indicators 1.9.2 → 1.9.4

package/src/moving-averages/bollingerBands.js

@@ -1,99 +1,73 @@
-
 import {FasterBollingerBands, FasterSMA} from 'trading-signals';
 import { classifySize } from '../utilities/classification.js';
 
-export const bollingerBands = (main, size, times, bollingerBandsStudies) => {
-
-  const {verticalOhlcv} = main
-  const {close} = verticalOhlcv
+export const bollingerBands = (main, index, size, times, bollingerBandsStudies = false) => {
 
-  const col = getBollingerBands(close, size, times, bollingerBandsStudies)
-  return col
-}
+    const value = main.verticalOhlcv.close[index]
 
-export const getBollingerBands = (data, size = 20, times = 2, bollingerBandsStudies = false) => {
-  
-  const dataLength = data.length
-  const bollinger_bands_upper =  Array(dataLength).fill(null)
-  const bollinger_bands_middle =  Array(dataLength).fill(null)
-  const bollinger_bands_lower =  Array(dataLength).fill(null)
+    if (!main.instances.hasOwnProperty(`bollinger_bands`)) {
 
+        Object.assign(main.instances, {bollinger_bands: {
+            instance: new FasterBollingerBands(size, times),
+            heightInstance: bollingerBandsStudies ? new FasterSMA(size) : null
+        }})
 
-  let bollinger_bands_range
-  let bollinger_bands_height
-  let heightInstance
-  let range = null
-  let height = null
 
-  if(bollingerBandsStudies)
-  {
-    bollinger_bands_range =  Array(dataLength).fill(null)
-    bollinger_bands_height =  Array(dataLength).fill(null)
-    heightInstance = new FasterSMA(size)
-  }
+        Object.assign(main.verticalOhlcv, {
+            bollinger_bands_upper: new Array(main.len).fill(null),
+            bollinger_bands_middle: new Array(main.len).fill(null),
+            bollinger_bands_lower: new Array(main.len).fill(null)
+        })
 
-  let getRange = (value, upper, lower) => ({
-    range: ((value - lower) / (upper - lower)),
-    height: upper-lower
-  })
+        if (bollingerBandsStudies) {
 
-  let instance = new FasterBollingerBands(size, times)
-
-  
-  for (let x = 0; x < dataLength; x++) {
-    let obj = {};
-    instance.update(data[x])
-    let hasNull = false
-    let heightMean
+            Object.assign(main.verticalOhlcv, {
+                bollinger_bands_range: new Array(main.len).fill(null),
+                bollinger_bands_height: new Array(main.len).fill(null),
+            })
+        }
+    }
 
+    const { instance, heightInstance } = main.instances[`bollinger_bands`];
+    instance.update(value);
 
+    let result;
     try {
-      obj = instance.getResult()
+        result = instance.getResult();
     } catch (err) {
-      hasNull = true
-      obj = { upper: null, middle: null, lower: null }
+       //do nothing
     }
 
-    bollinger_bands_upper[x] = obj.upper;
-    bollinger_bands_middle[x] = obj.middle;
-    bollinger_bands_lower[x] = obj.lower;
-
-    if(bollingerBandsStudies === false) continue
-    
-    if(hasNull)
-    {
-      bollinger_bands_range[x] = null
-      bollinger_bands_height[x] = null
-    }
-    else
-    {
-      const extraProps = getRange(data[x], obj.upper, obj.lower)
-      range = extraProps.range
-      height = extraProps.height
+    if(!result) return true
 
-      heightInstance.update(height)
+    const { upper, middle, lower } = result;
+    main.verticalOhlcv.bollinger_bands_upper[index] = upper;
+    main.verticalOhlcv.bollinger_bands_middle[index] = middle;
+    main.verticalOhlcv.bollinger_bands_lower[index] = lower;
 
-      try{
-        heightMean = heightInstance.getResult()
-      }
-      catch(err)
-      {
-        heightMean = null
-      }
+    if (!bollingerBandsStudies) return true;
 
-    }
+    let range = null;
+    let height = null;
+    let heightMean;
 
-    bollinger_bands_range[x] = range
-    bollinger_bands_height[x] = classifySize(height, heightMean, 1.5)
-  }
+    range = (value - lower) / (upper - lower);
+    height = upper - lower;
 
-  let output = { bollinger_bands_upper, bollinger_bands_middle, bollinger_bands_lower }
+    heightInstance.update(height);
 
-  if(bollingerBandsStudies)
-  {
-    output = {...output, bollinger_bands_range, bollinger_bands_height}
-  }
+    try {
+        heightMean = heightInstance.getResult();
+    } catch (err) {
+        //do nothing
+    }
 
-  return output
-}
+    main.verticalOhlcv.bollinger_bands_range[index] = range;
 
+    if(heightMean)
+    {
+        main.verticalOhlcv.bollinger_bands_height[index] = classifySize(height, heightMean, 1.5);
+    }
+    
+    return true;
+};

package/src/moving-averages/donchianChannel.js

@@ -1,59 +1,50 @@
-export const donchianChannels = (main, period, offset) => {
-
-    const {verticalOhlcv, len} = main
-    const {high, low} = verticalOhlcv
-
-    return getDonchianChannels(high, low, period, offset, len)
-}
-
-export const getDonchianChannels = (high, low, period, offset, len) => {
-    const donchian_channel_upper = new Array(len).fill(null)
-    const donchian_channel_lower = new Array(len).fill(null)
-    const donchian_channel_basis = new Array(len).fill(null)
-
-    const maxQueue = []
-    const minQueue = []
-
-    const avg = ((h, l) => (h + l) / 2)
-    
-    for (let i = 0; i < len; i++) {
-
-        while (maxQueue.length && maxQueue[0] <= i - period) {
-            maxQueue.shift()
-        }
-        // Remove smaller values from the end
-        while (maxQueue.length && high[maxQueue[maxQueue.length - 1]] <= high[i]) {
-            maxQueue.pop()
-        }
-        maxQueue.push(i)
-
-        while (minQueue.length && minQueue[0] <= i - period) {
-            minQueue.shift()
-        }
-        while (minQueue.length && low[minQueue[minQueue.length - 1]] >= low[i]) {
-            minQueue.pop()
-        }
-
-        minQueue.push(i)
-
-        if (i >= period - 1) {
-            const upperValue = high[maxQueue[0]]
-            const lowerValue = low[minQueue[0]]
-            const basisValue = avg(upperValue, lowerValue)
-
-            const indexWithOffset = i + offset
-
-            if (indexWithOffset >= 0 && indexWithOffset < len) {
-                donchian_channel_upper[indexWithOffset] = upperValue
-                donchian_channel_lower[indexWithOffset] = lowerValue
-                donchian_channel_basis[indexWithOffset] = basisValue
-            }
-        }
+const avg = (h, l) => (h + l) / 2;
+
+export const donchianChannels = (main, index, size, offset) => {
+
+    const highs = main.verticalOhlcv.high;
+    const lows = main.verticalOhlcv.low;
+
+    // If we don't have enough data to fill one size ending at (index - offset), return
+    if ((index - offset) < (size - 1)) return true;
+
+    // Ensure that the required arrays exist
+    if (!main.instances.hasOwnProperty('donchian_channels')) {
+        
+        main.instances['donchian_channels'] = {};
+
+        Object.assign(main.verticalOhlcv, {
+            donchian_channel_upper: new Array(main.len).fill(null),
+            donchian_channel_basis: new Array(main.len).fill(null),
+            donchian_channel_lower: new Array(main.len).fill(null),
+        })
     }
 
-    return { 
-        donchian_channel_upper, 
-        donchian_channel_lower,
-        donchian_channel_basis 
+
+    // Compute the slice start and end to get exactly 'size' bars
+    const endIdx = (index - offset) + 1;          // inclusive end of the slice
+    const startIdx = endIdx - size;             // start index for slicing
+
+    // If any of these indices is out of bounds, return
+    if (startIdx < 0 || endIdx > main.len) return true;
+
+    // Extract the relevant chunks of data
+    const highChunk = highs.slice(startIdx, endIdx)
+    const lowChunk = lows.slice(startIdx, endIdx)
+
+    // Compute the Donchian channels
+    const upper = Math.max(...highChunk);
+    const lower = Math.min(...lowChunk);
+    const basis = avg(upper, lower);
+
+    // Place the result at index
+    const placementIndex = index;
+
+    if (placementIndex >= 0 && placementIndex < main.len) {
+        main.verticalOhlcv['donchian_channel_upper'][placementIndex] = upper;
+        main.verticalOhlcv['donchian_channel_basis'][placementIndex] = basis;
+        main.verticalOhlcv['donchian_channel_lower'][placementIndex] = lower;
     }
-}
+
+    return true;
+};

package/src/moving-averages/ema.js

@@ -1,54 +1,29 @@
 
-import {EMA, FasterEMA} from 'trading-signals'
+import {FasterEMA} from 'trading-signals'
 
-export const ema = (main, size) => {
+export const ema = (main, index, size) => {
 
-  const {verticalOhlcv} = main
-  const {close} = verticalOhlcv
+  const value = main.verticalOhlcv.close[index]
 
-  const col = getEMA(close, size)
-
-  return {
-    [`ema_${size}`]: col
+  if(!main.instances.hasOwnProperty(`ema_${size}`))
+  {
+      main.instances[`ema_${size}`] = new FasterEMA(size)
+      main.verticalOhlcv[`ema_${size}`] = new Array(main.len).fill(null)
   }
-}
 
-export const getEMA = (data, size) => {
-  
+  let currSma
+  main.instances[`ema_${size}`].update(value)
 
-  if(typeof data === 'undefined' || typeof size === 'undefined')
+  try{
+    currSma = main.instances[`ema_${size}`].getResult()
+  } catch(err)
   {
-    throw Error('undefined param in getEMA')
+    currSma = null
   }
 
-  const dataLength = data.length
-  const output = new Array(dataLength).fill(null)
-  const instance = new FasterEMA(size)
-
-  for(let x = 0; x < dataLength; x++)
+  if(currSma)
   {
-      
-      let value = null
-
-      if(data[x] !== null)
-      {
-        instance.update(data[x])
-      
-        try
-        {
-          value = instance.getResult()
-        }
-        catch(err)
-        {
-          value = null
-        }
-      }
-      
-      output[x] = value
+    main.verticalOhlcv[`ema_${size}`][index] = currSma
   }
 
-
-
-  return output
-
 }

package/src/moving-averages/macd.js

@@ -1,50 +1,43 @@
-import { findCrosses } from "../studies/findCrosses.js";
-import {EMA, MACD, FasterEMA, FasterMACD} from 'trading-signals';
+import {FasterEMA, FasterMACD} from 'trading-signals';
 
+export const macd = (main, index, fastLine = 12, slowLine = 26, signalLine = 9) => {
 
-export const macd = (main, fastLine, slowLine, signalLine) => {
+    const value = main.verticalOhlcv.close[index]
 
-    const {verticalOhlcv} = main
-    const {close} = verticalOhlcv
-    const col = getMACD(close, fastLine, slowLine, signalLine)
+    if (!main.instances.hasOwnProperty('macd')) {
 
-    return col
-}
+        main.autoCrossPairsList.push({fast: 'macd_diff', slow: 'macd_dea'});
 
-export const getMACD = (data, fastLine = 12, slowLine = 26, signalLine = 9) => {
+        main.instances['macd'] = new FasterMACD(
+            new FasterEMA(fastLine),
+            new FasterEMA(slowLine),
+            new FasterEMA(signalLine)
+        );
 
-    const dataLength = data.length
-    const diff = new Array(dataLength).fill(null)
-    const dea = new Array(dataLength).fill(null)
-    const histogram = new Array(dataLength).fill(null)
+        Object.assign(main.verticalOhlcv, {
+            macd_diff: new Array(main.len).fill(null),
+            macd_dea: new Array(main.len).fill(null),
+            macd_histogram: new Array(main.len).fill(null),
+        })
+    }
 
-    const instance = new FasterMACD(new FasterEMA(fastLine), new FasterEMA(slowLine), new FasterEMA(signalLine))
+    const macdInstance = main.instances[`macd`];
+    macdInstance.update(value);
 
-    for(let x = 0; x < dataLength; x++)
-    {
-        let obj = {}
-        instance.update(data[x])
-        
-        try
-        {
-            obj = instance.getResult()
-        }
-        catch(err)
-        {
-            obj = {macd: null, signal: null, histogram: null}
-        }
+    let macdResult;
     
-        diff[x] = obj.macd
-        dea[x] = obj.signal
-        histogram[x] = obj.histogram
+    try {
+        macdResult = macdInstance.getResult();
+    } catch (err) {
+        //do nothing
     }
 
-    const x = findCrosses({fast: diff, slow: dea})
 
-	return {
-		macd_diff: diff, 
-		macd_dea: dea,
-		macd_histogram: histogram,
-        macd_diff_x_macd_dea: x
+    if (macdResult) {
+        main.verticalOhlcv['macd_diff'][index] = macdResult.macd;
+        main.verticalOhlcv['macd_dea'][index] = macdResult.signal;
+        main.verticalOhlcv['macd_histogram'][index] = macdResult.histogram;
     }
-}
+
+    return true;
+};

package/src/moving-averages/relativeVolume.js

@@ -1,43 +1,35 @@
-import {FasterSMA} from 'trading-signals'
+import {FasterSMA} from 'trading-signals';
 
-export const relativeVolume = (main, size = 10) => {
-    const {verticalOhlcv} = main
-    const {volume} = verticalOhlcv
-    const col = getRelativeVolume(volume, size)
+export const relativeVolume = (main, index, size = 10) => {
 
-    return {
-        [`relative_volume_${size}`]: col
+    const value = main.verticalOhlcv.volume[index]
+
+    if (!main.instances.hasOwnProperty(`relative_volume_${size}`)) {
+        main.instances[`relative_volume_${size}`] = new FasterSMA(size);
+
+        Object.assign(main.verticalOhlcv, {
+            [`relative_volume_${size}`]: new Array(main.len).fill(null),
+            [`relative_volume_sma_${size}`]: new Array(main.len).fill(null)
+        })
+    }
+
+    const smaInstance = main.instances[`relative_volume_${size}`]
+    smaInstance.update(value)
+
+    let smaValue;
+    try {
+        smaValue = smaInstance.getResult()
+    } catch (err) {
+        //do nothing
     }
-}
-
-export const getRelativeVolume = (volume, size) => {
-    
-    const instance = new FasterSMA(size)
-    const sma = new Array(volume.length).fill(null)
-    const output = new Array(volume.length).fill(null)
-
-    for(let x = 0; x < volume.length; x++)
-    {
-        let value = null
-
-        instance.update(volume[x])
-
-        try
-        {
-          value = instance.getResult()
-        }
-        catch(err)
-        {
-          value = null
-        }
-
-        sma[x] = value
-
-        if(typeof sma[x-1] === 'number')
-        {
-            output[x] = volume[x] / sma[x-1]
-        }
+
+    main.verticalOhlcv[`relative_volume_sma_${size}`][index] = smaValue;
+
+    if (smaValue !== null && typeof main.verticalOhlcv[`relative_volume_sma_${size}`][index - 1] === 'number') {
+        main.verticalOhlcv[`relative_volume_${size}`][index] = value / main.verticalOhlcv[`relative_volume_sma_${size}`][index - 1];
+    } else {
+        main.verticalOhlcv[`relative_volume_${size}`][index] = null;
     }
-    
-    return output
-}
+
+    return true;
+};

package/src/moving-averages/sma.js

@@ -1,49 +1,29 @@
 
 import {FasterSMA} from 'trading-signals';
 
-export const sma = (main, size) => {
+export const sma = (main, index, size) => {
 
-  const {verticalOhlcv} = main
-  const {close} = verticalOhlcv
+  const value = main.verticalOhlcv.close[index]
 
-  const col = getSMA(close, size)
- 
-  return {
-    [`sma_${size}`]: col
+  if(!main.instances.hasOwnProperty(`sma_${size}`))
+  {
+      main.instances[`sma_${size}`] = new FasterSMA(size)
+      main.verticalOhlcv[`sma_${size}`] = new Array(main.len).fill(null)
   }
-}
 
-export const getSMA = (data, size) => {
-  
-  if(typeof data === 'undefined' || typeof size === 'undefined')
+  let currSma
+  main.instances[`sma_${size}`].update(value)
+
+  try{
+    currSma = main.instances[`sma_${size}`].getResult()
+  } catch(err)
   {
-    throw Error('undefined param in getSMA')
+    //do nothing
   }
 
-  const dataLength = data.length
-  const output = new Array(dataLength).fill(null)
-  const instance = new FasterSMA(size)
-
-  for(let x = 0; x < dataLength; x++)
+  if(currSma)
   {
-      let value = null
-
-      if(data[x] !== null)
-      {
-        instance.update(data[x])
-      
-        try
-        {
-          value = instance.getResult()
-        }
-        catch(err)
-        {
-          value = null
-        }
-      }
-
-      output[x] = value
+    main.verticalOhlcv[`sma_${size}`][index] = currSma
   }
 
-  return output
 }

package/src/oscillators/rsi.js

@@ -1,68 +1,56 @@
-import { getSMA } from "../moving-averages/sma.js";
-import { getEMA } from "../moving-averages/ema.js";
-import { findCrosses } from "../studies/findCrosses.js";
 import {FasterRSI} from 'trading-signals';
+import { FasterSMA } from 'trading-signals';
 
-const ma = {getSMA, getEMA}
 
-export const rsi = (main, period, movingAverage, movingAveragePeriod) => {
-
-    const {verticalOhlcv} = main
-    const {close} = verticalOhlcv
+export const rsi = (main, index, size) => {
+    
+    const value = main.verticalOhlcv.close[index]
 
-    if(typeof period === 'number' && typeof movingAveragePeriod === 'undefined')
+    if(!main.instances.hasOwnProperty(`rsi_${size}`))
     {
-        movingAveragePeriod = period
-    }
-
-    const col = getRSI(close, period, movingAverage, movingAveragePeriod)
+        main.autoCrossPairsList.push({fast: `rsi_${size}`, slow: `rsi_sma_${size}`})
 
-    return col   
-}
+        Object.assign(main.instances, {
+            [`rsi_${size}`]: new FasterRSI(size),
+            [`rsi_sma_${size}`]: new FasterSMA(size)
+        })
 
-export const getRSI = (data, period = 14, movingAverage = 'SMA', movingAveragePeriod = 14) => {
-
-    const dataLength = data.length
-
-    if (dataLength < period) {
-        return [];
+        Object.assign(main.verticalOhlcv, {
+            [`rsi_${size}`]: new Array(main.len).fill(null),
+            [`rsi_sma_${size}`]: new Array(main.len).fill(null)
+        })
     }
+    
+    let currentRsi
+    let smoothedRsi
 
-    let rsi = new Array(dataLength).fill(null)
-    const instance = new FasterRSI(period)
+    main.instances[`rsi_${size}`].update(value)
 
-    for(let x = 0; x < dataLength; x++)
+    try
     {
-        let value = null
-
-        if(data[x] !== null)
-        {
-            instance.update(data[x])
-            
-            try
-            {
-                value = instance.getResult()
-            }
-            catch(err)
-            {
-                value = null
-            }
-        }
+        currentRsi = main.instances[`rsi_${size}`].getResult()
+    } catch(err) {
+        currentRsi = null
+    }
     
-        rsi[x] = value
+    if(currentRsi)
+    {
+        main.verticalOhlcv[`rsi_${size}`][index] = currentRsi
+        main.instances[`rsi_sma_${size}`].update(currentRsi)
     }
 
-    let output = {[`rsi_${period}`]: rsi}
+    try
+    {
+        smoothedRsi = main.instances[`rsi_sma_${size}`].getResult()
+    } catch(err)
+    {
+        smoothedRsi = null
+    }
 
-    if(typeof movingAverage === 'string' && typeof movingAveragePeriod === 'number')
+    if(smoothedRsi)
     {
-        if(ma.hasOwnProperty(`get${movingAverage}`))
-        {
-            const rsi_smoothed = ma[`get${movingAverage}`](rsi, movingAveragePeriod)
-            output[`rsi_${movingAverage}_${movingAveragePeriod}`] = rsi_smoothed
-            output[`rsi_${period}_x_rsi_${movingAverage}_${movingAveragePeriod}`] = findCrosses({fast: rsi, slow: rsi_smoothed})
-        }
+        main.verticalOhlcv[`rsi_sma_${size}`][index] = smoothedRsi
     }
 
-    return output
-}
+    return true
+}