ohlcv-indicators 1.9.3 → 1.9.5

package/src/oscillators/rsi.js

@@ -6,13 +6,19 @@ export const rsi = (main, index, size) => {
     
     const value = main.verticalOhlcv.close[index]
 
-    if(!main.instances.hasOwnProperty(`rsi_${size}`))
+    if(index === 0)
     {
-        main.autoCrossPairsList.push({fast: `rsi_${size}`, slow: `rsi_sma_${size}`})
-        main.instances[`rsi_${size}`] = new FasterRSI(size)
-        main.instances[`rsi_sma_${size}`] = new FasterSMA(size)
-        main.verticalOhlcv[`rsi_${size}`] = new Array(main.len).fill(null)
-        main.verticalOhlcv[`rsi_sma_${size}`] = new Array(main.len).fill(null)
+        main.crossPairsList.push({fast: `rsi_${size}`, slow: `rsi_sma_${size}`})
+
+        Object.assign(main.instances, {
+            [`rsi_${size}`]: new FasterRSI(size),
+            [`rsi_sma_${size}`]: new FasterSMA(size)
+        })
+
+        Object.assign(main.verticalOhlcv, {
+            [`rsi_${size}`]: new Array(main.len).fill(null),
+            [`rsi_sma_${size}`]: new Array(main.len).fill(null)
+        })
     }
     
     let currentRsi

package/src/oscillators/volumeOscillator.js

@@ -4,13 +4,17 @@ export const volumeOscillator = (main, index, fastSize = 5, slowSize = 10) => {
 
     const value = main.verticalOhlcv.volume[index]
 
-    if (!main.instances.hasOwnProperty(`volume_oscillator`)) {
-        main.instances[`volume_oscillator`] = {
-            fastEMA: new FasterEMA(fastSize),
-            slowEMA: new FasterEMA(slowSize)
-        };
+    if (index === 0) {
+
+        Object.assign(main.instances, {
+            volume_oscillator: {
+                fastEMA: new FasterEMA(fastSize),
+                slowEMA: new FasterEMA(slowSize)
+            }
+        })
+
         main.verticalOhlcv[`volume_oscillator`] = new Array(main.len).fill(null);
-        main.autoCrossPairsList.push({ fast: `volume_oscillator`, slow: 0 });
+        main.crossPairsList.push({ fast: `volume_oscillator`, slow: 0 });
     }
 
     const { fastEMA, slowEMA } = main.instances[`volume_oscillator`];

package/src/studies/candleStudies.js

@@ -3,54 +3,39 @@ import { classifySize } from '../utilities/classification.js';
 
 export const candlesStudies = (main, index, size, classify = true, classificationLevels = {}) => {
 
-
-
     const { changeLevel = 7, sizeLevel = 5 } = classificationLevels;
 
-    // Ensure arrays exist in main.verticalOhlcv
-    const fields = [
-        'candle_gap_size',
-        'candle_body_size',
-        'candle_top_size',
-        'candle_bottom_size',
-        'candle_shadow_size',
-        'candle_close_direction',
-        'candle_high_direction',
-        'candle_low_direction',
-        'candle_open_direction'
-    ];
-
-    for (const field of fields) {
-        if (!main.verticalOhlcv.hasOwnProperty(field)) {
-            main.verticalOhlcv[field] = new Array(main.len).fill(null);
-        }
+    if(index === 0)
+    {
+        Object.assign(main.verticalOhlcv, {
+            candle_gap_size: new Array(main.len).fill(null),
+            candle_body_size: new Array(main.len).fill(null),
+            candle_top_size: new Array(main.len).fill(null),
+            candle_bottom_size: new Array(main.len).fill(null),
+            candle_shadow_size: new Array(main.len).fill(null),
+            candle_close_direction: new Array(main.len).fill(null),
+            candle_high_direction: new Array(main.len).fill(null),
+            candle_low_direction: new Array(main.len).fill(null),
+            candle_open_direction: new Array(main.len).fill(null),          
+        })
     }
 
     // Ensure instances exist if classification is enabled
-    if (classify) {
-        const instanceNames = [
-            'topInstance',
-            'bottomInstance',
-            'gapInstance',
-            'bodySizeInstance',
-            'shadowSizeInstance',
-            'closeDirectionInstance',
-            'highDirectionInstance',
-            'lowDirectionInstance',
-            'openDirectionInstance'
-        ];
-
-        // Create a namespace for candle studies if it doesn't exist
-        if (!main.instances.hasOwnProperty('candleStudies')) {
-            main.instances.candleStudies = {};
-        }
-
-        // Create instances if they don't exist
-        for (const name of instanceNames) {
-            if (!main.instances.candleStudies.hasOwnProperty(name)) {
-                main.instances.candleStudies[name] = new FasterSMA(size);
+    if (classify && index === 0) {
+
+        Object.assign(main.instances, {
+            candleStudies: {
+                topInstance: new FasterSMA(size),
+                bottomInstance: new FasterSMA(size),
+                gapInstance: new FasterSMA(size),
+                bodySizeInstance: new FasterSMA(size),
+                shadowSizeInstance: new FasterSMA(size),
+                closeDirectionInstance: new FasterSMA(size),
+                highDirectionInstance: new FasterSMA(size),
+                lowDirectionInstance: new FasterSMA(size),
+                openDirectionInstance: new FasterSMA(size)             
             }
-        }
+        })
     }
 
     // If we do not have a previous candle, we cannot compute differences
@@ -127,45 +112,45 @@ export const candlesStudies = (main, index, size, classify = true, classificatio
             // If there's not enough data, means remain null
         }
 
-        main.verticalOhlcv['candle_body_size'][index] = isUp
+        main.verticalOhlcv.candle_body_size[index] = isUp
             ? classifySize(candleBodySize, bodySizeMean, 2, changeLevel)
             : -Math.abs(classifySize(candleBodySize, bodySizeMean, 2, changeLevel)) || 0;
 
-        main.verticalOhlcv['candle_gap_size'][index] = isUp
+        main.verticalOhlcv.candle_gap_size[index] = isUp
             ? classifySize(gapSize, gapMean, 2, changeLevel)
             : -Math.abs(classifySize(gapSize, gapMean, 2, changeLevel)) || 0;
 
-        main.verticalOhlcv['candle_close_direction'][index] = isUp
+        main.verticalOhlcv.candle_close_direction[index] = isUp
             ? classifySize(closeDirection, closeDirectionMean, 2, changeLevel)
             : -Math.abs(classifySize(closeDirection, closeDirectionMean, 2, changeLevel)) || 0;
 
-        main.verticalOhlcv['candle_high_direction'][index] = isUp
+        main.verticalOhlcv.candle_high_direction[index] = isUp
             ? classifySize(highDirection, highDirectionMean, 2, changeLevel)
             : -Math.abs(classifySize(highDirection, highDirectionMean, 2, changeLevel)) || 0;
 
-        main.verticalOhlcv['candle_low_direction'][index] = isUp
+        main.verticalOhlcv.candle_low_direction[index] = isUp
             ? classifySize(lowDirection, lowDirectionMean, 2, changeLevel)
             : -Math.abs(classifySize(lowDirection, lowDirectionMean, 2, changeLevel)) || 0;
 
-        main.verticalOhlcv['candle_open_direction'][index] = isUp
+        main.verticalOhlcv.candle_open_direction[index] = isUp
             ? classifySize(openDirection, openDirectionMean, 2, changeLevel)
             : -Math.abs(classifySize(openDirection, openDirectionMean, 2, changeLevel)) || 0;
 
-        main.verticalOhlcv['candle_top_size'][index] = classifySize(topSize, topSizeMean, 0.5, sizeLevel);
-        main.verticalOhlcv['candle_bottom_size'][index] = classifySize(bottomSize, bottomSizeMean, 0.5, sizeLevel);
-        main.verticalOhlcv['candle_shadow_size'][index] = classifySize(shadowSize, shadowSizeMean, 0.5, sizeLevel);
+        main.verticalOhlcv.candle_top_size[index] = classifySize(topSize, topSizeMean, 0.5, sizeLevel);
+        main.verticalOhlcv.candle_bottom_size[index] = classifySize(bottomSize, bottomSizeMean, 0.5, sizeLevel);
+        main.verticalOhlcv.candle_shadow_size[index] = classifySize(shadowSize, shadowSizeMean, 0.5, sizeLevel);
     } else {
         // Without classification, just store raw values
-        main.verticalOhlcv['candle_body_size'][index] = isUp ? candleBodySize : -candleBodySize;
-        main.verticalOhlcv['candle_gap_size'][index] = isUp ? gapSize : -gapSize;
-        main.verticalOhlcv['candle_close_direction'][index] = isUp ? closeDirection : -closeDirection;
-        main.verticalOhlcv['candle_high_direction'][index] = isUp ? highDirection : -highDirection;
-        main.verticalOhlcv['candle_low_direction'][index] = isUp ? lowDirection : -lowDirection;
-        main.verticalOhlcv['candle_open_direction'][index] = isUp ? openDirection : -openDirection;
-
-        main.verticalOhlcv['candle_top_size'][index] = topSize;
-        main.verticalOhlcv['candle_bottom_size'][index] = bottomSize;
-        main.verticalOhlcv['candle_shadow_size'][index] = shadowSize;
+        main.verticalOhlcv.candle_body_size[index] = isUp ? candleBodySize : -candleBodySize;
+        main.verticalOhlcv.candle_gap_size[index] = isUp ? gapSize : -gapSize;
+        main.verticalOhlcv.candle_close_direction[index] = isUp ? closeDirection : -closeDirection;
+        main.verticalOhlcv.candle_high_direction[index] = isUp ? highDirection : -highDirection;
+        main.verticalOhlcv.candle_low_direction[index] = isUp ? lowDirection : -lowDirection;
+        main.verticalOhlcv.candle_open_direction[index] = isUp ? openDirection : -openDirection;
+
+        main.verticalOhlcv.candle_top_size[index] = topSize;
+        main.verticalOhlcv.candle_bottom_size[index] = bottomSize;
+        main.verticalOhlcv.candle_shadow_size[index] = shadowSize;
     }
 
     return true;

package/src/studies/findCrosses.js

@@ -1,210 +1,185 @@
-const eq = (f, s) => f === s
-const gt = (f, s) => f > s
-const lt = (f, s) => f < s
+const eq = (fast, slow) => fast === slow
+const gt = (fast, slow) => fast > slow
+const lt = (fast, slow) => fast < slow
 
 
-// Function to find crosses between two arrays: fast and slow
-export const findCrosses = ({fast, high, low, slow}) => {
-    // Map states based on comparison of fast and slow arrays
+//this class counts how many intervals have passed between crosses: fast crossed slow line, high crossed slow line or low crossed slow line.
+//interval === 0 for no crosses yet or the lines are equal
+//interval >= 1 for an upwards crosses
+//interval <= -1 from downward crosses
 
-    const dataLength = fast.length
+class CrossInstance {
 
-    if(dataLength ==! slow.length)
+    constructor()
     {
-        throw Error('fast and slow do not have the same length')
-    }
-
-    const state = new Array(dataLength).fill(0.5)
+        this.interval = 0
+        this.prevState = 0.5
+        this.prevFast = null
+        this.prevSlow = null
+        this.prevHigh = null
+        this.prevLow = null
+        this.areHighAndLowUndefined = false
+        this.index = 0
+        this.crossIndexes = {
+            up: [],
+            down: []
+        }
 
-    for(let x = 0; x < dataLength; x++)
+    }
+    update({fast, high, slow, low})
     {
-        const prevState = state?.[x-1] || 0.5
-        const f = fast[x]
-        const s = slow[x]
-        const hi = high?.[x]
-        const lo = low?.[x]
+        let currState = this.prevState
 
-        if(high || low)
+        if(!this.areHighAndLowUndefined)
         {
-            if(typeof hi === 'undefined' || typeof lo === 'undefined') continue
+            if(typeof high === 'undefined' || typeof low === 'undefined')
+            {
+                this.areHighAndLowUndefined = true
+            }
         }
 
-        const prevS = slow[x - 1]
-        const prevHi = high?.[x-1]
-        const prevLo = low?.[x-1]
-
-        if(high || low)
-        {
-            if(typeof prevHi === 'undefined' || typeof prevLo === 'undefined' || typeof prevS === 'undefined') continue
+        if(fast === null || slow === null){
+            currState = 0.5
         }
-        
-        let value
-
-        if(f === null || s === null) value = 0.5
-
-        else if(eq(f, s)) {
-            value = prevState
+        else if(eq(fast, slow)) {
+            currState = 0.5
         }
-        else if(gt(f, s)) {
+        else if(gt(fast, slow)) {
 
-            if(lt(lo, s) && gt(prevLo, prevS))
+            if(this.areHighAndLowUndefined)
             {
-                value = 0
+                currState = 1
             }
             else
             {
-                value = 1
+                if ([low, slow, this.prevLow, this.prevSlow].every(v => v !== null) && lt(low, slow) && gt(this.prevLow, this.prevSlow))
+                {
+                    currState = 0
+                }
+                else
+                {
+                    currState = 1
+                }
             }
         }
-        else if(lt(f, s)) {
+        else if(lt(fast, slow)) {
 
-            if(gt(hi, s) && lt(prevHi, prevS))
+            if(this.areHighAndLowUndefined)
             {
-                value = 1
+                currState = 0
             }
             else
             {
-                value = 0
+                if([high, slow, this.prevHigh, this.prevSlow].every(v => v !== null) && gt(high, slow) && lt(this.prevHigh, this.prevSlow))
+                {
+                    currState = 1
+                }
+                else
+                {
+                    currState = 0
+                }
             }
         }
-        
-        state[x] = value
-    }
-
 
-
-    const groups = groupConsecutiveValues(state)
-
-    return flatGroupsToNumArr(groups)
-}
-
-
-const flatGroupsToNumArr = groups => {
-
-    const groupLengths = groups.map(g => g.length)
-
-    return groups.map((group, gIndex) => {
-        let initialValue = groupLengths[gIndex]
-
-        return group.map((s, i) => {
-            let v = initialValue - i
-
-            if(s === 0.5)
+        if(currState === 0.5)
+        {
+            this.interval = 0
+        }
+        else if(currState === 1)
+        {
+            if(this.prevState <= 0.5)
+            {
+                this.interval = 1
+            }
+            else
             {
-                v = 0
+                this.interval++
             }
-            if(s === 1)
+        }
+        else if(currState === 0)
+        {
+            if(this.prevState >= 0.5)
             {
-                v = v * 1
+                this.interval = -1
             }
-            if(s === 0)
+            else
             {
-                v = v * -1
+                this.interval--
             }
-
-            return v
-        }).reverse()
-    }).flat()
-}
+        }
 
 
-// Helper function to group consecutive values
-export const groupConsecutiveValues = arr => {
-    if (arr.length === 0) return []
-
-    return arr.reduce((acc, currentValue, index, array) => {
-        if (index === 0) {
-            // Start the first group with the first element
-            acc.push([currentValue])
-        } else {
-            // Get the previous value
-            const prevValue = array[index - 1]
-            const currentGroup = acc[acc.length - 1]
-
-            // Check the direction of the previous and current values
-            if (currentValue !== prevValue) {
-                // Start a new group if the direction changes
-                acc.push([currentValue]);
-            } else {
-                // Otherwise, add to the current group
-                currentGroup.push(currentValue);
-            }
-        }
-        return acc
-    }, [])
-}
+        if(this.interval === 1) this.crossIndexes.up.push(this.index)
+        if(this.interval === -1) this.crossIndexes.down.push(this.index)
 
+        //save prev state
+        this.index++
+        this.prevState = currState
+        this.prevFast = fast
+        this.prevSlow = slow
+        this.prevHigh = high
+        this.prevLow = low
+    }
 
+    getResult()
+    {
+        return this.interval
+    }
 
-export const crossPairs = (main, arr) => {
+}
 
+export const crossPairs = (main, index, arr) => {
 
+    const {len} = main
 
-    const {verticalOhlcv, len} = main
-    const slowNumArrCache = {};
-    const x = {}
-    const c = {}
+    for (const { fast, slow } of arr)
+    {
 
-    for (const { fast, slow, count } of arr) {
-        // Validate parameters
-        if (!fast || !slow) continue;
-    
-        // Prepare slowNumArr if 'slow' is a number
-        if (typeof slow === 'number' && !slowNumArrCache[slow]) {
+        
 
-            slowNumArrCache[slow] = Array(len).fill(slow)
-        }
-    
-        const crossName = `${fast}_x_${slow}`
-        const countName = `${fast}_c_${slow}`
+        if (!fast || !slow) continue
 
-        const splitCount = arr => (typeof count !== 'undefined') ? (arr.slice(-count)).filter(o => o === 1 || o === -1).length : 0
+        let crossName = `${fast}_x_${slow}`
 
-        //cross already exists
-        if(verticalOhlcv[crossName])
+        if(index === 0)
         {
-            const cross = verticalOhlcv[crossName]
-            x[crossName] = cross    
-            
-            if(typeof count !== 'undefined')
+            if(typeof slow === 'number')
             {
-                c[countName] = splitCount(cross)
+                main.verticalOhlcv[slow] = new Array(len).fill(slow)
             }
             
-        }
-        //cross created from 2 columns
-        else if ((verticalOhlcv[fast] || fast === 'price') && verticalOhlcv[slow]) {
+            if(fast !== 'price' && !main.verticalOhlcv.hasOwnProperty(fast)) throw Error(`fast "${fast} not found in crossPairs"`)
+            if(!main.verticalOhlcv.hasOwnProperty(slow)) throw Error(`slow "${slow} not found in crossPairs"`)
 
-            const cross = (fast === 'price') 
-            ? findCrosses({
-                fast: verticalOhlcv.close, 
-                high: verticalOhlcv.high, 
-                low: verticalOhlcv.low, 
-                slow: verticalOhlcv[slow]}
-            ) 
-            : findCrosses({fast: verticalOhlcv[fast], slow: verticalOhlcv[slow]})
 
-            x[crossName] = cross
+            main.instances[crossName] = new CrossInstance()
+            main.verticalOhlcv[crossName] = new Array(len).fill(null)
+        }
 
-            if(typeof count !== 'undefined')
-            {
-                c[countName] = splitCount(cross)
-            }
+        let fastValue
+        let closeValue
+        let highValue
+        let lowValue
+        let slowValue
 
-        }
-        //cross created from 1 column and an number
-        else if (verticalOhlcv[fast] && slowNumArrCache[slow]) {
-            const cross = findCrosses({fast: verticalOhlcv[fast], slow: slowNumArrCache[slow]})
-            x[crossName] = cross
+        if(fast === 'price')
+        {
+            closeValue = main.verticalOhlcv.close[index]
+            highValue = main.verticalOhlcv.high[index]
+            lowValue = main.verticalOhlcv.low[index]
+            slowValue = main.verticalOhlcv[slow][index]
 
-            if(typeof count !== 'undefined'){
-                c[countName] = splitCount(cross)
-            }
+            main.instances[crossName].update({fast: closeValue, slow: slowValue, high: highValue, low: lowValue})
 
-        } else {
-            throw Error(`Missing ohlcv properties for ${fast} or ${slow}`);
+        } else
+        {
+            fastValue = main.verticalOhlcv[fast][index]
+            slowValue = main.verticalOhlcv[slow][index]
+
+            main.instances[crossName].update({fast: fastValue, slow: slowValue})
         }
+
+        main.verticalOhlcv[crossName][index] = main.instances[crossName].getResult()
     }
 
-    return {x, c}
 }

package/src/studies/lag.js

@@ -1,27 +1,34 @@
-export const lag = (main, index, colKeys = ['close'], lags = 1) => {
+export const lag = (main, index, params) => {
 
-    const { verticalOhlcv, len } = main;
+    for(let p = 0; p < params.length; p++)
+    {
+        const [colKeys, lags] = params[p]
 
-    // Ensure arrays exist for each lag key before we populate
-    for (let x = 0; x < colKeys.length; x++) {
-        for (let lag = 1; lag <= lags; lag++) {
-            const key = `${colKeys[x]}_lag_${lag}`;
-            // If the array does not exist, initialize it
-            if (!verticalOhlcv.hasOwnProperty(key)) {
-                verticalOhlcv[key] = new Array(len).fill(null);
-            }
+        // Ensure arrays exist for each lag key before we populate
+        for (let x = 0; x < colKeys.length; x++) {
+            for (let lag = 1; lag <= lags; lag++) {
+                const key = `${colKeys[x]}_lag_${lag}`;
+                // If the array does not exist, initialize it
+                if (index === 0) {
+                    main.verticalOhlcv[key] = new Array(main.len).fill(null)
+                }
 
-            // Compute the lagged index
-            const laggedIndex = index - lag;
-            
-            // If laggedIndex is negative, we don't have a previous value
-            const value = (laggedIndex >= 0) 
-                ? verticalOhlcv[colKeys[x]][laggedIndex] 
-                : null;
-            
-            verticalOhlcv[key][index] = value;
+                // Compute the lagged index
+                const laggedIndex = index - lag;
+                
+                // If laggedIndex is negative, we don't have a previous value
+                const value = (laggedIndex >= 0) 
+                    ? main.verticalOhlcv[colKeys[x]][laggedIndex] 
+                    : null;
+                
+                main.verticalOhlcv[key][index] = value;
+            }
         }
     }
 
+
+
+
+
     return true;
 };