ohlcv-indicators 1.9.2 → 1.9.4

package/src/oscillators/volumeOscillator.js

@@ -1,47 +1,47 @@
-import { FasterEMA } from 'trading-signals'
-import { findCrosses } from "../studies/findCrosses.js";
+import { FasterEMA } from 'trading-signals';
 
+export const volumeOscillator = (main, index, fastSize = 5, slowSize = 10) => {
 
-export const volumeOscillator = (main, fastPeriod = 5, slowPeriod = 10) => {
-    const { verticalOhlcv } = main;
-    const { volume } = verticalOhlcv;
+    const value = main.verticalOhlcv.volume[index]
 
-    return getVolumeOscillator(volume, fastPeriod, slowPeriod);
+    if (!main.instances.hasOwnProperty(`volume_oscillator`)) {
 
-}
+        Object.assign(main.instances, {
+            volume_oscillator: {
+                fastEMA: new FasterEMA(fastSize),
+                slowEMA: new FasterEMA(slowSize)
+            }
+        })
 
-export const getVolumeOscillator = (volume, fastPeriod, slowPeriod) => {
-    const fastEMA = new FasterEMA(fastPeriod)
-    const slowEMA = new FasterEMA(slowPeriod)
-    const volume_oscillator = new Array(volume.length).fill(null)
-
-    for (let i = 0; i < volume.length; i++) {
-
-        fastEMA.update(volume[i])
-        slowEMA.update(volume[i])
+        main.verticalOhlcv[`volume_oscillator`] = new Array(main.len).fill(null);
+        main.autoCrossPairsList.push({ fast: `volume_oscillator`, slow: 0 });
+    }
 
-        let fastValue = null
-        let slowValue = null
+    const { fastEMA, slowEMA } = main.instances[`volume_oscillator`];
 
-        try {
-            fastValue = fastEMA.getResult()
-        } catch (err) {
-            fastValue = null
-        }
+    fastEMA.update(value);
+    slowEMA.update(value);
 
-        try {
-            slowValue = slowEMA.getResult()
-        } catch (err) {
-            slowValue = null
-        }
+    let fastValue = null;
+    let slowValue = null;
 
-        if (typeof fastValue === 'number' && typeof slowValue === 'number' && slowValue !== 0) {
+    try {
+        fastValue = fastEMA.getResult();
+    } catch (err) {
+        fastValue = null;
+    }
 
-            volume_oscillator[i] = 100 * (fastValue - slowValue) / slowValue
-        }
+    try {
+        slowValue = slowEMA.getResult();
+    } catch (err) {
+        slowValue = null;
     }
 
-    const volume_oscillator_x_0 = findCrosses({fast: volume_oscillator, slow: new Array(volume.length).fill(0)})
+    if (typeof fastValue === 'number' && typeof slowValue === 'number' && slowValue !== 0) {
+        main.verticalOhlcv[`volume_oscillator`][index] = 100 * (fastValue - slowValue) / slowValue
+    } else {
+        main.verticalOhlcv[`volume_oscillator`][index] = null;
+    }
 
-    return {volume_oscillator, volume_oscillator_x_0}
-}
+    return true;
+};

package/src/studies/candleStudies.js

@@ -1,184 +1,157 @@
-import {FasterSMA} from 'trading-signals'
-import { classifySize } from '../utilities/classification.js'
-
-export const candlesStudies = (main, period, classify, classificationLevels) => {
-
-    const {inputOhlcv, len} = main
-
-    const cols = getCandlesStudies(inputOhlcv, period, len, classify, classificationLevels)
-    return cols
-}
-
-const getCandlesStudies = (inputOhlcv, period = 20, len, classify = true, classificationLevels = {}) => {
-
-    const {changeLevel = 7, sizeLevel = 5} = classificationLevels
- 
-    //close > open
-    let candle_body_size = new Array(len).fill(null) //scaled candle direction close - open
-    let candle_top_size = new Array(len).fill(null) //scaled top size (0, 0.5 and 1)
-    let candle_bottom_size = new Array(len).fill(null) //scaled bottom size(0, 0.5 and 1)
-    let candle_gap_size = new Array(len).fill(null) //scaled gap between the current open and previous close (-1 to 1)
-    let candle_shadow_size = new Array(len).fill(null) //scaled shadow size high - slow
-    let candle_close_direction =  new Array(len).fill(null) //scaled shadow size curr.close - prev.close
-    let candle_high_direction = new Array(len).fill(null) //scaled shadow size curr.high - prev.high
-    let candle_low_direction = new Array(len).fill(null) //scaled shadow size curr.low - prev.low
-    let candle_open_direction = new Array(len).fill(null) //scaled shadow size curr.open - prev.open
-
-    //instances
-    let topInstance 
-    let bottomInstance
-    let gapInstance
-    let bodySizeInstance
-    let shadowSizeInstance
-    let closeDirectionInstance
-    let highDirectionInstance
-    let lowDirectionInstance
-    let openDirectionInstance
-
-    if(classify)
+import { FasterSMA } from 'trading-signals';
+import { classifySize } from '../utilities/classification.js';
+
+export const candlesStudies = (main, index, size, classify = true, classificationLevels = {}) => {
+
+    const { changeLevel = 7, sizeLevel = 5 } = classificationLevels;
+
+    if(index === 0)
     {
-        topInstance = new FasterSMA(period)
-        bottomInstance = new FasterSMA(period)
-        gapInstance = new FasterSMA(period)
-        bodySizeInstance = new FasterSMA(period)
-        shadowSizeInstance = new FasterSMA(period)
-        closeDirectionInstance = new FasterSMA(period)
-        highDirectionInstance = new FasterSMA(period)
-        lowDirectionInstance = new FasterSMA(period)
-        openDirectionInstance = new FasterSMA(period)
+        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),          
+        })
     }
 
-    for(let x = 0; x < len; x++)
-    {
-        const curr = inputOhlcv[x]
-        const prev = inputOhlcv[x-1]
-
-        if(typeof prev === 'undefined') continue
-
-        const {open, high, low, close} = curr
-
-
-        //initial means
-        let gapMean = null
-        let bottomSizeMean = null
-        let topSizeMean = null
-        let bodySizeMean = null
-        let shadowSizeMean = null
-        let closeDirectionMean = null
-        let highDirectionMean = null
-        let lowDirectionMean = null
-        let openDirectionMean = null
-
-        //directions
-        const isUp = close > open
-        const candleBodySize = Math.abs(close - open)
-        const shadowSize = Math.abs(curr.high - curr.low)
-
-        //sizes
-        const topSize = high - Math.max(open, close)
-        const bottomSize = Math.min(open, close) - low
-        const gapSize = Math.abs(prev.close - curr.open)
-        const closeDirection = Math.abs(curr.close - prev.close)
-        const highDirection = Math.abs(curr.high - prev.high)
-        const lowDirection = Math.abs(curr.low - prev.low)
-        const openDirection = Math.abs(curr.open - prev.open)
-
-        if(classify)
-        {
-            //instances
-            topInstance.update(Math.abs(topSize))
-            bottomInstance.update(Math.abs(bottomSize))
-            shadowSizeInstance.update(Math.abs(shadowSize))
-
-            gapInstance.update(gapSize)
-            bodySizeInstance.update(candleBodySize)
-            closeDirectionInstance.update(closeDirection)
-            highDirectionInstance.update(highDirection)
-            lowDirectionInstance.update(lowDirection)
-            openDirectionInstance.update(openDirection)
-            
-            try
-            {
-                topSizeMean = topInstance.getResult()
-                bottomSizeMean = bottomInstance.getResult()
-                gapMean = gapInstance.getResult()
-                bodySizeMean = bodySizeInstance.getResult()
-                shadowSizeMean = shadowSizeInstance.getResult()
-                closeDirectionMean = closeDirectionInstance.getResult()
-                highDirectionMean = highDirectionInstance.getResult()
-                lowDirectionMean = lowDirectionInstance.getResult()
-                openDirectionMean = openDirectionInstance.getResult()
-            }
-            catch(err)
-            {
-                bodySizeMean = null
-                gapMean = null
-                topSizeMean = null
-                bottomSizeMean = null
-                shadowSizeMean = null
-                closeDirectionMean = null
-                highDirectionMean = null
-                lowDirectionMean = null
-                openDirectionMean = null
+    // Ensure instances exist if classification is enabled
+    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)             
             }
+        })
+    }
 
-            //negatives and positives
-            candle_body_size[x] = (isUp) 
-            ? classifySize(candleBodySize, bodySizeMean, 2, changeLevel) 
+    // If we do not have a previous candle, we cannot compute differences
+    const prevOpen = main.verticalOhlcv.open[index-1]
+    const prevHigh = main.verticalOhlcv.high[index-1]
+    const prevLow = main.verticalOhlcv.low[index-1]
+    const prevClose = main.verticalOhlcv.close[index-1]
+
+    if ([prevOpen, prevHigh, prevLow, prevClose].some(v => typeof v === 'undefined')) return true;
+
+    const currOpen = main.verticalOhlcv.open[index]
+    const currHigh = main.verticalOhlcv.high[index]
+    const currLow = main.verticalOhlcv.low[index]
+    const currClose = main.verticalOhlcv.close[index]
+
+    // Determine candle direction and sizes
+    const isUp = currClose > currOpen;
+    const candleBodySize = Math.abs(currClose - currOpen);
+    const shadowSize = Math.abs(currHigh - currLow);
+
+    const topSize = currHigh - Math.max(currOpen, currClose);
+    const bottomSize = Math.min(currOpen, currClose) - currLow;
+    const gapSize = Math.abs(prevClose - currOpen);
+    const closeDirection = Math.abs(currClose - prevClose);
+    const highDirection = Math.abs(currHigh - prevHigh);
+    const lowDirection = Math.abs(currLow - prevLow);
+    const openDirection = Math.abs(currOpen - prevOpen);
+
+    let gapMean = null;
+    let bottomSizeMean = null;
+    let topSizeMean = null;
+    let bodySizeMean = null;
+    let shadowSizeMean = null;
+    let closeDirectionMean = null;
+    let highDirectionMean = null;
+    let lowDirectionMean = null;
+    let openDirectionMean = null;
+
+    if (classify) {
+        const {
+            topInstance,
+            bottomInstance,
+            gapInstance,
+            bodySizeInstance,
+            shadowSizeInstance,
+            closeDirectionInstance,
+            highDirectionInstance,
+            lowDirectionInstance,
+            openDirectionInstance
+        } = main.instances.candleStudies;
+
+        // Update instances with current absolute values
+        topInstance.update(Math.abs(topSize));
+        bottomInstance.update(Math.abs(bottomSize));
+        shadowSizeInstance.update(Math.abs(shadowSize));
+        gapInstance.update(gapSize);
+        bodySizeInstance.update(candleBodySize);
+        closeDirectionInstance.update(closeDirection);
+        highDirectionInstance.update(highDirection);
+        lowDirectionInstance.update(lowDirection);
+        openDirectionInstance.update(openDirection);
+
+        try {
+            topSizeMean = topInstance.getResult();
+            bottomSizeMean = bottomInstance.getResult();
+            gapMean = gapInstance.getResult();
+            bodySizeMean = bodySizeInstance.getResult();
+            shadowSizeMean = shadowSizeInstance.getResult();
+            closeDirectionMean = closeDirectionInstance.getResult();
+            highDirectionMean = highDirectionInstance.getResult();
+            lowDirectionMean = lowDirectionInstance.getResult();
+            openDirectionMean = openDirectionInstance.getResult();
+        } catch (err) {
+            // If there's not enough data, means remain null
+        }
+
+        main.verticalOhlcv.candle_body_size[index] = isUp
+            ? classifySize(candleBodySize, bodySizeMean, 2, changeLevel)
             : -Math.abs(classifySize(candleBodySize, bodySizeMean, 2, changeLevel)) || 0;
 
-            candle_gap_size[x] = (isUp) 
-            ? classifySize(gapSize, gapMean, 2, changeLevel) 
+        main.verticalOhlcv.candle_gap_size[index] = isUp
+            ? classifySize(gapSize, gapMean, 2, changeLevel)
             : -Math.abs(classifySize(gapSize, gapMean, 2, changeLevel)) || 0;
 
-            candle_close_direction[x] = (isUp) 
-            ? classifySize(closeDirection, closeDirectionMean, 2, changeLevel) 
+        main.verticalOhlcv.candle_close_direction[index] = isUp
+            ? classifySize(closeDirection, closeDirectionMean, 2, changeLevel)
             : -Math.abs(classifySize(closeDirection, closeDirectionMean, 2, changeLevel)) || 0;
 
-            candle_high_direction[x] = (isUp) 
-            ? classifySize(highDirection, highDirectionMean, 2, changeLevel) 
-            : -Math.abs(classifySize(highDirection, highDirectionMean, 2, changeLevel)) || 0;  
-            
-            
-            candle_low_direction[x] = (isUp) 
-            ? classifySize(lowDirection, lowDirectionMean, 2, changeLevel) 
+        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
+            ? classifySize(lowDirection, lowDirectionMean, 2, changeLevel)
             : -Math.abs(classifySize(lowDirection, lowDirectionMean, 2, changeLevel)) || 0;
 
-            candle_open_direction[x] = (isUp) 
-            ? classifySize(openDirection, openDirectionMean, 2, changeLevel) 
+        main.verticalOhlcv.candle_open_direction[index] = isUp
+            ? classifySize(openDirection, openDirectionMean, 2, changeLevel)
             : -Math.abs(classifySize(openDirection, openDirectionMean, 2, changeLevel)) || 0;
 
-            
-            //positives only
-            candle_top_size[x] = classifySize(topSize, topSizeMean, 0.5, sizeLevel)
-            candle_bottom_size[x] = classifySize(bottomSize, bottomSizeMean, 0.5, sizeLevel)
-            candle_shadow_size[x] = classifySize(shadowSize, shadowSizeMean, 0.5, sizeLevel)
-        }
-        else{
-             //negatives and positives
-             candle_body_size[x] = candleBodySize
-             candle_gap_size[x] = gapSize
-             candle_close_direction[x] = closeDirection
-             candle_high_direction[x] = highDirection
-             candle_low_direction[x] = lowDirection
- 
-             //positives only
-             candle_top_size[x] = topSize
-             candle_bottom_size[x] = bottomSize
-             candle_shadow_size[x] = shadowSize           
-        }
-
+        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;
     }
 
-    return {
-        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
-    }
-}
+    return true;
+};

package/src/studies/findCrosses.js

@@ -3,8 +3,69 @@ const gt = (f, s) => f > s
 const lt = (f, s) => f < s
 
 
+
+export const crossPairs = (main, arr) => {
+    
+    const {verticalOhlcv} = main
+
+    const x = {}
+    const c = {}
+
+    for (const { fast, slow, count } of arr) {
+        // Validate parameters
+        if (!fast || !slow) continue;
+    
+        // Prepare slowNumArr if 'slow' is a number
+        if (typeof slow === 'number') {
+
+            main.verticalOhlcv[slow] = new Array(main.len).fill(slow)
+        }
+    
+        const crossName = `${fast}_x_${slow}`
+        const countName = `${fast}_c_${slow}`
+
+        const splitCount = arr => (typeof count !== 'undefined') ? (arr.slice(-count)).filter(o => o === 1 || o === -1).length : 0
+
+        //cross already exists
+        if(verticalOhlcv[crossName])
+        {
+            const cross = verticalOhlcv[crossName]
+            x[crossName] = cross    
+            
+            if(typeof count !== 'undefined')
+            {
+                c[countName] = splitCount(cross)
+            }
+            
+        }
+        //cross created from 2 columns
+        else if ((verticalOhlcv[fast] || fast === 'price') && verticalOhlcv[slow]) {
+
+            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
+
+            if(typeof count !== 'undefined')
+            {
+                c[countName] = splitCount(cross)
+            }
+
+        }
+    }
+
+    return {x, c}
+}
+
+
 // Function to find crosses between two arrays: fast and slow
-export const findCrosses = ({fast, high, low, slow}) => {
+const findCrosses = ({fast, high, low, slow}) => {
     // Map states based on comparison of fast and slow arrays
 
     const dataLength = fast.length
@@ -80,131 +141,48 @@ export const findCrosses = ({fast, high, low, slow}) => {
 
 
 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)
-            {
-                v = 0
-            }
-            if(s === 1)
-            {
-                v = v * 1
-            }
-            if(s === 0)
-            {
-                v = v * -1
-            }
-
-            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
-    }, [])
-}
-
-
-
-export const crossPairs = (main, arr) => {
-
-
-
-    const {verticalOhlcv, len} = main
-    const slowNumArrCache = {};
-    const x = {}
-    const c = {}
-
-    for (const { fast, slow, count } of arr) {
-        // Validate parameters
-        if (!fast || !slow) continue;
+    const result = [];
     
-        // Prepare slowNumArr if 'slow' is a number
-        if (typeof slow === 'number' && !slowNumArrCache[slow]) {
-
-            slowNumArrCache[slow] = Array(len).fill(slow)
+    for (const group of groups) {
+        const length = group.length;
+        
+        for (let i = length - 1; i >= 0; i--) {
+            const s = group[i];
+            const offset = length - i;
+            result.push(
+                s === 0.5 ? 0 : offset * (s === 1 ? 1 : -1)
+            );
         }
+    }
     
-        const crossName = `${fast}_x_${slow}`
-        const countName = `${fast}_c_${slow}`
-
-        const splitCount = arr => (typeof count !== 'undefined') ? (arr.slice(-count)).filter(o => o === 1 || o === -1).length : 0
-
-        //cross already exists
-        if(verticalOhlcv[crossName])
-        {
-            const cross = verticalOhlcv[crossName]
-            x[crossName] = cross    
-            
-            if(typeof count !== 'undefined')
-            {
-                c[countName] = splitCount(cross)
-            }
-            
-        }
-        //cross created from 2 columns
-        else if ((verticalOhlcv[fast] || fast === 'price') && verticalOhlcv[slow]) {
-
-            const cross = (fast === 'price') 
-            ? findCrosses({
-                fast: verticalOhlcv.close, 
-                high: verticalOhlcv.high, 
-                low: verticalOhlcv.low, 
-                slow: verticalOhlcv[slow]}
-            ) 
-            : findCrosses({fast: verticalOhlcv[fast], slow: verticalOhlcv[slow]})
+    return result;
+}
 
-            x[crossName] = cross
 
-            if(typeof count !== 'undefined')
-            {
-                c[countName] = splitCount(cross)
-            }
+// Helper function to group consecutive values
+const groupConsecutiveValues = (arr) => {
+    const length = arr.length;
+    if (length === 0) return [];
 
-        }
-        //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
+    const result = [];
+    let currentGroup = [arr[0]];
 
-            if(typeof count !== 'undefined'){
-                c[countName] = splitCount(cross)
-            }
+    for (let i = 1; i < length; i++) {
+        const currentValue = arr[i];
+        const prevValue = arr[i - 1];
 
+        if (currentValue === prevValue) {
+            // Same value, continue the current group
+            currentGroup.push(currentValue);
         } else {
-            throw Error(`Missing ohlcv properties for ${fast} or ${slow}`);
+            // Value changed, finalize the current group and start a new one
+            result.push(currentGroup);
+            currentGroup = [currentValue];
         }
     }
 
-    return {x, c}
-}
+    // Push the last group
+    result.push(currentGroup);
+
+    return result;
+};

package/src/studies/lag.js

@@ -0,0 +1,27 @@
+export const lag = (main, index, colKeys = ['close'], lags = 1) => {
+
+    const { verticalOhlcv, len } = main;
+
+    // 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);
+            }
+
+            // 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;
+        }
+    }
+
+    return true;
+};