ohlcv-indicators 3.5.78 → 3.5.80

package/src/core-functions/pushToMain.js

@@ -2,34 +2,15 @@ export const pushToMain = ({main, index, key, value}) => {
 
     const {verticalOhlcv} = main
 
-    verticalOhlcv[key][index] = value    
-
-    return true
+    verticalOhlcv[key][index] = value
 }
 
-export const areKeyValuesValid = (main, index, keyNames) => {
-    
-    if(keyNames.length === 0) return false
-
-    const {verticalOhlcv} = main
-
-    let output = true
+export const areKeyValuesValid = (columns, index) => {
 
-    for(let x = 0 ; x < keyNames.length; x++)
-    {
-        const key = keyNames[x]
-        if(!verticalOhlcv.hasOwnProperty(key)) {
-            output = false
-            break
-        }
-
-        const val = verticalOhlcv[key][index]
-
-        if (val == null || Number.isNaN(val)) {
-            output = false
-            break
-        }
+    if (columns.length === 0) return false
+    for (let x = 0; x < columns.length; x++) {
+        const val = columns[x][index]
+        if (val == null || Number.isNaN(val)) return false
     }
-
-    return output
-}
+    return true
+}

package/src/core-indicators/README.md

@@ -0,0 +1,60 @@
+# Core indicators
+
+Local numeric `Faster*` indicator implementations. The existing constructor arguments, `update(value,
+replace?)`, `isStable`, and `getResult()` interface remain available. The
+numeric series also retain result/extrema and replacement semantics. These
+use ordinary JavaScript numbers, not arbitrary-precision decimal arithmetic.
+
+```js
+import { FasterEMA } from './index.js'
+
+const ema = new FasterEMA(14)
+ema.update(price)
+const value = ema.isStable ? ema.getResult() : NaN
+```
+
+`getResult()` still throws `NotEnoughDataError` during warm-up for API
+compatibility. All readiness checks are non-throwing; project handlers check
+readiness before reading. EMA still returns its provisional result from
+`update()` before it becomes stable, so do not substitute that return value
+for a readiness-checked read.
+
+## Storage and calculation choices
+
+- EMA uses scalar state and a readiness counter.
+- SMA uses a bounded circular `Float64Array`. It sums oldest to newest to
+  preserve floating-point rounding and recovery after NaN/Infinity. It remains
+  O(period) per update rather than adopting a different running-sum formula.
+- WSMA releases its seed SMA after initialization, then updates in O(1).
+- RSI retains two prices instead of the entire input history.
+- MACD uses a capped counter instead of retaining an unused price window.
+- Bollinger uses a bounded numeric ring and two ordered passes, without
+  intermediate deviation arrays. Its size + 1 warm-up is intentional.
+- Stochastic uses a bounded candle-reference ring, scans extrema without
+  temporary arrays, and preserves the original zero/NaN smoothing behavior.
+- TR/ATR/DX/ADX retain the existing arithmetic and replacement behavior.
+
+Scalar rings switch once to a bounded ordinary Array if a non-number is
+provided. This preserves existing JavaScript coercion for custom mapped
+columns without adding object storage for normal numeric input. NaN and
+Infinity remain numeric values and do not trigger this fallback. Candle
+references are retained where the reference implementation observes mutations
+of previously supplied objects. Private buffer layouts intentionally differ.
+
+## Verification
+
+`npm test` checks known core results and fixed behavior traces captured before
+runtime optimizations, checks bounded retained storage, and exercises all
+public indicators, precision/log modes, lags, and config replay.
+These checks are self-contained: no third-party indicator library or test
+oracle is installed. Preserve the trace expectations unless intentionally
+changing the corresponding behavior.
+
+`node test/test.js --baseline /path/to/original/index.js --benchmark` also
+compares the full pipeline with a pre-change checkout. Benchmarks report
+local timings and retained array slots/buffer bytes, not total heap usage or
+performance guarantees. Results must remain exact; changing summation order,
+warm-up, or quirks is a separate behavior change.
+
+Adapted portions retain the upstream MIT notice in `indicator.js`, also
+preserved in the generated distribution's license notice.

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,81 @@
+/*!
+ * 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,14 +1,20 @@
-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'
+import { mathLog } from '../utilities/math.js'
 
-export const bollingerBands = (main, index, size, stdDev, { lag } = {}) => {
+export const bollingerBands = (main, index, size, stdDev, { lag, retLogs = false } = {}) => {
   const { verticalOhlcv, instances, useFullNames } = main
   const indicatorKey = `${size}_${stdDev}`
-  const prefix = 'bollinger_bands'
+  const instanceKey = `${retLogs ? 'ret_log_' : ''}${indicatorKey}`
+  const prefix = `${retLogs ? 'ret_log_' : ''}bollinger_bands`
   const target = 'close'
 
   // 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}"`)
@@ -27,54 +33,56 @@ export const bollingerBands = (main, index, size, stdDev, { lag } = {}) => {
       }
     }
 
-    instances.bollinger_bands.settings[indicatorKey] = new FasterBollingerBands(size, stdDev)
+    instances.bollinger_bands.settings[instanceKey] = new FasterBollingerBands(size, stdDev)
 
     const suffix = (numberOfIndicators > 1 || useFullNames) ? `_${indicatorKey}` : ''
 
-    const keyNames = [
+    const keyNames = retLogs ? [
+      `${prefix}_width${suffix}`,
+      `${prefix}_position${suffix}`,
+    ] : [
       `${prefix}_upper${suffix}`,
       `${prefix}_middle${suffix}`,
       `${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: !retLogs && priceBased.has(target)
+    })), { lag })
   }
 
   const { numberOfIndicators } = instances.bollinger_bands
   const suffix = (numberOfIndicators > 1 || useFullNames) ? `_${indicatorKey}` : ''
 
-  const instance = instances.bollinger_bands.settings[indicatorKey]
+  const instance = instances.bollinger_bands.settings[instanceKey]
   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
   const lower = result?.lower ?? NaN
 
+  if (retLogs) {
+    let width = NaN
+    let position = NaN
+    const rangeRatio = upper / lower
+    if (lower > 0 && upper >= lower && Number.isFinite(upper) && Number.isFinite(rangeRatio)) {
+      const logRange = mathLog(rangeRatio, 1)
+      width = logRange / 2
+      const locationRatio = value / lower
+      if (logRange > 0 && value > 0 && locationRatio > 0 && Number.isFinite(locationRatio)) {
+        const normalized = 2 * mathLog(locationRatio, 1) / logRange - 1
+        if (Number.isFinite(normalized)) position = normalized
+      }
+    }
+    main.pushToMain({ index, key: `${prefix}_width${suffix}`, value: width })
+    main.pushToMain({ index, key: `${prefix}_position${suffix}`, value: position })
+    return
+  }
+
   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
-}
+}