ohlcv-indicators 3.5.2 → 3.5.3

package/index.js

@@ -68,6 +68,7 @@ export default class OHLCV_INDICATORS {
         this.precisionMultiplier = calcPrecisionMultiplier(this, this.firstRow)
         this.scaledGroups = {}
         this.scaledLabels = new Set()
+        this.models = {}
 
         this.pushToMain = ({index, key, value}) => pushToMain({main: this, index, key, value})
         
@@ -457,11 +458,10 @@ export default class OHLCV_INDICATORS {
         validateNumber(size, {min: 1, max: this.len, allowDecimals: false}, 'size', methodName)
         validateArray(colKeys, 'colKeys', methodName)
 
-        const {group = false, range = [0, 1], lag = 0, type = 'zscore', decimals = null, pca = false, pcaSource = false} = options
+        const {group = false, range = [0, 1], lag = 0, type = 'zscore', decimals = null, pca = null} = options
 
         validateBoolean(group, 'options.group', methodName)
-        validateBoolean(pca, 'options.pca', methodName)
-        validateBoolean(pcaSource, 'options.pcaSource', methodName)
+        if(pca !== null) validateObject(pca, 'options.pca', methodName)
         validateArrayOfRanges(range, 'options.range', methodName)
         validateArrayOptions(['minmax', 'zscore'], type, 'options.type', methodName)
 
@@ -471,7 +471,7 @@ export default class OHLCV_INDICATORS {
         const groupKeyLen = colKeys.length
         const precomputed = {groupKey, groupKeyLen}
 
-        this.inputParams.push({key: methodName, params: [size, colKeys, {type, group, range, lag, precomputed, decimals, pca, pcaSource}]})
+        this.inputParams.push({key: methodName, params: [size, colKeys, {type, group, range, lag, precomputed, decimals, pca}]})
         return this
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ohlcv-indicators",
-  "version": "3.5.2",
+  "version": "3.5.3",
   "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/machine-learning/pca.js

@@ -1,4 +1,5 @@
 import { PCA } from "ml-pca";
+import { validateBoolean, validateArrayOptions, validateNumber } from "../utilities/validators.js";
 
 export const pca = main => {
 
@@ -13,9 +14,29 @@ export const pca = main => {
 
         const [size, keyNames, options] = params
 
-        const {type, group, lag, pca: pcaBoolean, pcaSource} = options
-
-        if(!group || !pcaBoolean) continue
+        const {type, group, lag, pca: pcaOptions} = options
+
+        const {
+            showSource = false,
+            storeModel = false,
+            isCovarianceMatrix = false,
+            method = 'NIPALS', //SVD, covarianceMatrix or NIPALS
+            center = true,
+            scale = false,
+            nCompNIPALS = 2,
+            ignoreZeroVariance = false
+        } = pcaOptions
+
+        if(!group || pcaOptions === null) continue
+
+        validateBoolean(showSource, 'showSource', 'scaler.options.pca.showSource')
+        validateBoolean(storeModel, 'storeModel', 'scaler.options.pca.storeModel')
+        validateBoolean(isCovarianceMatrix, 'isCovarianceMatrix', 'scaler.options.pca.isCovarianceMatrix')
+        validateBoolean(center, 'center', 'scaler.options.pca.center')
+        validateBoolean(scale, 'scale', 'scaler.options.pca.scale')
+        validateBoolean(ignoreZeroVariance, 'ignoreZeroVariance', 'scaler.options.pca.ignoreZeroVariance')
+        validateArrayOptions(['SVD', 'NIPALS', 'covarianceMatrix'], method, 'scaler.options.pca.method')
+        validateNumber(nCompNIPALS, {min: 1}, 'nCompNIPALS', 'scaler.options.pca.nCompNIPALS')
 
         const scaledKeyNames = keyNames.map(v => `${type}_${size}_${v}`)
         const laggedKeys = []
@@ -46,22 +67,36 @@ export const pca = main => {
             tempArr[i - startIndex] = row
         }
 
-        if(!pcaSource)
+        if(!showSource)
         {
             for (const key of scaledKeyNames) {
                 delete verticalOhlcv[key]
             }
         }
 
-        const pca = new PCA(tempArr)
-        const predictions = [...pca.predict(tempArr)]
-
         const verticalKey = `pca_${type}_${size}`
+
+        const pca = new PCA(tempArr, {
+            isCovarianceMatrix,
+            method,
+            center,
+            scale,
+            nCompNIPALS,
+            ignoreZeroVariance
+        })
+
+        if(storeModel)
+        {
+            main.models[verticalKey] = pca.toJSON()
+        }
+        
+        const predictions = pca.predict(tempArr).to2DArray()
+
         verticalOhlcv[verticalKey] = new Array(len).fill(null)
 
         for(let x = 0; x < predictions.length; x++)
         {
-            verticalOhlcv[verticalKey][x + startIndex + 1] = predictions[x]
+            verticalOhlcv[verticalKey][x + startIndex] = predictions[x]
         }
 
     }

package/src/utilities/validators.js

@@ -31,7 +31,7 @@ export const validateArray = (arr, paramName, callerName) => {
 
 export const validateObject = (obj, paramName, callerName) => {
     
-    if(!Boolean(obj) || !typeof obj == 'object')
+    if(obj instanceof Object === false)
     {
         throw new Error(`Param "${paramName}" must be an object in "${callerName}".`)
     }
@@ -62,35 +62,54 @@ export const validateBoolean = (value, paramName, callerName) => {
 }
 
 export const validateNumber = (value, options, paramName, callerName) => {
+  validateObject(options, 'options', `${callerName}.${paramName}.validateNumber`);
+
+  const { allowDecimals = false, min, max } = options;
+  const label = allowDecimals ? 'number' : 'integer';
+
+  // 1) check that value is a number (and integer if decimals not allowed)
+  if (typeof value !== 'number' || (allowDecimals === false && !Number.isInteger(value))) {
+    throw new Error(
+      `Param "${paramName}" must be an ${label} in "${callerName}".`
+    );
+  }
+
+  // 2) validate types of min and max if they’re provided
+  if (min !== undefined && typeof min !== 'number') {
+    throw new Error(
+      `Param "min" must be a valid ${label} (if provided) in "${callerName}.${paramName}.validateNumber".`
+    );
+  }
+  if (max !== undefined && typeof max !== 'number') {
+    throw new Error(
+      `Param "max" must be a valid ${label} (if provided) in "${callerName}.${paramName}.validateNumber".`
+    );
+  }
+
+  // 3) if both were provided, ensure min < max
+  if (min !== undefined && max !== undefined && min >= max) {
+    throw new Error(
+      `Param "min" must be less than "max" in "${callerName}.${paramName}.validateNumber".`
+    );
+  }
+
+  // 4) check value against min (if set)
+  if (min !== undefined && value < min) {
+    throw new Error(
+      `Param "${paramName}" must be an ${label} ≥ ${min} in "${callerName}".`
+    );
+  }
+
+  // 5) check value against max (if set)
+  if (max !== undefined && value > max) {
+    throw new Error(
+      `Param "${paramName}" must be an ${label} ≤ ${max} in "${callerName}".`
+    );
+  }
+
+  return true;
+};
 
-    validateObject(options, 'options', `${callerName}.${paramName}.validateNumber`)
-
-    const {allowDecimals = false, min, max} = options
-
-    const label = (allowDecimals) ? 'number' : 'integer'
-
-    if(typeof value !== 'number' || (allowDecimals === false && !Number.isInteger(value)))
-    {
-        throw new Error(`Param "${paramName}" must be an integer in "${callerName}".`)
-    }
-
-    if(typeof min !== 'number' || typeof max !== 'number' || min >= max)
-    {
-        throw new Error(`Param "min" must be a valid ${label} lower than "max" "${callerName}.${paramName}.validateNumber".`)
-    }
-
-    if(value < min)
-    {
-        throw new Error(`Param "${paramName}" must be an ${label} greater than or equal to ${min} in "${callerName}".`)
-    }
-
-    if(value > max)
-    {
-        throw new Error(`Param "${paramName}" must be an ${label} lower than or equal to ${max} in "${callerName}".`)
-    }
-
-    return true
-}
 
 export const validateArrayOfRanges = (range, paramName, callerName) => {