ohlcv-indicators 3.5.41 → 3.5.43

package/index.js

@@ -8,7 +8,8 @@ import {
     validateBoolean, 
     validateNumber, 
     validateArrayOfRanges,
-    validateInputParams
+    validateInputParams,
+    validateString
 } from './src/utilities/validators.js'
 import { verticalToHorizontal } from './src/utilities/verticalToHorizontal.js'
 import { pushToMain } from './src/core-functions/pushToMain.js'
@@ -16,33 +17,45 @@ import { assignTypes } from './src/utilities/assignTypes.js'
 import { calcPrecisionMultiplier } from './src/utilities/precisionMultiplier.js'
 import { buildArray } 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'
 
-//precomputed
-import { precomputeMovingAverages } from './src/moving-averages/movingAverages.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.
+ * to parallel compute various technical indicators in 1 single loop for standard indicators and a second loop for ML regressors and classifier.
  * OHLCV datasets.
  */
 
 export default class OHLCV_INDICATORS {
-    constructor({input, ticker = null, precision = true, inputParams = null, chunkProcess = 2000}) {
+    constructor({input, ticker = null, precision = true, inputParams = null, chunkProcess = 2000, ML = {}}) {
 
         validateArray(input, 'input', (ticker !== null) ? `contructor ${ticker}` : 'constuctor')
         if(input.length === 0) throw Error('input OHLCV must not be empty: ' + ticker)
 
         validateBoolean(precision, 'precision', 'constructor')
         validateNumber(chunkProcess, {min: 100, max: 50000, allowDecimals: false}, 'chunkProcess', 'constructor')
+        validateObject(ML, 'ML', 'constructor')
 
-
+        this.notNumberKeys = new Set()
         this.chunkProcess = chunkProcess
-        this.firstRow = input[0]
         
-        const {inputTypes, arrayTypes} = assignTypes(this.firstRow)
+        this.input = [...input]
+        this.len = this.input.length
+        this.firstRow = this.input[0]
+        
+        const {inputTypes, arrayTypes} = assignTypes(this)
 
         this.inputTypes = inputTypes
         this.arrayTypes = arrayTypes
@@ -50,11 +63,8 @@ export default class OHLCV_INDICATORS {
 
         this.dateType = this.inputTypes.date ? this.inputTypes.date : null;
         this.isComputed = false
-        this.input = input
-        this.priceBased = new Set(['open', 'high', 'low', 'close'])
-        this.len = input.length
+
         this.instances = {}
-        this.crossPairsList = []
         this.verticalOhlcv = {}
         this.verticalOhlcvKeyNames = []
         this.verticalOhlcvTempCols = new Set()
@@ -67,8 +77,19 @@ export default class OHLCV_INDICATORS {
         this.precision = precision
         this.precisionMultiplier = calcPrecisionMultiplier(this, this.firstRow)
         this.scaledGroups = {}
-        this.scaledLabels = new Set()
-        this.models = {}
+        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})
         
@@ -78,6 +99,7 @@ export default class OHLCV_INDICATORS {
             this.inputParams = inputParams
             this.compute()
         }
+        else
         {
             this.inputParams = []
         }
@@ -99,14 +121,15 @@ export default class OHLCV_INDICATORS {
         const {
           precisionMultiplier,
           precision,
-          invalidValueIndex,
           len,
+          invalidValueIndex,
           verticalOhlcv,
-          priceBased,
           arrayTypes,
-          verticalOhlcvTempCols
+          verticalOhlcvTempCols,
+          notNumberKeys
         } = this
         const result = {}
+
         const startIndex = skipNull ? invalidValueIndex + 1 : 0
         const newLen = len - startIndex
       
@@ -114,7 +137,7 @@ export default class OHLCV_INDICATORS {
 
             if(verticalOhlcvTempCols.has(key)) continue
 
-            const shouldApplyPrecision = priceBased.has(key) && precision
+            const shouldApplyPrecision = precision && !notNumberKeys.has(key)
             result[key] = buildArray(arrayTypes[key], newLen)
 
             for (let x = startIndex; x < len; x++)
@@ -162,7 +185,8 @@ export default class OHLCV_INDICATORS {
         this.compute()
 
         const {dateFormat = 'string'} = options
-         validateArrayOptions(Object.keys(dateOutputFormaters), dateFormat, 'dateFormat', 'getData')
+        
+        validateArrayOptions(Object.keys(dateOutputFormaters), dateFormat, 'dateFormat', 'getData')
 
         return verticalToHorizontal({
             skipNull: false, 
@@ -188,13 +212,14 @@ 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.isComputed = true;
+            mainLoop(this.input, this)
+
+            this.isComputed = true;
 
-          //flushing after mainLoop
-          this.input = []
-          this.instances = {}
-          this.firstRow = []
+            //flushing after mainLoop
+            this.input = []
+            this.instances = {}
+            this.firstRow = []
         }
       
         return this;
@@ -202,16 +227,42 @@ export default class OHLCV_INDICATORS {
     
     
 
-    crossPairs(arr = [])
+    crossPairs(arr = [], options = {})
     {
         const methodName = 'crossPairs'
 
         isAlreadyComputed(this)
-
         validateArray(arr, 'arr', methodName)
+        validateObject(options, 'options', methodName)
+
+        const {limit = 125, oneHot = false} = options
+        
+        validateNumber(limit, {min: 2, max: this.len}, 'options.limit', methodName)
+        validateBoolean(oneHot, 'options.oneHot', methodName)
+       
+        const orderArr = []
+
+        for (const {fast = '', slow = ''} of arr) {
+
+            if (fast === '' || slow === '') {
+                throw new Error(
+                    `Invalid crossPairs[${fast}_${slow}]: Object property “fast” must be a non-null column name and “slow” must be a non-null column name or integer.`
+                );
+            }
+
+            orderArr.push(fast.toString(), slow.toString())
+        }
+
+        if(this.isAlreadyComputed.has(methodName))
+        {
+            throw new Error(`You can only call the "${methodName}" method once.`)
+        }
+
+        this.isAlreadyComputed.add(methodName)
+
+        const order = getOrderFromArray(orderArr, methodName)
 
-        this.crossPairsList = [...this.crossPairsList, ...arr]
-        this.inputParams.push({key: methodName, params: [this.crossPairsList]})
+        this.inputParams.push({key: methodName, order, params: [arr, {limit, oneHot}]})
         
         return this
     }
@@ -222,19 +273,11 @@ export default class OHLCV_INDICATORS {
         const methodName = 'lag'
 
         isAlreadyComputed(this)
-
         validateArray(colKeys, 'colKeys', methodName)
         validateNumber(lookback, {min:1, max: this.len, allowDecimals: false}, 'lookback', methodName)
 
-        this.inputParams.push({key: methodName, params: [colKeys, lookback]})
-
-        for(const key of colKeys)
-        {
-            if(this.priceBased.has(key))
-            {
-                this.priceBased.add(key);
-            }
-        }
+        const order = getOrderFromArray(colKeys, methodName)
+        this.inputParams.push({key: methodName, order, params: [colKeys, lookback]})
         
         return this;
     }
@@ -256,7 +299,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, {lag}]})
+        this.inputParams.push({key: methodName, order: 0, params: [size, {lag}]})
  
         return this
     }
@@ -278,7 +321,7 @@ export default class OHLCV_INDICATORS {
         if(upper !== null) validateNumber(upper, {min: 0.001, max: 100, allowDecimals: true}, 'options.upper', 'atr')
         if(lower !== null) validateNumber(lower, {min: 0.001, max: 100, allowDecimals: true}, 'options.lower', 'atr')
 
-        this.inputParams.push({key: methodName, params: [size, {lag, percentage, upper, lower}]})
+        this.inputParams.push({key: methodName, order: 0, params: [size, {lag, percentage, upper, lower}]})
 
         return this
     }
@@ -294,11 +337,12 @@ export default class OHLCV_INDICATORS {
 
         const {target = 'close', lag = 0} = options
 
+        validateString(target, 'options.target', methodName)
         validateNumber(lag, {min: 0, max: this.len, allowDecimals: false}, 'options.lag', methodName)
 
-        const precomputed = precomputeMovingAverages({main: this, size, target, lag, methodName})
+        const order = getOrderFromArray([target], methodName)
 
-        this.inputParams.push({key: methodName, params: [methodName, size, {target, lag, precomputed}]})
+        this.inputParams.push({key: methodName, order, params: [methodName, size, {target, lag}]})
 
         return this
     }
@@ -313,16 +357,75 @@ export default class OHLCV_INDICATORS {
 
         const {target = 'close', lag = 0} = options
 
+        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}]})
+
+        return this
+    }
+
+    vidya(size = 14, smoothing = 20, options = {}) {
+
+        const methodName = 'vidya'
+
+        isAlreadyComputed(this)
+
+        validateNumber(size, {min: 2, max: this.len, allowDecimals: false}, 'size', methodName)
+        validateNumber(smoothing, {min: size, max: this.len, allowDecimals: false}, 'smoothing', methodName)
+        validateObject(options, 'options', methodName)
 
-        const precomputed = precomputeMovingAverages({main: this, size, target, lag, methodName})
+        const {target = 'close', lag = 0} = options
 
-        this.inputParams.push({key: methodName, params: [methodName, size, {target, lag, precomputed}]})
+        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: [size, smoothing, {target, lag}]})
 
         return this
     }
 
+    stochastic(kPeriod = 14, kSlowingPeriod = 3, dPeriod = 3, options = {}){
+        const methodName = 'stochastic'
+
+        const {len: max} = this
+
+        validateNumber(kPeriod, {min: 1, max, allowDecimals: false}, 'kPeriod', methodName)
+        validateNumber(kSlowingPeriod, {min: 1, max, allowDecimals: false}, 'kSlowingPeriod', methodName)
+        validateNumber(dPeriod, {min: 1, max, allowDecimals: false}, 'dPeriod', methodName)
+        validateObject(options, 'options', methodName)
+
+        let parser = v => v
+        let prefix = ''
+
+        const {lag = 0} = options
+
+        validateNumber(lag, {min: 0, max, allowDecimals: false}, 'options.lag', methodName)
+
+        let minmax = options.minmax
+
+        if(Array.isArray(minmax) || (typeof minmax === 'boolean' && minmax === true))
+        {
+            if(Array.isArray(minmax)){
+                validateArrayOfRanges(minmax, 'options.minmax', methodName)
+                parser = value => (minmax !== null) ? normalizeMinMax(value, 0, 100, minmax) : value
+            } else
+            {
+                validateBoolean(minmax, 'options.minmax', methodName)
+                minmax = [0, 1]
+                parser = value => (minmax !== null) ? normalizeMinMax(value, 0, 100, minmax) : value
+            }
+            prefix = 'minmax_'
+        }
+
+        this.inputParams.push({key: methodName, order: 0, params: [kPeriod, kSlowingPeriod, dPeriod, {minmax, prefix, parser, lag}]})
+
+        return this
+    }
     
     macd(fast = 12, slow = 26, signal = 9, options = {}) {
 
@@ -337,12 +440,15 @@ export default class OHLCV_INDICATORS {
 
         const {target = 'close', lag = 0} = options
         
+        validateString(target, 'options.target', methodName)
         validateNumber(lag, {min: 0, max: this.len, allowDecimals: false}, 'options.lag', methodName)
 
         const instanceKey = `${fast}_${slow}_${signal}${target === 'close' ? '' : `_${target}`}`
         const precomputed = {instanceKey}
 
-        this.inputParams.push({key: methodName, params: [fast, slow, signal, {target, lag, precomputed}]})
+        const order = getOrderFromArray([target], methodName)
+
+        this.inputParams.push({key: methodName, order, params: [fast, slow, signal, {target, lag, precomputed}]})
         
         return this
 
@@ -359,13 +465,15 @@ export default class OHLCV_INDICATORS {
 
         const {target = 'close', height = false, range = [],  lag = 0, decimals = null} = options
 
-
+        validateString(target, 'options.target', methodName)
         validateArray(range, 'options.range', methodName)
         validateNumber(lag, {min: 0, max: this.len, allowDecimals: false}, 'options.lag', methodName)
         validateBoolean(height, 'options.height', methodName)
         if(decimals !== null) validateNumber(decimals, {min: 1, max: 15, allowDecimals: false}, 'decimals', methodName)
-    
-        this.inputParams.push({key: methodName, params: [size, stdDev, {target, height, range, lag, decimals}]});
+  
+        const order = getOrderFromArray([target], methodName)
+
+        this.inputParams.push({key: methodName, order, params: [size, stdDev, {target, height, range, lag, decimals}]});
     
         return this;
     }
@@ -380,10 +488,30 @@ export default class OHLCV_INDICATORS {
         validateObject(options, 'options', methodName)
         
         const {target = 'close', lag = 0} = options
-
+        let minmax = options.minmax
+        validateString(target, 'options.target', methodName)
         validateNumber(lag, {min: 0, max: this.len, allowDecimals: false}, 'options.lag', methodName)
 
-        this.inputParams.push({key: methodName, params: [size, {target, lag}]})
+        let parser = v => v
+        let prefix = ''
+
+        if(Array.isArray(minmax) || (typeof minmax === 'boolean' && minmax === true))
+        {
+            if(Array.isArray(minmax)){
+                validateArrayOfRanges(minmax, 'options.minmax', methodName)
+                parser = value => (minmax !== null) ? normalizeMinMax(value, 0, 100, minmax) : value
+            } else
+            {
+                validateBoolean(minmax, 'options.minmax', methodName)
+                minmax = [0, 1]
+                parser = value => (minmax !== null) ? normalizeMinMax(value, 0, 100, minmax) : value
+            }
+            prefix = 'minmax_'
+        }
+
+        const order = getOrderFromArray([target], methodName)
+
+        this.inputParams.push({key: methodName, order, params: [size, {target, lag, parser, prefix, minmax}]})
 
         return this
     }
@@ -405,13 +533,13 @@ export default class OHLCV_INDICATORS {
         validateBoolean(height, 'options.height', methodName)
         if(decimals !== null) validateNumber(decimals, {min: 1, max: 15, allowDecimals: false}, 'decimals', methodName)
       
-        this.inputParams.push({ key: methodName, params: [size, offset, { height, range, lag, decimals}] });
+        this.inputParams.push({ key: methodName, order: 0, params: [size, offset, { height, range, lag, decimals}] });
       
         return this;
     }
       
 
-    volumeOscillator(fastSize = 5, slowSize = 10, options = {})
+    volumeOscillator(fastsize = 5, slowsize = 10, options = {})
     {
         const methodName = 'volumeOscillator'
 
@@ -421,15 +549,15 @@ export default class OHLCV_INDICATORS {
 
         isAlreadyComputed(this)
 
-        validateNumber(fastSize, {min: 1, max: this.len, allowDecimals: false}, 'fastSize', methodName)
-        validateNumber(slowSize, {min: fastSize, max: this.len, allowDecimals: false}, 'slowSize', methodName)
+        validateNumber(fastsize, {min: 1, max: this.len, allowDecimals: false}, 'fastsize', methodName)
+        validateNumber(slowsize, {min: fastsize, max: this.len, allowDecimals: false}, 'slowsize', methodName)
         validateObject(options, 'options', methodName)
 
         const {lag = 0} = options
 
         validateNumber(lag, {min: 0, max: this.len, allowDecimals: false}, 'options.lag', methodName)
 
-        this.inputParams.push({key: methodName, params: [fastSize, slowSize, {lag}]})
+        this.inputParams.push({key: methodName, order: 0, params: [fastsize, slowsize, {lag}]})
         return this           
     }
     dateTime(options = {})
@@ -441,37 +569,375 @@ export default class OHLCV_INDICATORS {
 
         validateObject(options, 'options', methodName)
 
-        const {lag = 0} = options
+        const {lag = 0, oneHot = false} = options
 
         validateNumber(lag, {min: 0, max: this.len, allowDecimals: false}, 'options.lag', methodName)
+        validateBoolean(oneHot, 'options.oneHot', methodName)
+
+        const prefix = (oneHot) ? 'one_hot_' : ''
+
+
+        const colKeySizes = {
+            [`${prefix}month`]: 12,
+            [`${prefix}day_of_the_month`]: 31,
+            [`${prefix}day_of_the_week`]: 7,
+            [`${prefix}hour`]: 24,
+            [`${prefix}minute`]: 60
+        }
+
+        const precompute = {
+            prefix,
+            colKeySizes,
+            colKeys: Object.keys(colKeySizes)
+        }
 
-        this.inputParams.push({key: methodName, params: [{lag}]})
+        this.inputParams.push({key: methodName, order: 0, params: [{lag, oneHot, precompute}]})
         return this           
     }
 
-    scaler(size, colKeys = [], options = {})
+    scaler(type = 'zscore', size, options = {})
     {
-        const methodName = 'scaler'
+        let methodName = 'scaler'
 
         isAlreadyComputed(this)
 
         validateNumber(size, {min: 1, max: this.len, allowDecimals: false}, 'size', methodName)
-        validateArray(colKeys, 'colKeys', methodName)
+        
+        validateObject(options, 'options', methodName)
 
-        const {group = false, range = [0, 1], lag = 0, type = 'zscore', decimals = null, pca = null} = options
+        const {group = false, range = [0, 1], lag = 0,  colKeys = []} = options
 
+        validateArray(colKeys, 'options.colKeys', methodName)
         validateBoolean(group, 'options.group', methodName)
-        if(pca !== null) validateObject(pca, 'options.pca', methodName)
         validateArrayOfRanges(range, 'options.range', methodName)
         validateArrayOptions(['minmax', 'zscore'], type, 'options.type', methodName)
 
-        if(decimals !== null) validateNumber(decimals, {min: 1, max: 15, allowDecimals: false}, 'decimals', methodName)
-
-        const groupKey = (group) ? `${type}_${size}_group_${colKeys.join('_')}` : ''
+        const groupKey = `${type}_${size}`
         const groupKeyLen = colKeys.length
         const precomputed = {groupKey, groupKeyLen}
 
-        this.inputParams.push({key: methodName, params: [size, colKeys, {type, group, range, lag, precomputed, decimals, pca}]})
+        let secondaryLoop = false
+
+        const order = getOrderFromArray(colKeys, methodName)
+
+        if(order >= 10)
+        {
+            secondaryLoop = true
+        }
+
+        this.inputParams.push({key: methodName, order, params: [size, colKeys, {type, group, range, lag, precomputed, secondaryLoop}]})
+        return this
+    }
+
+    classifier(trainingSize = 200, 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]
+
+        const prefix = `cla_${shortName}_${trainingSize}_prediction`
+
+        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}.`
+            );
+        }
+
+        const precompute = {
+            lookbackAbs: Math.abs(lookback) + 1,
+            flatY,
+            prefix
+        }
+        
+        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}]})
+
+
+        return this
+    }
+
+    regressor(trainingSize = 200, options = {})
+    {
+        isAlreadyComputed(this)
+
+        const methodName = 'regressor'
+        
+
+        validateNumber(trainingSize, {max: this.len, allowDecimals: false}, 'trainingSize', methodName)
+        validateObject(options, 'options', methodName)
+
+        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.`
+            )
+        }
+        
+        //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.`);
+                }
+
+                orderArr.push(type.toString(), groupName.toString());
+            }
+
+        }  else {
+            if(trainingCols.length === 0 && flatX === false)
+            {
+                throw new Error(`"trainingCols" array is empty in ${methodName} ${type}`)
+            }
+        }
+
+        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.`)
+            }
+            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)
+
+
+
+
+        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())
+            }
+        }
+
+        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}".`
+            )
+        }
+
+        const lookbackAbs =  Math.abs(lookback) + 1
+        this.isAlreadyComputed.add(prefix)
+
+        this.inputParams.push({key: methodName, order, params: [{prefix, trainingSize, findGroups, trainingCols, lookbackAbs, modelArgs, filterCallback}]})
+
+        return this
+    }
+
+    exportTrainedModels()
+    {
+        return exportTrainedModels(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} = options
+
+        validateArray(newCols, 'newCols', methodName)
+        validateNumber(lag, {min: 0, allowDecimals: false}, 'options.lag', methodName)
+        const order = getOrderFromArray(newCols, methodName)
+
+        this.inputParams.push({key: methodName, order, params: [newCols, callback, {lag}]})
+
         return this
     }
 }