ohlcv-indicators 3.5.47 → 3.5.49

package/index.js

@@ -355,14 +355,34 @@ export default class OHLCV_INDICATORS {
         return this
     }
 
-    vidya(size = 14, smoothing = 20, options = {}) {
+    heikenAshi(smoothLength = 10, afterSmoothLength = 10, options = {}) {
+        const methodName = 'heikenAshi'
+
+        isAlreadyComputed(this)
+
+        validateNumber(smoothLength, {min: 1, max: this.len, allowDecimals: false}, 'smoothLength', methodName)
+        validateNumber(afterSmoothLength, {min: 1, max: this.len, allowDecimals: false}, 'afterSmoothLength', methodName)
+        validateObject(options, 'options', methodName)
+
+        const {lag = 0} = options
+
+        validateNumber(lag, {min: 0, max: this.len, allowDecimals: false}, 'options.lag', methodName)
+
+        const order = 0
+
+        this.inputParams.push({key: methodName, order, params: [smoothLength, afterSmoothLength, {lag}]})
+
+        return this
+    }
+
+    vidya(size = 14, momentum = 20, options = {}) {
 
         const methodName = 'vidya'
 
         isAlreadyComputed(this)
 
         validateNumber(size, {min: 2, max: this.len, allowDecimals: false}, 'size', methodName)
-        validateNumber(smoothing, {min: size, max: this.len, allowDecimals: false}, 'smoothing', methodName)
+        validateNumber(momentum, {min: 1, max: this.len, allowDecimals: false}, 'momentum', methodName)
         validateObject(options, 'options', methodName)
 
         const {target = 'close', lag = 0, atrLength = 200, bandDistance = 2, liquidityLookback = 20} = options
@@ -375,7 +395,7 @@ export default class OHLCV_INDICATORS {
 
         const order = getOrderFromArray([target], methodName)
 
-        this.inputParams.push({key: methodName, order, params: [size, smoothing, {target, lag}]})
+        this.inputParams.push({key: methodName, order, params: [size, momentum, {target, lag}]})
 
         return this
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ohlcv-indicators",
-  "version": "3.5.47",
+  "version": "3.5.49",
   "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/core-functions/mainLoop.js

@@ -3,6 +3,7 @@ import { validateInputParams } from "../utilities/validators.js";
 import { rsi } from "../oscillators/rsi.js";
 import { stochastic } from "../oscillators/stochastic.js";
 import { movingAverages } from "../moving-averages/movingAverages.js";
+import { heikenAshi } from "../moving-averages/heikenAshi.js";
 import { vidya } from "../moving-averages/vidya.js";
 import { macd } from "../moving-averages/macd.js";
 import { relativeVolume } from "../moving-averages/relativeVolume.js";
@@ -27,6 +28,7 @@ import { classifier } from "../machine-learning/classifier.js";
 // Map indicator keys to their respective functions
 const mainFunctions = {
   dateTime,
+  heikenAshi,
   rsi,
   stochastic,
   atr,

package/src/moving-averages/heikenAshi.js

@@ -0,0 +1,113 @@
+import { FasterEMA } from 'trading-signals';
+
+export const heikenAshi = (main, index, smoothLength, afterSmoothLength, {lag}) => {
+    const { verticalOhlcv, instances, len } = main
+    const prefix = `heiken_ashi_${smoothLength}_${afterSmoothLength}`
+    const keys = ['open', 'high', 'low', 'close']
+
+    // ---- INIT ----
+    if (index === 0) {
+
+        // Initialize pre-smoothing EMA instances and buffers
+        instances[prefix] = {
+            emaPre: Object.fromEntries(keys.map(k => [k, new FasterEMA(smoothLength)])),
+            emaPost: Object.fromEntries(keys.map(k => [k, new FasterEMA(afterSmoothLength)])),
+            prevHaOpen: NaN,
+            prevHaClose: NaN,
+            isTrendUp: false,
+        };
+
+        const keyNames = keys.map(k => `${prefix}_${k}`)
+
+        const verticalOhlcvSetup = Object.fromEntries([...keyNames, `${prefix}_cross`].map(v => [v, new Float64Array(len).fill(NaN)]))
+
+        Object.assign(verticalOhlcv, {...verticalOhlcvSetup})
+
+        if(lag > 0)
+        {
+            main.lag(keyNames, lag)
+        }
+    }
+
+    // ---- FETCH RAW INPUTS ----
+    const open = verticalOhlcv.open[index]
+    const high = verticalOhlcv.high[index]
+    const low = verticalOhlcv.low[index]
+    const close = verticalOhlcv.close[index]
+    const inst = instances[prefix]
+
+    // ---- PRE-SMOOTHING (EMA) ----
+    inst.emaPre.open.update(open)
+    inst.emaPre.high.update(high)
+    inst.emaPre.low.update(low)
+    inst.emaPre.close.update(close)
+
+    let sOpen, sHigh, sLow, sClose
+
+    try {
+        sOpen = inst.emaPre.open.getResult()
+        sHigh = inst.emaPre.high.getResult()
+        sLow = inst.emaPre.low.getResult()
+        sClose = inst.emaPre.close.getResult()
+    } catch {
+        return true; // skip if not enough data
+    }
+
+    // ---- HEIKEN ASHI CORE ----
+    const haClose = (sOpen + sHigh + sLow + sClose) / 4
+    const haOpen = (Number.isNaN(inst.prevHaOpen) || Number.isNaN(inst.prevHaClose)) ? (sOpen + sClose) / 2 : (inst.prevHaOpen + inst.prevHaClose) / 2
+    const haHigh = Math.max(sHigh, haOpen, haClose)
+    const haLow = Math.min(sLow, haOpen, haClose)
+
+    // Store for next round
+    inst.prevHaOpen = haOpen
+    inst.prevHaClose = haClose
+
+    // ---- POST-SMOOTHING (EMA) ----
+    inst.emaPost.open.update(haOpen)
+    inst.emaPost.high.update(haHigh)
+    inst.emaPost.low.update(haLow)
+    inst.emaPost.close.update(haClose)
+
+    let smOpen, smHigh, smLow, smClose
+
+    try {
+        smOpen = inst.emaPost.open.getResult()
+        smHigh = inst.emaPost.high.getResult()
+        smLow = inst.emaPost.low.getResult()
+        smClose = inst.emaPost.close.getResult()
+    } catch {
+        return true
+    }
+
+  // Cumulative cross counter: positive when uptrend, negative when downtrend
+    const prevCross = index > 0 ? verticalOhlcv[`${prefix}_cross`][index - 1] : 0
+    const prevHaOpen = index > 0 ? verticalOhlcv[`${prefix}_open`][index - 1] : NaN
+    const prevHaClose = index > 0 ? verticalOhlcv[`${prefix}_close`][index - 1] : NaN
+    const crossUp = !Number.isNaN(prevHaClose) && prevHaClose <= prevHaOpen && smClose > smOpen
+    const crossDown = !Number.isNaN(prevHaClose) && prevHaClose >= prevHaOpen && smClose < smOpen
+
+
+    if (crossUp) inst.isTrendUp = true;
+    if (crossDown) inst.isTrendUp = false;
+
+    let cross = 0
+
+    if (index > 0) {
+        if (inst.isTrendUp) {
+            cross = prevCross > 0 ? prevCross + 1 : 1
+        } else {
+            cross = prevCross < 0 ? prevCross - 1 : -1
+        }
+    }
+
+    // ---- 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 })
+
+
+  return true
+}