ohlcv-indicators 3.5.78 → 3.5.79

package/dist/ohlcv-indicators.min.js.LICENSE.txt

@@ -0,0 +1,23 @@
+/*!
+ * 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.
+ */

package/index.js

@@ -10,11 +10,10 @@ import {
     validateString
 } from './src/utilities/validators.js'
 import { verticalToHorizontal } from './src/utilities/verticalToHorizontal.js'
-import { pushToMain } from './src/core-functions/pushToMain.js'
 import { assignTypes } from './src/utilities/assignTypes.js'
 import { dateOutputFormaters } from './src/utilities/dateUtilities.js'
-import { defaultMapColsCallback } from './src/studies/mapCols.js'
 import { calcPrecisionMultiplier } from './src/utilities/precisionMultiplier.js'
+import { CONFIG_VERSION, copyConfig, freezeConfig, registerMapCallback, resolveMapCallback, exportInputParams } from './src/utilities/config.js'
 
 /**
  * Class OHLCV_INDICATORS
@@ -25,14 +24,41 @@ import { calcPrecisionMultiplier } from './src/utilities/precisionMultiplier.js'
  */
 
 export default class OHLCV_INDICATORS {
-    constructor({input, ticker = null, inputParams = null, chunkProcess = 2000, precision = false, useFullNames = false}) {
+    constructor({input, ticker = null, chunkProcess = 2000, config = {}}) {
+
+        if (config === null || Array.isArray(config) || typeof config !== 'object') {
+            throw new TypeError('Constructor "config" must be a plain object.')
+        }
+        const savedConfig = copyConfig(config)
+        const configKeys = ['schemaVersion', 'precision', 'useFullNames', 'inputParams', 'dateFormat', 'skipNull', 'timeZone']
+        for (const key of Object.keys(savedConfig)) {
+            if (!configKeys.includes(key)) throw new Error(`Unknown configuration option "${key}".`)
+        }
+        const {
+            schemaVersion = CONFIG_VERSION,
+            precision = false,
+            useFullNames = false,
+            inputParams = null,
+            dateFormat = 'milliseconds',
+            skipNull = true,
+            timeZone = Intl.DateTimeFormat().resolvedOptions().timeZone
+        } = savedConfig
+
+        if (schemaVersion !== CONFIG_VERSION) throw new Error(`Unsupported configuration schemaVersion: ${schemaVersion}.`)
+        validateBoolean(skipNull, 'config.skipNull', 'constructor')
+        validateString(dateFormat, 'config.dateFormat', 'constructor')
+        validateArrayOptions(Object.keys(dateOutputFormaters), dateFormat, 'config.dateFormat', 'constructor')
+        validateString(timeZone, 'config.timeZone', 'constructor')
+        const resolvedTimeZone = new Intl.DateTimeFormat('en-US', { timeZone }).resolvedOptions().timeZone
+        this.config = Object.freeze({ schemaVersion, precision, useFullNames, dateFormat, skipNull, timeZone: resolvedTimeZone })
+        this.timeZone = resolvedTimeZone
 
         validateArray(input, 'input', (ticker !== null) ? `contructor ${ticker}` : 'constuctor')
         if(input.length === 0) throw Error('input OHLCV must not be empty: ' + ticker)
 
         validateNumber(chunkProcess, {min: 100, max: 50000, allowDecimals: false}, 'chunkProcess', 'constructor')
         validateBoolean(precision, 'precision', 'contructor')
-        validateBoolean(precision, 'useFullNames', 'contructor')
+        validateBoolean(useFullNames, 'config.useFullNames', 'constructor')
 
         this.chunkProcess = chunkProcess
         
@@ -56,6 +82,8 @@ export default class OHLCV_INDICATORS {
 
         this.dateType = this.inputTypes.date ? this.inputTypes.date : null;
         this.isComputed = false
+        this.isComputing = false
+        this.executionParams = []
 
         this.instances = {}
         this.verticalOhlcv = {}
@@ -67,17 +95,19 @@ export default class OHLCV_INDICATORS {
         this.scaledGroups = {}
         this.isAlreadyComputed = new Set()
 
-        this.pushToMain = ({index, key, value}) => pushToMain({main: this, index, key, value})
+        this.pushToMain = ({index, key, value}) => {
+            this.verticalOhlcv[key][index] = value
+        }
         
         if(inputParams !== null)
         {
             validateInputParams(inputParams, this.len)
-            this.inputParams = inputParams.sort((a, b) => a.order - b.order)
+            this.inputParams = freezeConfig(copyConfig(inputParams))
             this.compute()
         }
         else
         {
-            this.inputParams = []
+            this.inputParams = Object.freeze([])
         }
 
         
@@ -86,12 +116,27 @@ export default class OHLCV_INDICATORS {
     }
 
 
+    static registerMapCallback(name, callback) {
+        registerMapCallback(name, callback)
+        return this
+    }
+
+    exportConfig() {
+        return { ...this.config, inputParams: exportInputParams(this.inputParams) }
+    }
+
+    _registerIndicator(job) {
+        isAlreadyComputed(this)
+        this.inputParams = Object.freeze([...this.inputParams, freezeConfig(copyConfig(job, true))])
+        return this
+    }
+
     getData(options = {}) {
 
         //getData method returns the last object (row) of the new OHLCV with indicators: {open, high, low, close, rsi_14, bollinger_bands_upper}
         this.compute()
 
-        const {skipNull = true, dateFormat = 'milliseconds'} = options
+        const {skipNull = this.config.skipNull, dateFormat = this.config.dateFormat} = options
 
         validateArrayOptions(Object.keys(dateOutputFormaters), dateFormat, 'dateFormat', 'getData')
         validateObject(options, 'options', 'getData')
@@ -109,7 +154,7 @@ export default class OHLCV_INDICATORS {
 
         this.compute()
 
-        const {dateFormat = 'milliseconds'} = options
+        const {dateFormat = this.config.dateFormat} = options
         
         validateArrayOptions(Object.keys(dateOutputFormaters), dateFormat, 'dateFormat', 'getData')
 
@@ -128,7 +173,13 @@ export default class OHLCV_INDICATORS {
           return this;
         }
 
-        this.inputParams = this.inputParams.sort((a, b) => a.order - b.order)
+        if (this.isComputing) throw new Error('Computation is already in progress.')
+
+        this.executionParams = copyConfig(this.inputParams, true)
+            .sort((a, b) => (a.order ?? 0) - (b.order ?? 0))
+        for (const job of this.executionParams) {
+            if (job.key === 'mapCols') job.params[1] = resolveMapCallback(job.params[1])
+        }
       
         // Mark as “in progress”
         this.isComputed = false;
@@ -139,7 +190,12 @@ export default class OHLCV_INDICATORS {
         // Only run the full loop once (or when new data appears later,
         // if you extend this to reset isComputed elsewhere)
         if (this.len > 0) {
-            mainLoop(this.input, this)
+            this.isComputing = true
+            try {
+                mainLoop(this.input, this)
+            } finally {
+                this.isComputing = false
+            }
 
             this.isComputed = true;
 
@@ -187,7 +243,7 @@ export default class OHLCV_INDICATORS {
 
         this.isAlreadyComputed.add(methodName)
 
-        this.inputParams.push({key: methodName, params: [arr, {limit, oneHot}]})
+        this._registerIndicator({key: methodName, params: [arr, {limit, oneHot}]})
         
         return this
     }
@@ -201,7 +257,7 @@ export default class OHLCV_INDICATORS {
         validateArray(colKeys, 'colKeys', methodName)
         validateNumber(lookback, {min:1, max: this.len, allowDecimals: false}, 'lookback', methodName)
 
-        this.inputParams.push({key: methodName, params: [colKeys, lookback]})
+        this._registerIndicator({key: methodName, params: [colKeys, lookback]})
         
         return this;
     }
@@ -223,7 +279,7 @@ export default class OHLCV_INDICATORS {
 
         validateNumber(lag, {min: 0, max: this.len, allowDecimals: false}, 'options.lag', methodName)
 
-        this.inputParams.push({key: methodName, order: 0, params: [size, {lag}]})
+        this._registerIndicator({key: methodName, order: 0, params: [size, {lag}]})
  
         return this
     }
@@ -244,7 +300,7 @@ export default class OHLCV_INDICATORS {
 
         validateNumber(lag, {min: 0, max: this.len, allowDecimals: false}, 'options.lag', methodName)
 
-        this.inputParams.push({key: methodName, order: 0, params: [{lag}]})
+        this._registerIndicator({key: methodName, order: 0, params: [{lag}]})
  
         return this
     }
@@ -264,7 +320,7 @@ export default class OHLCV_INDICATORS {
         validateBoolean(retLogs, 'options.retLogs', methodName)
 
 
-        this.inputParams.push({key: methodName, order: 0, params: [size, {lag, retLogs}]})
+        this._registerIndicator({key: methodName, order: 0, params: [size, {lag, retLogs}]})
 
         return this
     }
@@ -284,7 +340,7 @@ export default class OHLCV_INDICATORS {
         validateBoolean(retLogs, 'options.retLogs', methodName)
 
 
-        this.inputParams.push({key: methodName, order: 0, params: [size, {lag, retLogs}]})
+        this._registerIndicator({key: methodName, order: 0, params: [size, {lag, retLogs}]})
 
         return this
     }
@@ -303,7 +359,7 @@ export default class OHLCV_INDICATORS {
         validateString(target, 'options.target', methodName)
         validateNumber(lag, {min: 0, max: this.len, allowDecimals: false}, 'options.lag', methodName)
 
-        this.inputParams.push({key: methodName, params: [methodName, size, {target, lag}]})
+        this._registerIndicator({key: methodName, params: [methodName, size, {target, lag}]})
 
         return this
     }
@@ -321,7 +377,7 @@ export default class OHLCV_INDICATORS {
         validateString(target, 'options.target', methodName)
         validateNumber(lag, {min: 0, max: this.len, allowDecimals: false}, 'options.lag', methodName)
 
-        this.inputParams.push({key: methodName, params: [methodName, size, {target, lag}]})
+        this._registerIndicator({key: methodName, params: [methodName, size, {target, lag}]})
 
         return this
     }
@@ -347,30 +403,7 @@ export default class OHLCV_INDICATORS {
 
         const order = 0
 
-        this.inputParams.push({key: methodName, order, params: [smoothLength, afterSmoothLength, {lag, bothNull, retLogs}]})
-
-        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(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
-
-        validateString(target, 'options.target', methodName)
-        validateNumber(lag, {min: 0, max: this.len, allowDecimals: false}, 'options.lag', methodName)
-        validateNumber(bandDistance, {min: 0.01, max: 10, allowDecimals: true}, 'options.bandDistance', methodName)
-        validateNumber(atrLength, {min: 2, max: this.len, allowDecimals: false}, 'options.atrLength', methodName)
-        validateNumber(liquidityLookback, {min: 1, max: this.len, allowDecimals: false}, 'options.liquidityLookback', methodName)
-
-        this.inputParams.push({key: methodName, params: [size, momentum, {target, lag}]})
+        this._registerIndicator({key: methodName, order, params: [smoothLength, afterSmoothLength, {lag, bothNull, retLogs}]})
 
         return this
     }
@@ -378,6 +411,8 @@ export default class OHLCV_INDICATORS {
     stochastic(kPeriod = 14, kSlowingPeriod = 3, dPeriod = 3, options = {}){
         const methodName = 'stochastic'
 
+        isAlreadyComputed(this)
+
         const {len: max} = this
 
         validateNumber(kPeriod, {min: 1, max, allowDecimals: false}, 'kPeriod', methodName)
@@ -390,7 +425,7 @@ export default class OHLCV_INDICATORS {
         validateNumber(lag, {min: 0, max, allowDecimals: false}, 'options.lag', methodName)
         validateBoolean(retLogs, 'retLogs', methodName)
 
-        this.inputParams.push({key: methodName, params: [kPeriod, kSlowingPeriod, dPeriod, {lag, retLogs}]})
+        this._registerIndicator({key: methodName, params: [kPeriod, kSlowingPeriod, dPeriod, {lag, retLogs}]})
 
         return this
     }
@@ -414,7 +449,7 @@ export default class OHLCV_INDICATORS {
         const instanceKey = `${fast}_${slow}_${signal}${target === 'close' ? '' : `_${target}`}`
         const precomputed = {instanceKey}
 
-        this.inputParams.push({key: methodName, params: [fast, slow, signal, {target, lag, precomputed}]})
+        this._registerIndicator({key: methodName, params: [fast, slow, signal, {target, lag, precomputed}]})
         
         return this
 
@@ -433,7 +468,7 @@ export default class OHLCV_INDICATORS {
 
         validateNumber(lag, {min: 0, max: this.len, allowDecimals: false}, 'options.lag', methodName)
   
-        this.inputParams.push({key: methodName, params: [size, stdDev, {lag}]});
+        this._registerIndicator({key: methodName, params: [size, stdDev, {lag}]});
     
         return this;
     }
@@ -453,7 +488,7 @@ export default class OHLCV_INDICATORS {
         validateNumber(lag, {min: 0, max: this.len, allowDecimals: false}, 'options.lag', methodName)
         validateBoolean(retLogs, 'retLogs', methodName)
 
-        this.inputParams.push({key: methodName, params: [size, {target, lag, retLogs}]})
+        this._registerIndicator({key: methodName, params: [size, {target, lag, retLogs}]})
 
         return this
     }
@@ -471,7 +506,7 @@ export default class OHLCV_INDICATORS {
       
         validateNumber(lag, {min: 0, max: this.len, allowDecimals: false}, 'options.lag', methodName)
       
-        this.inputParams.push({ key: methodName, order: 0, params: [size, offset, {lag}] });
+        this._registerIndicator({ key: methodName, order: 0, params: [size, offset, {lag}] });
       
         return this;
     }
@@ -491,11 +526,12 @@ export default class OHLCV_INDICATORS {
         validateNumber(slowsize, {min: fastsize, max: this.len, allowDecimals: false}, 'slowsize', methodName)
         validateObject(options, 'options', methodName)
 
-        const {lag = 0} = options
+        const {lag = 0, retLogs = false} = options
 
         validateNumber(lag, {min: 0, max: this.len, allowDecimals: false}, 'options.lag', methodName)
+        validateBoolean(retLogs, 'retLogs', methodName)
 
-        this.inputParams.push({key: methodName, order: 0, params: [fastsize, slowsize, {lag}]})
+        this._registerIndicator({key: methodName, order: 0, params: [fastsize, slowsize, {lag, retLogs}]})
         return this           
     }
     dateTime(options = {})
@@ -529,7 +565,7 @@ export default class OHLCV_INDICATORS {
             colKeys: Object.keys(colKeySizes)
         }
 
-        this.inputParams.push({key: methodName, order: 0, params: [{lag, oneHot, precompute}]})
+        this._registerIndicator({key: methodName, order: 0, params: [{lag, oneHot, precompute}]})
         return this           
     }
 
@@ -547,7 +583,7 @@ export default class OHLCV_INDICATORS {
         validateBoolean(retLogs, 'retLogs', methodName)
 
 
-        this.inputParams.push({key: methodName, params: [{lag, colKeys, retLogs}]})
+        this._registerIndicator({key: methodName, params: [{lag, colKeys, retLogs}]})
 
         return this
     }
@@ -560,12 +596,14 @@ export default class OHLCV_INDICATORS {
 
         if(typeof callback === 'undefined' || callback === null)
         {
-            callback = defaultMapColsCallback
+            callback = 'default'
         }
 
         validateObject(options, 'options', methodName)
 
-        const {lag = 0, isPriceBased = false} = options
+        const {lag = 0, isPriceBased = false, callbackParams = {}} = options
+        resolveMapCallback(callback)
+        const savedCallbackParams = copyConfig(callbackParams)
 
         validateArray(newCols, 'newCols', methodName)
         validateNumber(lag, {min: 0, allowDecimals: false}, 'options.lag', methodName)
@@ -575,7 +613,7 @@ export default class OHLCV_INDICATORS {
             throw new Error(`Invalid param: If "mapCols.options.isPriceBased" is true, the "constructor.precision" param must be also true.`)
         }
 
-        this.inputParams.push({key: methodName, params: [newCols, callback, {lag, isPriceBased}]})
+        this._registerIndicator({key: methodName, params: [newCols, callback, {lag, isPriceBased, callbackParams: savedCallbackParams}]})
 
         return this
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ohlcv-indicators",
-  "version": "3.5.78",
+  "version": "3.5.79",
   "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/initializeColumns.js

@@ -0,0 +1,40 @@
+import { buildArray } from '../utilities/assignTypes.js';
+import { validateNumber } from '../utilities/validators.js';
+
+// Called once by each indicator, inside its index === 0 block.
+export const initializeColumns = (main, columns, { lag = 0 } = {}) => {
+  const keyNames = [];
+  const lagKeys = [];
+
+  for (const {
+    key,
+    type = 'Float64Array',
+    fill,
+    enabled = true,
+    priceBased = false,
+    includeInLag = true
+  } of columns) {
+    if (!enabled) continue;
+
+    if (Object.prototype.hasOwnProperty.call(main.verticalOhlcv, key)) {
+      throw new Error(`Output column "${key}" already exists in verticalOhlcv.`);
+    }
+
+    // Integer arrays cannot represent the default missing value, NaN.
+    if (/^(?:Int|Uint)/.test(type) && fill === undefined) {
+      throw new Error(`Integer output column "${key}" requires an explicit fill value.`);
+    }
+
+    main.verticalOhlcv[key] = buildArray(type, main.len, fill);
+    if (priceBased) main.priceBased.add(key);
+    keyNames.push(key);
+    if (includeInLag) lagKeys.push(key);
+  }
+
+  if (lag > 0 && lagKeys.length > 0) {
+    validateNumber(lag, { min: 1, max: main.len }, 'lag', 'initializeColumns');
+    main.executionParams.push({ key: 'lag', params: [lagKeys, lag] });
+  }
+
+  return keyNames;
+};

package/src/core-functions/mainLoop.js

@@ -4,7 +4,6 @@ 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";
 import { donchianChannels } from "../moving-averages/donchianChannel.js";
@@ -35,7 +34,6 @@ const mainFunctions = {
   adx,
   ema: movingAverages,
   sma: movingAverages,
-  vidya,
   macd,
   volumeDelta,
   relativeVolume,
@@ -56,17 +54,33 @@ export const mainLoop = (input, main) => {
     inputTypes, 
     chunkProcess, 
     precisionMultiplier,
-    inputParams
+    executionParams
   } = main;
 
 
-  validateInputParams(inputParams, len)
+  validateInputParams(executionParams, len)
+  for (const { key } of executionParams) {
+    if (!Object.prototype.hasOwnProperty.call(mainFunctions, key)) {
+      throw new Error(`Unknown indicator "${key}" in configuration.`)
+    }
+  }
 
   for(const key of Object.keys(inputTypes))
   {
     verticalOhlcv[key] = buildArray(arrayTypes[key], len)
   }
 
+  // Callbacks can modify inputTypes through main; retain dynamic lookup for them.
+  const inputColumns = executionParams.some(({ key }) => key === 'mapCols')
+    ? null
+    : Object.entries(inputTypes).map(([key, formatterKey]) => {
+        const numeric = inputNumberFormatter.hasOwnProperty(formatterKey)
+        const formatter = numeric
+          ? inputNumberFormatter[formatterKey]
+          : dateFormaters.hasOwnProperty(formatterKey) ? dateFormaters[formatterKey] : null
+        return { key, formatter, numeric }
+      })
+
   // Process each row in the input
   for (let chunkStart = 0; chunkStart < len; chunkStart += chunkProcess) {
 
@@ -75,25 +89,36 @@ export const mainLoop = (input, main) => {
       for (let index = chunkStart; index < chunkEnd; index++) {
         const curr = input[index]
       
-        for(const [key, formaterKey] of Object.entries(inputTypes))
-        {
-          let value = curr[key]
-
-          if(typeof value === 'undefined') continue
-
-          if(inputNumberFormatter.hasOwnProperty(formaterKey))
-          {
-            const formatedValue = inputNumberFormatter[formaterKey](value, precisionMultiplier)
-
-            main.pushToMain({index, key, value: formatedValue})
-          }
-          else if(dateFormaters.hasOwnProperty(formaterKey))
-          {
-            main.pushToMain({index, key, value: dateFormaters[formaterKey](value)})
+        if (inputColumns !== null) {
+          for (const { key, formatter, numeric } of inputColumns) {
+            const value = curr[key]
+            if (typeof value === 'undefined') continue
+
+            const formattedValue = formatter === null ? value
+              : numeric ? formatter(value, precisionMultiplier) : formatter(value)
+            main.pushToMain({ index, key, value: formattedValue })
           }
-          else
+        } else {
+          for(const [key, formaterKey] of Object.entries(inputTypes))
           {
-            main.pushToMain({index, key, value})
+            let value = curr[key]
+
+            if(typeof value === 'undefined') continue
+
+            if(inputNumberFormatter.hasOwnProperty(formaterKey))
+            {
+              const formatedValue = inputNumberFormatter[formaterKey](value, precisionMultiplier)
+
+              main.pushToMain({index, key, value: formatedValue})
+            }
+            else if(dateFormaters.hasOwnProperty(formaterKey))
+            {
+              main.pushToMain({index, key, value: dateFormaters[formaterKey](value)})
+            }
+            else
+            {
+              main.pushToMain({index, key, value})
+            }
           }
         }
 
@@ -102,7 +127,7 @@ export const mainLoop = (input, main) => {
         main.pushToMain({index, key: 'mid_price', value: midPrice})
     
         // Process these indicators separately (ensuring their execution in the order of initialization)
-        for (const { key, params} of inputParams)
+        for (const { key, params} of executionParams)
         {
           mainFunctions[key](main, index, ...params)
         }

package/src/core-functions/pushToMain.js

@@ -2,9 +2,7 @@ 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) => {

package/src/core-indicators/README.md

@@ -0,0 +1,61 @@
+# Core indicators
+
+Local numeric replacements for the `Faster*` implementations used from
+`trading-signals@5.0.4`. The existing constructor arguments, `update(value,
+replace?)`, `isStable`, and `getResult()` interface remain available. The
+numeric series also retain result/extrema and replacement semantics. These
+are not replacements for the arbitrary-precision `Big` classes or a promise
+of compatibility with other trading-signals versions.
+
+```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` compares the core classes directly with the installed
+trading-signals reference, checks bounded retained storage, and exercises all
+public indicators, precision/log modes, lags, callbacks, and config replay.
+The dependency is retained as a regression oracle; production source imports
+only these local classes. Preserve the reference version in the lockfile.
+
+`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.