ohlcv-indicators 3.5.56 → 3.5.60

package/index.js

@@ -15,35 +15,25 @@ 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 { getOrderFromArray } from './src/utilities/order.js'
 import { calcPrecisionMultiplier } from './src/utilities/precisionMultiplier.js'
 
-import {
-    defaultYCallback,
-    validRegressors,
-    validClassifiers,
-    exportTrainedModels
-} from './src/machine-learning/ml-config.js'
-
 import { normalizeMinMax } from './src/machine-learning/ml-utilities.js'
 
 /**
  * Class OHLCV_INDICATORS
  *
  * This class provides methods for calculating and managing technical indicators 
- * on financial OHLCV (Open, High, Low, Close, Volume) data. It enables users 
- * to parallel compute various technical indicators in 1 single loop for standard indicators and a second loop for ML regressors and classifier.
+ * on financial OHLCV (Open, High, Low, Close, Volume) data. It enables users
  * OHLCV datasets.
  */
 
 export default class OHLCV_INDICATORS {
-    constructor({input, ticker = null, inputParams = null, chunkProcess = 2000, ML = {}, precision = false}) {
+    constructor({input, ticker = null, inputParams = null, chunkProcess = 2000, precision = false}) {
 
         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')
-        validateObject(ML, 'ML', 'constructor')
         validateBoolean(precision, 'precision', 'contructor')
 
         this.chunkProcess = chunkProcess
@@ -78,24 +68,12 @@ export default class OHLCV_INDICATORS {
         this.scaledGroups = {}
         this.isAlreadyComputed = new Set()
 
-        const {classes: mlClasses} = ML
-
-        if(typeof mlClasses !== 'undefined') validateObject(mlClasses, 'ML.classes', 'constructor')
-
-        this.ML = {
-            models: {},
-            classes: mlClasses,
-            metrics: {},
-            featureCols: {}
-        }
-        this.processSecondaryLoop = false
-
         this.pushToMain = ({index, key, value}) => pushToMain({main: this, index, key, value})
         
         if(inputParams !== null)
         {
             validateInputParams(inputParams, this.len)
-            this.inputParams = inputParams
+            this.inputParams = inputParams.sort((a, b) => a.order - b.order)
             this.compute()
         }
         else
@@ -150,6 +128,8 @@ export default class OHLCV_INDICATORS {
         if (this.isComputed) {
           return this;
         }
+
+        this.inputParams = this.inputParams.sort((a, b) => a.order - b.order)
       
         // Mark as “in progress”
         this.isComputed = false;
@@ -208,9 +188,7 @@ export default class OHLCV_INDICATORS {
 
         this.isAlreadyComputed.add(methodName)
 
-        const order = getOrderFromArray(orderArr, methodName)
-
-        this.inputParams.push({key: methodName, order, params: [arr, {limit, oneHot}]})
+        this.inputParams.push({key: methodName, params: [arr, {limit, oneHot}]})
         
         return this
     }
@@ -224,8 +202,7 @@ export default class OHLCV_INDICATORS {
         validateArray(colKeys, 'colKeys', methodName)
         validateNumber(lookback, {min:1, max: this.len, allowDecimals: false}, 'lookback', methodName)
 
-        const order = getOrderFromArray(colKeys, methodName)
-        this.inputParams.push({key: methodName, order, params: [colKeys, lookback]})
+        this.inputParams.push({key: methodName, params: [colKeys, lookback]})
         
         return this;
     }
@@ -309,9 +286,7 @@ export default class OHLCV_INDICATORS {
         validateString(target, 'options.target', methodName)
         validateNumber(lag, {min: 0, max: this.len, allowDecimals: false}, 'options.lag', methodName)
 
-        const order = getOrderFromArray([target], methodName)
-
-        this.inputParams.push({key: methodName, order, params: [methodName, size, {target, lag}]})
+        this.inputParams.push({key: methodName, params: [methodName, size, {target, lag}]})
 
         return this
     }
@@ -329,9 +304,7 @@ export default class OHLCV_INDICATORS {
         validateString(target, 'options.target', methodName)
         validateNumber(lag, {min: 0, max: this.len, allowDecimals: false}, 'options.lag', methodName)
 
-        const order = getOrderFromArray([target], methodName)
-
-        this.inputParams.push({key: methodName, order, params: [methodName, size, {target, lag}]})
+        this.inputParams.push({key: methodName, params: [methodName, size, {target, lag}]})
 
         return this
     }
@@ -379,9 +352,7 @@ export default class OHLCV_INDICATORS {
         validateNumber(atrLength, {min: 2, max: this.len, allowDecimals: false}, 'options.atrLength', methodName)
         validateNumber(liquidityLookback, {min: 1, max: this.len, allowDecimals: false}, 'options.liquidityLookback', methodName)
 
-        const order = getOrderFromArray([target], methodName)
-
-        this.inputParams.push({key: methodName, order, params: [size, momentum, {target, lag}]})
+        this.inputParams.push({key: methodName, params: [size, momentum, {target, lag}]})
 
         return this
     }
@@ -443,9 +414,7 @@ export default class OHLCV_INDICATORS {
         const instanceKey = `${fast}_${slow}_${signal}${target === 'close' ? '' : `_${target}`}`
         const precomputed = {instanceKey}
 
-        const order = getOrderFromArray([target], methodName)
-
-        this.inputParams.push({key: methodName, order, params: [fast, slow, signal, {target, lag, precomputed}]})
+        this.inputParams.push({key: methodName, params: [fast, slow, signal, {target, lag, precomputed}]})
         
         return this
 
@@ -467,9 +436,7 @@ export default class OHLCV_INDICATORS {
         validateNumber(lag, {min: 0, max: this.len, allowDecimals: false}, 'options.lag', methodName)
         validateBoolean(height, 'options.height', methodName)
   
-        const order = getOrderFromArray([target], methodName)
-
-        this.inputParams.push({key: methodName, order, params: [size, stdDev, {target, height, range, lag}]});
+        this.inputParams.push({key: methodName, params: [size, stdDev, {target, height, range, lag}]});
     
         return this;
     }
@@ -505,9 +472,7 @@ export default class OHLCV_INDICATORS {
             prefix = 'minmax_'
         }
 
-        const order = getOrderFromArray([target], methodName)
-
-        this.inputParams.push({key: methodName, order, params: [size, {target, lag, parser, prefix, minmax}]})
+        this.inputParams.push({key: methodName, params: [size, {target, lag, parser, prefix, minmax}]})
 
         return this
     }
@@ -589,328 +554,89 @@ export default class OHLCV_INDICATORS {
         return this           
     }
 
-    scaler(type = 'zscore', size, options = {})
-    {
-        let methodName = 'scaler'
+    priceFeatures(options = {}) {
+        let methodName = 'priceFeatures'
 
         isAlreadyComputed(this)
 
-        validateNumber(size, {min: 1, max: this.len, allowDecimals: false}, 'size', methodName)
-        
         validateObject(options, 'options', methodName)
 
-        const {group = false, range = [0, 1], lag = 0,  colKeys = []} = options
+        const {lag = 0, colKeys = []} = options
 
+        validateNumber(lag, {min: 0, max: this.len, allowDecimals: false}, 'options.lag', methodName)
         validateArray(colKeys, 'options.colKeys', methodName)
-        validateBoolean(group, 'options.group', methodName)
-        validateArrayOfRanges(range, 'options.range', methodName)
-        validateArrayOptions(['minmax', 'zscore'], type, 'options.type', methodName)
 
-        const groupKey = `${type}_${size}`
-        const groupKeyLen = colKeys.length
-        const precomputed = {groupKey, groupKeyLen}
 
-        let secondaryLoop = false
-
-        const order = getOrderFromArray(colKeys, methodName)
-
-        if(order >= 10)
-        {
-            secondaryLoop = true
-        }
+        this.inputParams.push({key: methodName, params: [{lag, colKeys}]})
 
-        this.inputParams.push({key: methodName, order, params: [size, colKeys, {type, group, range, lag, precomputed, secondaryLoop}]})
         return this
     }
 
-    classifier(trainingSize = 200, options = {})
+    scaler(type = 'zscore', size, options = {})
     {
-        isAlreadyComputed(this)
-
-        const methodName = 'classifier'
-        validateNumber(trainingSize, {max: this.len, allowDecimals: false}, 'trainingSize', methodName)
-        validateObject(options, 'options', methodName)
-
-        const {
-            retrain = false,
-            trainingCols = [], 
-            type = 'KNN',
-            lookback = 0,
-            findGroups = [],
-            predictions = 2,
-            horizon = 2,
-            modelArgs = undefined,
-            filterCallback = () => true
-        } = options
-
-        if (modelArgs !== undefined && (typeof modelArgs !== 'object' || modelArgs === null || Array.isArray(modelArgs))) throw new TypeError(`"modelArgs" must be either undefined or a plain object in ${type}`);
-
-        const yCallback = options.yCallback ?? defaultYCallback
-
-        if(typeof yCallback !== 'function')
-        {
-            throw new Error(`"yCallback" must be a function in the following format:\n\n---\n\nconst yCallback = ${defaultYCallback.toString()}\n\n---\n\n`)
-        }
-
-        validateArrayOptions(Object.keys(validClassifiers), type, 'options.type', methodName)
-
-        if (!this.ML.classes.hasOwnProperty(type)) {
-            throw new Error(
-                `"${type}" isn’t available because its library wasn’t imported into OHLCV_INDICATORS.ML.`
-            )
-        }
-
-        validateBoolean(retrain, 'options.retrain', methodName)
-        validateArray(trainingCols, 'options.trainingCols', methodName)
-        validateNumber(horizon, {min: 1, max: this.len, allowDecimals: false}, 'options.horizon', methodName)
-        validateNumber(lookback, {max: 0, allowDecimals: false}, 'options.lookback', methodName)
-        validateNumber(predictions, {min: 1, allowDecimals: false}, 'options.predictions', methodName)
-
-        const orderArr = [...trainingCols]
-
-        if(validateArray(findGroups, 'options.findGroups', 'scaler') && findGroups.length > 0)
-        {
-            for (const { type = '', size, groupName = '' } of findGroups) {
-
-                if (!type || (!size && !groupName) || (size && groupName)) {
-                    throw new Error(`If "options.findGroups" array is set, each item must be an object that includes the "type" (mandatory) and either "size" or "groupName" (choose 1) used to locate previously scaled (minmax or zscore) groups.`);
-                }
-
-                orderArr.push(type.toString(), groupName.toString());
-            }
-        }  else {
-            if(trainingCols.length === 0)
-            {
-                throw new Error(`"trainingCols" array is empty in ${methodName}`)
-            }
-        }
-
-        const {shortName, flatY} = validClassifiers[type]
+        let methodName = 'scaler'
 
-        const prefix = `cla_${shortName}_${trainingSize}_prediction`
+        isAlreadyComputed(this)
 
-        if(this.isAlreadyComputed.has(prefix))
-        {
-            throw new Error(
-            `Each classifier must have a unique pair of “type” and trainingSize.\n` +
-            `This rule ensures that your output columns are labeled unambiguously.\n` +
-            `You provided a duplicate: type="${type}" with trainingSize=${trainingSize}.`
-            );
-        }
+        validateArrayOptions(['minmax', 'zscore', 'byfeature'], type, 'options.type', methodName)
+        validateNumber(size, {min: 1, max: this.len, allowDecimals: false}, 'size', methodName)
 
-        const precompute = {
-            lookbackAbs: Math.abs(lookback) + 1,
-            flatY,
-            prefix
-        }
+        const longName = `${methodName}(${type}, ${size}, options = {})`
         
-        this.isAlreadyComputed.add(prefix)
-
-        const order = getOrderFromArray(orderArr, methodName)
-
-        const modelConfig = validClassifiers[type]
-        const modelClass =  this.ML.classes[type]
-
-        this.inputParams.push({key: methodName, order, params: [trainingSize, {yCallback, predictions, lookback, retrain, trainingCols, findGroups, horizon, type,  modelArgs, precompute, filterCallback, modelConfig, modelClass}]})
-
+        validateObject(options, 'options', longName)
 
-        return this
-    }
-
-    regressor(trainingSize = 200, options = {})
-    {
-        isAlreadyComputed(this)
+        const {minMaxRange = null, lag = false,  colKeys = [], weights = {}, euclideanWeights = false, byFeatureRange = null} = options
 
-        const methodName = 'regressor'
+        validateArray(colKeys, 'options.colKeys', longName)
+        validateBoolean(lag, 'options.lag', longName)
+        
         
+        validateObject(weights, 'options.weights', longName)
 
-        validateNumber(trainingSize, {max: this.len, allowDecimals: false}, 'trainingSize', methodName)
-        validateObject(options, 'options', methodName)
+        const lookback = lag ? size - 1 : 0
 
-        const {
-            retrain = false,
-            target = 'close', 
-            predictions =  1, 
-            trainingCols = [], 
-            type = 'SimpleLinearRegression', 
-            lookback = 0,
-            findGroups = [],
-            modelArgs = undefined,
-            filterCallback = () => true
-        } = options
-
-        validateArrayOptions(Object.keys(validRegressors), type, 'type', methodName)
-
-        if (!this.ML.classes.hasOwnProperty(type)) {
-            throw new Error(
-                `"${type}" isn’t available because its library wasn’t imported into OHLCV_INDICATORS.ML.`
-            )
+        if(colKeys.length === 0) {
+            throw new Error(`The property "options.colKeys" must be an array with target keys in ${longName}.`)
         }
-        
-        //regressor
-        validateBoolean(retrain, 'options.retrain', methodName)
-        validateString(target, 'options.target', methodName)
-        validateNumber(predictions, {min: 1, allowDecimals: false}, 'predictions', methodName)
-        validateNumber(lookback, {max: 0, allowDecimals: false}, 'lookback', methodName)
-        validateArray(trainingCols, 'options.trainingCols', methodName)
 
-        const {shortName, flatX, flatY} = validRegressors[type]
-        const prefix = `reg_${shortName}_${trainingSize}_${target}_prediction`
-        const orderArr = [...trainingCols]
 
-        if(validateArray(findGroups, 'options.findGroups', 'scaler') && findGroups.length > 0)
-        {
-            for (const { type = '', size, groupName = '' } of findGroups) {
 
-                if (!type || (!size && !groupName) || (size && groupName)) {
-                    throw new Error(`If "options.findGroups" array is set, each item must be an object that includes the "type" (mandatory) and either "size" or "groupName" (choose 1) used to locate previously scaled (minmax or zscore) groups.`);
-                }
+        for(const [key, arr] of Object.entries(weights)) {
+            validateArray(arr, `options.weights.${key}`)
 
-                orderArr.push(type.toString(), groupName.toString());
+            if(!lag && arr.size > 0) {
+                throw new Error(`If "options.lag" is set to false "options.weights.${key}" can only contain 1 item (float) in ${longName}.`)
             }
 
-        }  else {
-            if(trainingCols.length === 0 && flatX === false)
-            {
-                throw new Error(`"trainingCols" array is empty in ${methodName} ${type}`)
+            if(arr.length > size) {
+                throw new Error(`The length of the property "options.weights.${key}" can not be longer than "size" in ${longName}.`)
             }
-        }
 
-        if(flatX) {
-            if(trainingCols.length > 0)
-            {
-                throw new Error(`If regressor type is ${type} then leave "options.trainingCols" array empty.`)
-            }
-            if(lookback > 0)
-            {
-                throw new Error(`If regressor type is ${type} then "options.lookback" must be 0.`)
+            for(let x = 0; x < arr.length; x++) {
+                const val = arr[x]
+                validateNumber(val, {min: 0.01, max: 10, allowDecimals: true}, `options.weights.${key}[${x}]`, longName)
             }
-            if(findGroups.length > 0)
-            {
-                throw new Error(`If regressor type is ${type} then "options.findGroups" must be null.`)
-            }
-            else {                
-                trainingCols.push(target)
-            }
-        }
-
-        if(this.isAlreadyComputed.has(prefix))
-        {
-            throw new Error(
-            `Each regressor must have a unique "type", "trainingSize" and "target".\n` +
-            `This rule ensures that your output columns are labeled unambiguously.\n` +
-            `You provided a duplicate: type="${type}", trainingSize=${trainingSize} target=${target}.`
-            );
-        }
-
-        const precompute = {
-            lookbackAbs: Math.abs(lookback) + 1,
-            flatX,
-            flatY,
-            prefix
-        }
-
-        this.isAlreadyComputed.add(prefix)
-
-
-        const order = getOrderFromArray(orderArr, methodName)
-
-        const modelConfig = validRegressors[type]
-        const modelClass =  this.ML.classes[type]
 
-        this.inputParams.push({key: methodName, order, params: [trainingSize, {target, predictions, retrain, lookback, trainingCols, findGroups, type,  modelArgs, precompute, filterCallback, modelConfig, modelClass}]})
-
-        return this
-    }
-
-    pca(suffix, trainingSize, options = {})
-    {
-        const methodName = 'pca'
-        validateNumber(trainingSize, {min: 1, max: this.len}, 'trainingSize', methodName)
-        validateString(suffix, 'suffix', methodName)
-        validateObject(options, 'options', methodName)
-
-        const {
-            findGroups = [], 
-            trainingCols = [], 
-            lookback = 0,
-            filterCallback = () => true
-        } = options
-
-        
-        validateArray(trainingCols, 'options.trainigCols', methodName)
-        validateNumber(lookback, {min: 0, max: this.len, allowDecimals: false}, 'options.lookback', methodName)
-        if(typeof options.modelArgs !== 'undefined') {
-            validateObject(options.modelArgs, 'options.modelArgs', methodName)
-        } else {
-            options.modelArgs = {}
-        }
-
-        //modelArgs
-
-        const modelArgs = {
-            showSource: false,
-            storeModel: false,
-            isCovarianceMatrix: false,
-            method: 'NIPALS', //SVD, covarianceMatrix or NIPALS
-            center: true,
-            scale: false,
-            nCompNIPALS: 5,
-            ignoreZeroVariance: false,
-            ...options.modelArgs
         }
 
-        validateBoolean(modelArgs.showSource, 'options.modelArgs.showSource', methodName)
-        validateBoolean(modelArgs.storeModel, 'options.modelArgs.storeModel', methodName)
-        validateBoolean(modelArgs.isCovarianceMatrix, 'options.modelArgs.isCovarianceMatrix', methodName)
-        validateBoolean(modelArgs.center, 'options.modelArgs.center', methodName)
-        validateBoolean(modelArgs.scale, 'options.modelArgs.scale', methodName)
-        validateBoolean(modelArgs.ignoreZeroVariance, 'options.modelArgs.ignoreZeroVariance', methodName)
-        validateArrayOptions(['SVD', 'NIPALS', 'covarianceMatrix'], modelArgs.method, 'options.modelArgs.method', methodName)
-        validateNumber(modelArgs.nCompNIPALS, {min: 1}, 'options.modelArgs.nCompNIPALS', methodName)
-
+        if (type !== 'byfeature') {
 
-
-
-        const orderArr = []
-
-        if(validateArray(findGroups, 'options.findGroups', 'pca') && findGroups.length > 0)
-        {
-            
-            for (const { type = '', size, groupName = '' } of findGroups) {
-
-                if (!type || (!size && !groupName) || (size && groupName)) {
-                    throw new Error(`If "options.findGroups" array is set, each item must be an object that includes the "type" (mandatory) and either "size" or "groupName" (choose 1) used to locate previously scaled (minmax or zscore) groups.`);
-                }
-
-                orderArr.push(type.toString(), groupName.toString())
+            if(!byFeatureRange == null) {
+                throw new Error('"options.byFeatureRange" is only valid when "type" is "byfeature".')
             }
         }
-
-        const order = getOrderFromArray(orderArr, methodName)
-        const prefix = `pca_${suffix}_${trainingSize}`
-
-        if(this.isAlreadyComputed.has(prefix)) {
-            throw new Error(
-            `Each regressor must have a unique "suffix" param.\n` +
-            `This rule ensures that your output columns are labeled unambiguously.\n` +
-            `You provided a duplicate: type="${suffix}".`
-            )
+        else {
+            validateArrayOfRanges(byFeatureRange, 'options.byFeatureRange', longName)
+        }
+        
+        if(['minmax', 'byfeature']) {
+            validateArrayOfRanges(minMaxRange, 'options.minMaxRange', longName)
         }
 
-        const lookbackAbs =  Math.abs(lookback) + 1
-        this.isAlreadyComputed.add(prefix)
-
-        this.inputParams.push({key: methodName, order, params: [{prefix, trainingSize, findGroups, trainingCols, lookbackAbs, modelArgs, filterCallback}]})
-
+        this.inputParams.push({key: methodName, params: [size, colKeys, {type, minMaxRange, lookback, weights, euclideanWeights, byFeatureRange}]})
         return this
     }
 
-    exportTrainedModels()
-    {
-        return exportTrainedModels(this)
-    }
-
     mapCols(newCols = ['change'], callback = null, options = {}) {
 
         isAlreadyComputed(this)
@@ -934,9 +660,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.`)
         }
 
-        const order = getOrderFromArray(newCols, methodName)
-
-        this.inputParams.push({key: methodName, order, params: [newCols, callback, {lag, isPriceBased}]})
+        this.inputParams.push({key: methodName, params: [newCols, callback, {lag, isPriceBased}]})
 
         return this
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ohlcv-indicators",
-  "version": "3.5.56",
+  "version": "3.5.60",
   "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",
@@ -12,25 +12,14 @@
   "author": "https://jaimelias.com/",
   "license": "ISC",
   "dependencies": {
-    "trading-signals": "^5.0.4",
-    "xy-scale": "^1.4.1"
+    "trading-signals": "^5.0.4"
   },
   "devDependencies": {
     "@babel/core": "^7.25.2",
     "@babel/plugin-proposal-class-properties": "^7.18.6",
     "@babel/preset-env": "^7.25.3",
-    "arima": "^0.2.5",
     "babel-loader": "^9.1.3",
     "dotenv": "^16.4.5",
-    "merge-multi-timeframe": "^1.1.6",
-    "ml-cart": "^2.1.1",
-    "ml-fnn": "^5.0.0",
-    "ml-knn": "^3.0.0",
-    "ml-naivebayes": "^4.0.0",
-    "ml-pca": "^4.1.1",
-    "ml-random-forest": "^2.1.0",
-    "ml-regression-multivariate-linear": "^2.0.4",
-    "ml-regression-simple-linear": "^3.0.1",
     "terser-webpack-plugin": "^5.3.14",
     "webpack": "^5.93.0",
     "webpack-cli": "^5.1.4"

package/src/core-functions/mainLoop.js

@@ -21,13 +21,12 @@ 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 { priceFeatures } from "../studies/priceFeatures.js";
 
-import { pca } from "../machine-learning/pca.js";
-import { regressor } from "../machine-learning/regressor.js";
-import { classifier } from "../machine-learning/classifier.js";
 
 // Map indicator keys to their respective functions
 const mainFunctions = {
+  priceFeatures,
   dateTime,
   heikenAshi,
   rsi,
@@ -49,17 +48,18 @@ const mainFunctions = {
 };
 
 export const mainLoop = (input, main) => {
-  const { len, 
-    inputParams, 
+  const { 
+    len, 
     arrayTypes, 
     verticalOhlcv, 
     verticalOhlcvKeyNames, 
     inputTypes, 
     chunkProcess, 
-    processSecondaryLoop,
-    precisionMultiplier
+    precisionMultiplier,
+    inputParams
   } = main;
 
+
   validateInputParams(inputParams, len)
 
   for(const key of Object.keys(inputTypes))
@@ -96,15 +96,10 @@ export const mainLoop = (input, main) => {
           }
         }
     
-        // Process these indicators separately (ensuring their execution order)
-        for (const { key, params, order } of inputParams)
+        // Process these indicators separately (ensuring their execution in the order of initialization)
+        for (const { key, params} of inputParams)
         {
-          for(let orderIdx = 0; orderIdx <= 9; orderIdx++)
-          {
-            if(typeof order !== 'number') throw new Error(`order property of ${key} not found: ${params}`)
-            if(orderIdx !== order) continue
-            mainFunctions[key](main, index, ...params)
-          }
+          mainFunctions[key](main, index, ...params)
         }
       
         input[index] = null //flusing data
@@ -118,34 +113,7 @@ export const mainLoop = (input, main) => {
       }
   }
 
-  const isSecondaryLoopNeeded = inputParams.some(({ key }) => key === 'regressor' || key === 'classifier' || key === 'pca')
-
-  if(isSecondaryLoopNeeded || processSecondaryLoop)
-  {
-    secondaryLoop(main)
-  }
 
   verticalOhlcvKeyNames.push(...Object.keys(verticalOhlcv))
   
 }
-
-export const secondaryLoop = (main) => {
-  const {inputParams, len, invalidValueIndex} = main
-
-  const startIndex = invalidValueIndex + 1
-
-  for(let index = startIndex; index < len; index++)
-  {
-      for (const { key, params, order } of inputParams)
-      {
-        for(let orderIdx = 10; orderIdx <= 20; orderIdx++) {
-          if(typeof order !== 'number') throw new Error(`order property of ${key} not found: ${params}`)
-          if(orderIdx !== order) continue
-          if(key === 'pca') pca(main, index, ...params)
-          if(key === 'classifier') classifier(main, index, ...params)
-          if(key === 'regressor') regressor(main, index, ...params)
-        }
-      }
-  }
-
-}