ohlcv-indicators 1.9.2 → 1.9.3

package/src/oscillators/volumeOscillator.js

@@ -1,47 +1,43 @@
-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);
-
-}
-
-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])
+    if (!main.instances.hasOwnProperty(`volume_oscillator`)) {
+        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 });
+    }
 
-        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,172 @@
-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)
-    {
-        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)
+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;
+
+    // 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);
+        }
     }
 
-    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) {
+        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);
             }
+        }
+    }
 
-            //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/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;
+};