ohlcv-indicators 3.5.78 → 3.5.79

package/src/core-indicators/composites.js

@@ -0,0 +1,136 @@
+import { Indicator } from './indicator.js'
+import { FasterSMA } from './movingAverages.js'
+
+export class FasterBollingerBands extends Indicator {
+  constructor(interval, deviationMultiplier = 2) {
+    super()
+    this.interval = interval
+    this.deviationMultiplier = deviationMultiplier
+    this.prices = new Float64Array(interval)
+    this.count = 0
+    this.head = 0
+  }
+
+  update(price) {
+    // Custom Array-backed columns may contain raw values whose addition must not be coerced.
+    if (typeof price !== 'number' && !Array.isArray(this.prices)) {
+      this.prices = Array.from(this.prices)
+    }
+
+    if (this.count < this.interval) {
+      this.prices[this.count++] = price
+      return
+    }
+
+    // The first full window is deliberately skipped, matching the original warm-up.
+    this.prices[this.head] = price
+    this.head = (this.head + 1) % this.interval
+
+    let sum = 0
+    let slot = this.head
+    for (let i = 0; i < this.count; i++) {
+      sum += this.prices[slot]
+      if (++slot === this.interval) slot = 0
+    }
+    const middle = this.count ? sum / this.count : 0
+    let deviationMiddle = middle
+    if (!deviationMiddle && Array.isArray(this.prices)) {
+      // Match the original average || fallback, including repeated raw-value coercion.
+      sum = 0
+      slot = this.head
+      for (let i = 0; i < this.count; i++) {
+        sum += this.prices[slot]
+        if (++slot === this.interval) slot = 0
+      }
+      deviationMiddle = this.count ? sum / this.count : 0
+    }
+
+    // Re-sum in chronological order; a rolling variance changes floating-point results.
+    let squaredSum = 0
+    slot = this.head
+    for (let i = 0; i < this.count; i++) {
+      const difference = this.prices[slot] - deviationMiddle
+      squaredSum += difference * difference
+      if (++slot === this.interval) slot = 0
+    }
+    const standardDeviation = Math.sqrt(this.count ? squaredSum / this.count : 0)
+
+    return (this.result = {
+      lower: middle - standardDeviation * this.deviationMultiplier,
+      middle,
+      upper: middle + standardDeviation * this.deviationMultiplier
+    })
+  }
+}
+
+export class FasterMACD extends Indicator {
+  constructor(short, long, signal) {
+    super()
+    this.short = short
+    this.long = long
+    this.signal = signal
+    this.pricesCounter = 0
+  }
+
+  update(price, replace = false) {
+    if (!replace || this.pricesCounter === 0) this.pricesCounter++
+
+    const short = this.short.update(price, replace)
+    const long = this.long.update(price, replace)
+
+    if (this.pricesCounter > this.long.interval) this.pricesCounter--
+    if (this.pricesCounter === this.long.interval) {
+      const macd = short - long
+      const signal = this.signal.update(macd, replace)
+      return (this.result = { histogram: macd - signal, macd, signal })
+    }
+  }
+}
+
+export class FasterStochasticOscillator extends Indicator {
+  constructor(n, m, p) {
+    super()
+    this.n = n
+    this.m = m
+    this.p = p
+    this.periodM = new FasterSMA(m)
+    this.periodP = new FasterSMA(p)
+    // Keep candle references: callers may reuse or mutate objects retained in the window.
+    this.candles = new Array(n)
+    this.count = 0
+    this.head = 0
+  }
+
+  update(candle) {
+    if (this.count < this.n) {
+      this.candles[this.count++] = candle
+    } else {
+      this.candles[this.head] = candle
+      this.head = (this.head + 1) % this.n
+    }
+
+    if (this.count === this.n) {
+      let highest = -Infinity
+      let lowest = Infinity
+      let slot = this.head
+      for (let i = 0; i < this.count; i++) {
+        highest = Math.max(highest, this.candles[slot].high)
+        if (++slot === this.n) slot = 0
+      }
+      slot = this.head
+      for (let i = 0; i < this.count; i++) {
+        lowest = Math.min(lowest, this.candles[slot].low)
+        if (++slot === this.n) slot = 0
+      }
+
+      const divisor = highest - lowest
+      const fastK = ((candle.close - lowest) * 100) / (divisor === 0 ? 1 : divisor)
+      const stochK = this.periodM.update(fastK)
+      // Zero and NaN deliberately skip periodP, while still producing a result.
+      const stochD = stochK && this.periodP.update(stochK)
+      if (stochK !== undefined && stochD !== undefined) {
+        return (this.result = { stochD, stochK })
+      }
+    }
+  }
+}

package/src/core-indicators/index.js

@@ -0,0 +1,5 @@
+export { NotEnoughDataError } from './indicator.js'
+export { FasterEMA, FasterSMA, FasterWSMA } from './movingAverages.js'
+export { FasterRSI } from './rsi.js'
+export { FasterTR, FasterATR, FasterDX, FasterADX } from './volatility.js'
+export { FasterBollingerBands, FasterMACD, FasterStochasticOscillator } from './composites.js'

package/src/core-indicators/indicator.js

@@ -0,0 +1,82 @@
+/*!
+ * Portions adapted from trading-signals 5.0.4.
+ * MIT License
+ * Copyright (c) 2020 Benny Neugebauer
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+export class NotEnoughDataError extends Error {
+    constructor(message = 'Not enough data') {
+        super(message)
+        this.name = 'NotEnoughDataError'
+    }
+}
+
+export class Indicator {
+    result
+
+    get isStable() {
+        return this.result !== undefined
+    }
+
+    getResult() {
+        if (!this.isStable) throw new NotEnoughDataError()
+        return this.result
+    }
+}
+
+// Keep the public result/extrema and replacement semantics without price history.
+export class NumberIndicator extends Indicator {
+    previousResult
+    highest
+    lowest
+    previousHighest
+    previousLowest
+
+    setResult(value, replace = false) {
+        if (replace) {
+            this.highest = this.previousHighest
+            this.lowest = this.previousLowest
+            this.result = this.previousResult
+        }
+        if (this.highest === undefined) this.highest = value
+        else {
+            this.previousHighest = this.highest
+            if (value > this.highest) this.highest = value
+        }
+        if (this.lowest === undefined) this.lowest = value
+        else {
+            this.previousLowest = this.lowest
+            if (value < this.lowest) this.lowest = value
+        }
+        this.previousResult = this.result
+        this.result = value
+        return value
+    }
+
+    replace(input) {
+        return this.update(input, true)
+    }
+
+    updates(prices) {
+        prices.forEach(price => this.update(price))
+        return this.result
+    }
+}

package/src/core-indicators/movingAverages.js

@@ -0,0 +1,88 @@
+import { NumberIndicator } from './indicator.js'
+
+export class FasterEMA extends NumberIndicator {
+    constructor(interval) {
+        super()
+        this.interval = interval
+        this.pricesCounter = 0
+        this.weightFactor = 2 / (interval + 1)
+    }
+
+    update(price, replace = false) {
+        if (!replace || this.pricesCounter === 0) this.pricesCounter++
+
+        const previous = replace && this.previousResult !== undefined
+            ? this.previousResult
+            : this.result !== undefined ? this.result : price
+
+        return this.setResult(price * this.weightFactor + previous * (1 - this.weightFactor), replace)
+    }
+
+    get isStable() {
+        return this.pricesCounter >= this.interval
+    }
+}
+
+export class FasterSMA extends NumberIndicator {
+    constructor(interval) {
+        super()
+        this.interval = interval
+        this.prices = new Float64Array(interval)
+        this.count = 0
+        this.head = 0
+    }
+
+    update(price, replace = false) {
+        // Custom columns may contain raw values after their validated first row.
+        // Retain JavaScript addition/coercion semantics without slowing numeric windows.
+        if (typeof price !== 'number' && !Array.isArray(this.prices)) {
+            this.prices = Array.from(this.prices)
+        }
+        const { interval, prices } = this
+
+        if (replace && this.count) {
+            let last = this.head + this.count - 1
+            if (last >= interval) last -= interval
+            prices[last] = price
+        } else if (this.count < interval) {
+            prices[this.count++] = price
+        } else {
+            prices[this.head] = price
+            if (++this.head === interval) this.head = 0
+        }
+
+        if (this.count === interval) {
+            // Preserve chronological addition order, including NaN/Infinity recovery.
+            let sum = 0
+            for (let i = this.head; i < interval; i++) sum += prices[i]
+            for (let i = 0; i < this.head; i++) sum += prices[i]
+            return this.setResult(sum / interval, replace)
+        }
+    }
+}
+
+export class FasterWSMA extends NumberIndicator {
+    constructor(interval) {
+        super()
+        this.interval = interval
+        this.indicator = new FasterSMA(interval)
+        this.smoothingFactor = 1 / interval
+    }
+
+    update(price, replace = false) {
+        if (this.result === undefined) {
+            // The existing FasterWSMA appends seed samples even for replacement updates.
+            const sma = this.indicator.update(price)
+            if (sma !== undefined) {
+                this.indicator = undefined
+                return this.setResult(sma, replace)
+            }
+        } else if (replace && this.previousResult !== undefined) {
+            const smoothed = (price - this.previousResult) * this.smoothingFactor
+            return this.setResult(smoothed + this.previousResult, replace)
+        } else if (!replace) {
+            const smoothed = (price - this.result) * this.smoothingFactor
+            return this.setResult(smoothed + this.result, replace)
+        }
+    }
+}

package/src/core-indicators/rsi.js

@@ -0,0 +1,41 @@
+import { NumberIndicator } from './indicator.js';
+import { FasterWSMA } from './movingAverages.js';
+
+export class FasterRSI extends NumberIndicator {
+  constructor(interval, SmoothingIndicator = FasterWSMA) {
+    super();
+    this.interval = interval;
+    this.avgGain = new SmoothingIndicator(interval);
+    this.avgLoss = new SmoothingIndicator(interval);
+    this.maxValue = 100;
+    this.priceCount = 0;
+    this.previousPrice = undefined;
+    this.currentPrice = undefined;
+  }
+
+  update(price, replace = false) {
+    // Only the latest two prices are needed, including repeated replacements.
+    if (!replace || this.priceCount === 0) {
+      this.previousPrice = this.currentPrice;
+      if (this.priceCount < 2) this.priceCount++;
+    }
+    this.currentPrice = price;
+    if (this.priceCount < 2) return;
+
+    const previousPrice = this.previousPrice;
+    if (price > previousPrice) {
+      this.avgLoss.update(0, replace);
+      this.avgGain.update(price - previousPrice, replace);
+    } else {
+      this.avgLoss.update(previousPrice - price, replace);
+      this.avgGain.update(0, replace);
+    }
+
+    if (this.avgGain.isStable) {
+      const avgLoss = this.avgLoss.getResult();
+      if (avgLoss === 0) return this.setResult(100, replace);
+      const relativeStrength = this.avgGain.getResult() / avgLoss;
+      return this.setResult(this.maxValue - this.maxValue / (relativeStrength + 1), replace);
+    }
+  }
+}

package/src/core-indicators/volatility.js

@@ -0,0 +1,107 @@
+import { NumberIndicator } from './indicator.js';
+import { FasterWSMA } from './movingAverages.js';
+
+export class FasterTR extends NumberIndicator {
+  constructor() {
+    super();
+    this.previousCandle = undefined;
+    this.twoPreviousCandle = undefined;
+  }
+
+  update(candle, replace = false) {
+    const { high, low } = candle;
+    const highLow = high - low;
+    if (this.previousCandle && replace) this.previousCandle = this.twoPreviousCandle;
+    if (this.previousCandle) {
+      const highClose = Math.abs(high - this.previousCandle.close);
+      const lowClose = Math.abs(low - this.previousCandle.close);
+      this.twoPreviousCandle = this.previousCandle;
+      this.previousCandle = candle;
+      return this.setResult(Math.max(highLow, highClose, lowClose), replace);
+    }
+    this.twoPreviousCandle = this.previousCandle;
+    this.previousCandle = candle;
+    return this.setResult(highLow, replace);
+  }
+}
+
+export class FasterATR extends NumberIndicator {
+  constructor(interval, SmoothingIndicator = FasterWSMA) {
+    super();
+    this.interval = interval;
+    this.tr = new FasterTR();
+    this.smoothing = new SmoothingIndicator(interval);
+  }
+
+  update(candle, replace = false) {
+    const trueRange = this.tr.update(candle, replace);
+    this.smoothing.update(trueRange, replace);
+    if (this.smoothing.isStable) return this.setResult(this.smoothing.getResult(), replace);
+  }
+}
+
+export class FasterDX extends NumberIndicator {
+  constructor(interval, SmoothingIndicator = FasterWSMA) {
+    super();
+    this.interval = interval;
+    this.atr = new FasterATR(interval, SmoothingIndicator);
+    this.movesDown = new SmoothingIndicator(interval);
+    this.movesUp = new SmoothingIndicator(interval);
+    this.previousCandle = undefined;
+    this.mdi = undefined;
+    this.pdi = undefined;
+  }
+
+  updateState(candle, pdm = 0, mdm = 0) {
+    this.atr.update(candle);
+    this.movesUp.update(pdm);
+    this.movesDown.update(mdm);
+    this.previousCandle = candle;
+  }
+
+  update(candle) {
+    if (!this.previousCandle) {
+      this.updateState(candle);
+      return;
+    }
+    const higherHigh = candle.high - this.previousCandle.high;
+    const lowerLow = this.previousCandle.low - candle.low;
+    const pdm = higherHigh < 0 || higherHigh < lowerLow ? 0 : higherHigh;
+    const mdm = lowerLow < 0 || lowerLow < higherHigh ? 0 : lowerLow;
+    this.updateState(candle, pdm, mdm);
+
+    if (this.movesUp.isStable) {
+      const atr = this.atr.getResult();
+      this.pdi = this.movesUp.getResult() / atr;
+      this.mdi = this.movesDown.getResult() / atr;
+      const dmDiff = Math.abs(this.pdi - this.mdi);
+      const dmSum = this.pdi + this.mdi;
+      if (dmSum === 0) return this.setResult(0, false);
+      return this.setResult((dmDiff / dmSum) * 100, false);
+    }
+  }
+}
+
+export class FasterADX extends NumberIndicator {
+  constructor(interval, SmoothingIndicator = FasterWSMA) {
+    super();
+    this.interval = interval;
+    this.adx = new SmoothingIndicator(interval);
+    this.dx = new FasterDX(interval, SmoothingIndicator);
+  }
+
+  get mdi() {
+    return this.dx.mdi;
+  }
+
+  get pdi() {
+    return this.dx.pdi;
+  }
+
+  update(candle, replace = false) {
+    // DX/smoothing intentionally advance on replace, matching the existing API.
+    const result = this.dx.update(candle);
+    if (result !== undefined) this.adx.update(result);
+    if (this.adx.isStable) return this.setResult(this.adx.getResult(), replace);
+  }
+}

package/src/moving-averages/bollingerBands.js

@@ -1,4 +1,6 @@
-import { FasterBollingerBands } from 'trading-signals'
+import { FasterBollingerBands } from '../core-indicators/index.js'
+import { validateInputValues } from '../utilities/validators.js'
+import { initializeColumns } from '../core-functions/initializeColumns.js'
 
 export const bollingerBands = (main, index, size, stdDev, { lag } = {}) => {
   const { verticalOhlcv, instances, useFullNames } = main
@@ -8,7 +10,9 @@ export const bollingerBands = (main, index, size, stdDev, { lag } = {}) => {
 
   // Initialization on the first call.
   if (index === 0) {
-    const { inputParams, verticalOhlcv, len, priceBased } = main
+    const { inputParams, verticalOhlcv, priceBased } = main
+
+    validateInputValues({ [target]: true }, verticalOhlcv, index, 'bollingerBands')
 
     if (!(target in verticalOhlcv)) {
       throw new Error(`bollingerBands could not find target "${target}"`)
@@ -37,21 +41,9 @@ export const bollingerBands = (main, index, size, stdDev, { lag } = {}) => {
       `${prefix}_lower${suffix}`,
     ]
 
-    if (priceBased.has(target)) {
-      for (const k of keyNames) {
-        priceBased.add(k)
-      }
-    }
-
-    const verticalOhlcvSetup = Object.fromEntries(
-      keyNames.map(v => [v, new Float64Array(len).fill(NaN)])
-    )
-
-    Object.assign(verticalOhlcv, { ...verticalOhlcvSetup })
-
-    if (lag > 0) {
-      main.lag(keyNames, lag)
-    }
+    initializeColumns(main, keyNames.map(key => ({
+      key, priceBased: priceBased.has(target)
+    })), { lag })
   }
 
   const { numberOfIndicators } = instances.bollinger_bands
@@ -61,12 +53,7 @@ export const bollingerBands = (main, index, size, stdDev, { lag } = {}) => {
   const value = verticalOhlcv[target][index]
   instance.update(value)
 
-  let result = {}
-  try {
-    result = instance.getResult()
-  } catch (err) {
-    // If not available, result stays {}.
-  }
+  const result = instance.isStable ? instance.getResult() : null
 
   const upper = result?.upper ?? NaN
   const middle = result?.middle ?? NaN
@@ -75,6 +62,4 @@ export const bollingerBands = (main, index, size, stdDev, { lag } = {}) => {
   main.pushToMain({ index, key: `${prefix}_upper${suffix}`, value: upper })
   main.pushToMain({ index, key: `${prefix}_middle${suffix}`, value: middle })
   main.pushToMain({ index, key: `${prefix}_lower${suffix}`, value: lower })
-
-  return true
-}
+}

package/src/moving-averages/donchianChannel.js

@@ -1,10 +1,15 @@
+import { validateInputValues } from '../utilities/validators.js'
+import { initializeColumns } from '../core-functions/initializeColumns.js'
+
 export const donchianChannels = (main, index, size, offset, options) => {
-  const { verticalOhlcv, instances, len, inputParams, priceBased, useFullNames } = main
+  const { verticalOhlcv, instances, len, inputParams, useFullNames } = main
   const { lag: outputLag = 0 } = options
   const indicatorKey = `${size}_${offset}`
 
   // ---- INIT (only at first bar) ----
   if (index === 0) {
+    validateInputValues({ high: true, low: true }, verticalOhlcv, index, 'donchianChannels')
+
     const numberOfIndicators = inputParams.filter(o => o.key === 'donchianChannels').length
     const useIndexedKeys = numberOfIndicators > 1 || useFullNames
 
@@ -15,25 +20,17 @@ export const donchianChannels = (main, index, size, offset, options) => {
 
     const keys = ['upper', 'basis', 'lower'].map(getKey)
 
-    for (const k of keys) {
-      priceBased.add(k)
-    }
-
     if (!instances.donchian_channel) {
       instances.donchian_channel = { numberOfIndicators, settings: {} }
     }
 
     instances.donchian_channel.numberOfIndicators = numberOfIndicators
-    instances.donchian_channel.settings[indicatorKey] = { maxDeque: [], minDeque: [] }
-
-    Object.assign(
-      verticalOhlcv,
-      Object.fromEntries(keys.map(k => [k, new Float64Array(len).fill(NaN)]))
-    )
-
-    if (outputLag > 0) {
-      main.lag(keys, outputLag)
+    instances.donchian_channel.settings[indicatorKey] = {
+      maxDeque: { indices: [], head: 0, length: 0 },
+      minDeque: { indices: [], head: 0, length: 0 }
     }
+
+    initializeColumns(main, keys.map(key => ({ key, priceBased: true })), { lag: outputLag })
   }
 
   // ---- PER-BAR COMPUTATION ----
@@ -49,34 +46,38 @@ export const donchianChannels = (main, index, size, offset, options) => {
   const current = index - offset
   const start = current - size + 1
 
-  const outKeys = ['upper', 'basis', 'lower'].map(getKey)
-
-  if (start < 0 || current + 1 > len) {
-    outKeys.forEach(key =>
-      main.pushToMain({ index, key, value: NaN })
-    )
-    return true
-  }
+  // No source candle is available yet.
+  if (current < 0 || current >= len) return
 
   const { high: highs, low: lows } = verticalOhlcv
 
   const update = (dq, arr, cmp) => {
-    while (dq.length && dq[0] < start) dq.shift()
-    while (dq.length && cmp(arr[dq.at(-1)], arr[current])) dq.pop()
-    dq.push(current)
+    const { indices } = dq
+    while (dq.length && indices[dq.head] < start) {
+      dq.head = (dq.head + 1) % size
+      dq.length--
+    }
+    while (dq.length && cmp(arr[indices[(dq.head + dq.length - 1) % size]], arr[current])) {
+      dq.length--
+    }
+    // Reuse at most size slots instead of moving entries or growing with the input.
+    indices[(dq.head + dq.length) % size] = current
+    dq.length++
   }
 
   update(maxDeque, highs, (a, b) => a <= b)
   update(minDeque, lows, (a, b) => a >= b)
 
+  // Collect warm-up candles, but leave outputs as NaN until the window is complete.
+  if (start < 0) return
+
   const hasBounds = maxDeque.length && minDeque.length
-  const upper = hasBounds ? highs[maxDeque[0]] : NaN
-  const lower = hasBounds ? lows[minDeque[0]] : NaN
+  const upper = hasBounds ? highs[maxDeque.indices[maxDeque.head]] : NaN
+  const lower = hasBounds ? lows[minDeque.indices[minDeque.head]] : NaN
   const basis = hasBounds ? (upper + lower) / 2 : NaN
 
   main.pushToMain({ index, key: getKey('upper'), value: upper })
   main.pushToMain({ index, key: getKey('basis'), value: basis })
   main.pushToMain({ index, key: getKey('lower'), value: lower })
 
-  return true
-}
+}