ohlcv-indicators 3.5.78 → 3.5.80

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

@@ -0,0 +1,22 @@
+/*!
+ * 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 } 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,22 @@ export default class OHLCV_INDICATORS {
     }
 
 
+    exportConfig() {
+        return { ...this.config, inputParams: copyConfig(this.inputParams) }
+    }
+
+    _registerIndicator(job) {
+        isAlreadyComputed(this)
+        this.inputParams = Object.freeze([...this.inputParams, freezeConfig(copyConfig(job))])
+        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 +149,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 +168,10 @@ 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)
+            .sort((a, b) => (a.order ?? 0) - (b.order ?? 0))
       
         // Mark as “in progress”
         this.isComputed = false;
@@ -139,7 +182,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 +235,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
     }
@@ -199,9 +247,16 @@ export default class OHLCV_INDICATORS {
 
         isAlreadyComputed(this)
         validateArray(colKeys, 'colKeys', methodName)
+
+        const invalidItem = colKeys.find(v => typeof v !== 'string' || v === '')
+
+        if(invalidItem !== undefined) {
+            throw new Error(`Invalid item "${invalidItem}" (column name) in "colKeys" array param of "${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;
     }
@@ -219,11 +274,12 @@ export default class OHLCV_INDICATORS {
         validateNumber(size, {min:1, max: this.len, allowDecimals: false}, 'size', 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, 'options.retLogs', methodName)
 
-        this.inputParams.push({key: methodName, order: 0, params: [size, {lag}]})
+        this._registerIndicator({key: methodName, order: 0, params: [size, {lag, retLogs}]})
  
         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
     }
@@ -298,12 +354,13 @@ export default class OHLCV_INDICATORS {
         validateNumber(size, {min: 1, max: this.len, allowDecimals: false}, 'size', methodName)
         validateObject(options, 'options', methodName)
 
-        const {target = 'close', lag = 0} = options
+        const {target = 'close', lag = 0, retLogs = false} = options
 
         validateString(target, 'options.target', methodName)
         validateNumber(lag, {min: 0, max: this.len, allowDecimals: false}, 'options.lag', methodName)
+        validateBoolean(retLogs, 'options.retLogs', methodName)
 
-        this.inputParams.push({key: methodName, params: [methodName, size, {target, lag}]})
+        this._registerIndicator({key: methodName, params: [methodName, size, {target, lag, retLogs}]})
 
         return this
     }
@@ -316,12 +373,13 @@ export default class OHLCV_INDICATORS {
         validateNumber(size, {min: 1, max: this.len, allowDecimals: false}, 'size', methodName)
         validateObject(options, 'options', methodName)
 
-        const {target = 'close', lag = 0} = options
+        const {target = 'close', lag = 0, retLogs = false} = options
 
         validateString(target, 'options.target', methodName)
         validateNumber(lag, {min: 0, max: this.len, allowDecimals: false}, 'options.lag', methodName)
+        validateBoolean(retLogs, 'options.retLogs', methodName)
 
-        this.inputParams.push({key: methodName, params: [methodName, size, {target, lag}]})
+        this._registerIndicator({key: methodName, params: [methodName, size, {target, lag, retLogs}]})
 
         return this
     }
@@ -347,30 +405,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 +413,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 +427,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 +451,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
 
@@ -429,11 +466,12 @@ export default class OHLCV_INDICATORS {
         validateNumber(stdDev, {min: 0.01, max: 50, allowDecimals: true}, 'stdDev', 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, 'options.retLogs', methodName)
   
-        this.inputParams.push({key: methodName, params: [size, stdDev, {lag}]});
+        this._registerIndicator({key: methodName, params: [size, stdDev, {lag, retLogs}]});
     
         return this;
     }
@@ -453,10 +491,25 @@ 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
+    }
+    mfi(size = 14, options = {}) {
+        const methodName = 'mfi'
+
+        isAlreadyComputed(this)
+        validateNumber(size, {min: 1, max: this.len, allowDecimals: false}, 'size', methodName)
+        validateObject(options, 'options', methodName)
+
+        const {lag = 0, retLogs = false} = options
+        validateNumber(lag, {min: 0, max: this.len, allowDecimals: false}, 'options.lag', methodName)
+        validateBoolean(retLogs, 'options.retLogs', methodName)
 
+        this._registerIndicator({key: methodName, params: [size, {lag, retLogs}]})
         return this
     }
+
     donchianChannels(size = 20, offset = 0, options = {}) {
 
         const methodName = 'donchianChannels'
@@ -467,11 +520,12 @@ export default class OHLCV_INDICATORS {
         validateNumber(offset, {min: 0, max: this.len, allowDecimals: false}, 'offset', 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, 'options.retLogs', methodName)
       
-        this.inputParams.push({ key: methodName, order: 0, params: [size, offset, {lag}] });
+        this._registerIndicator({ key: methodName, order: 0, params: [size, offset, {lag, retLogs}] });
       
         return this;
     }
@@ -491,11 +545,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 +584,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,36 +602,9 @@ 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
     }
 
-    mapCols(newCols = ['change'], callback = null, options = {}) {
-
-        isAlreadyComputed(this)
-
-        const methodName = 'mapCols'
-
-        if(typeof callback === 'undefined' || callback === null)
-        {
-            callback = defaultMapColsCallback
-        }
-
-        validateObject(options, 'options', methodName)
-
-        const {lag = 0, isPriceBased = false} = options
-
-        validateArray(newCols, 'newCols', methodName)
-        validateNumber(lag, {min: 0, allowDecimals: false}, 'options.lag', methodName)
-        validateBoolean(isPriceBased, 'isPriceBased', 'mapCols')
-
-        if(this.precision === false && isPriceBased) {
-            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}]})
-
-        return this
-    }
 }

package/package.json

@@ -1,20 +1,17 @@
 {
   "name": "ohlcv-indicators",
-  "version": "3.5.78",
+  "version": "3.5.80",
   "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",
   "scripts": {
     "test": "node test/test.js",
+    "test-benchmark": "npm test -- --benchmark --rows 20000 --repeats 9",
     "build": "npx webpack",
     "cross": "node src/studies/findCrosses2.js"
   },
   "author": "https://jaimelias.com/",
   "license": "ISC",
-  "dependencies": {
-    "ohlcv-indicators": "^3.5.72",
-    "trading-signals": "^5.0.4"
-  },
   "devDependencies": {
     "@babel/core": "^7.25.2",
     "@babel/plugin-proposal-class-properties": "^7.18.6",

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

@@ -1,10 +1,10 @@
 import { areKeyValuesValid } from "./pushToMain.js";
 import { validateInputParams } from "../utilities/validators.js";
 import { rsi } from "../oscillators/rsi.js";
+import { mfi } from "../oscillators/mfi.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";
@@ -16,12 +16,12 @@ import { crossPairs } from "../studies/findCrosses.js";
 import { dateTime } from "../studies/dateTime.js";
 import { atr } from "../volatility/atr.js";
 import { adx } from "../volatility/adx.js";
-import { mapCols } from "../studies/mapCols.js";
 
 import { buildArray } from "../utilities/assignTypes.js";
 import {  inputNumberFormatter } from "../utilities/numberUtilities.js";
 import { dateFormaters } from "../utilities/dateUtilities.js";
 import { candleFeatures } from "../studies/candleFeatures.js";
+import { getPrecisionDecimals } from "../utilities/precisionMultiplier.js";
 
 
 // Map indicator keys to their respective functions
@@ -30,19 +30,18 @@ const mainFunctions = {
   dateTime,
   heikenAshi,
   rsi,
+  mfi,
   stochastic,
   atr,
   adx,
   ema: movingAverages,
   sma: movingAverages,
-  vidya,
   macd,
   volumeDelta,
   relativeVolume,
   donchianChannels,
   bollingerBands,
   volumeOscillator,
-  mapCols,
   crossPairs,
   lag
 };
@@ -56,17 +55,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)
   }
 
+  const inputColumns = 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 }
+  })
+  const precisionDecimals = typeof precisionMultiplier === 'number'
+    ? getPrecisionDecimals(precisionMultiplier) : undefined
+  let validationColumns = null
+
   // Process each row in the input
   for (let chunkStart = 0; chunkStart < len; chunkStart += chunkProcess) {
 
@@ -75,26 +90,13 @@ 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)})
-          }
-          else
-          {
-            main.pushToMain({index, key, value})
-          }
+        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, precisionDecimals) : formatter(value)
+          main.pushToMain({ index, key, value: formattedValue })
         }
 
         const midPrice = (verticalOhlcv.open[index] + verticalOhlcv.close[index]) / 2
@@ -102,17 +104,20 @@ 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)
         }
       
         input[index] = null //flusing data
 
-        const keyNames = Object.keys(verticalOhlcv)
+        // All built-in outputs (including generated lags) exist after row zero.
+        if (validationColumns === null) {
+          validationColumns = Object.values(verticalOhlcv)
+        }
 
-        // if any value at this index is missing/NaN/null, mark it invalid
-        if (!areKeyValuesValid(main, index, keyNames)) {
+        // Preserve the missing/NaN/null predicate, including Infinity behavior.
+        if (!areKeyValuesValid(validationColumns, index)) {
           main.invalidValueIndex = index
         }
       }