ohlcv-indicators 3.5.0 → 3.5.2

package/index.js

@@ -67,6 +67,7 @@ export default class OHLCV_INDICATORS {
         this.precision = precision
         this.precisionMultiplier = calcPrecisionMultiplier(this, this.firstRow)
         this.scaledGroups = {}
+        this.scaledLabels = new Set()
 
         this.pushToMain = ({index, key, value}) => pushToMain({main: this, index, key, value})
         
@@ -268,12 +269,15 @@ export default class OHLCV_INDICATORS {
         validateNumber(size, {min: 1, max: this.len, allowDecimals: false}, 'size', methodName)
         validateObject(options, 'options', methodName)
 
-        const {lag = 0, type = 'price'} = options
+        const {lag = 0, percentage = false, upper = null, lower = null} = options
 
         validateNumber(lag, {min: 0, max: this.len, allowDecimals: false}, 'options.lag', methodName)
-        validateArrayOptions(['price', 'percentage'], type, 'options.type', methodName)
+        validateBoolean(percentage, 'options.percentage', 'atr')
 
-        this.inputParams.push({key: methodName, params: [size, {lag, type}]})
+        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}]})
 
         return this
     }
@@ -453,9 +457,11 @@ 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 = 'minmax', decimals = null} = options
+        const {group = false, range = [0, 1], lag = 0, type = 'zscore', decimals = null, pca = false, pcaSource = false} = options
 
         validateBoolean(group, 'options.group', methodName)
+        validateBoolean(pca, 'options.pca', methodName)
+        validateBoolean(pcaSource, 'options.pcaSource', methodName)
         validateArrayOfRanges(range, 'options.range', methodName)
         validateArrayOptions(['minmax', 'zscore'], type, 'options.type', methodName)
 
@@ -465,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}]})
+        this.inputParams.push({key: methodName, params: [size, colKeys, {type, group, range, lag, precomputed, decimals, pca, pcaSource}]})
         return this
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ohlcv-indicators",
-  "version": "3.5.0",
+  "version": "3.5.2",
   "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,7 +12,9 @@
   "author": "https://jaimelias.com/",
   "license": "ISC",
   "dependencies": {
-    "trading-signals": "^5.0.4"
+    "ml-pca": "^4.1.1",
+    "trading-signals": "^5.0.4",
+    "xy-scale": "^1.4.1"
   },
   "devDependencies": {
     "@babel/core": "^7.25.2",

package/src/core-functions/mainLoop.js

@@ -9,13 +9,15 @@ import { volumeOscillator } from "../oscillators/volumeOscillator.js";
 import { lag } from "../studies/lag.js";
 import { crossPairs } from "../studies/findCrosses.js";
 import { dateTime } from "../studies/dateTime.js";
-import { scaler } from "../studies/scaler.js";
+import { scaler } from "../machine-learning/scaler.js";
 import { atr } from "../volatility/atr.js";
 
 import { buildArray } from "../utilities/assignTypes.js";
 import {  numberFormater } from "../utilities/numberUtilities.js";
 import { dateFormaters } from "../utilities/dateUtilities.js";
 
+import { pca } from "../machine-learning/pca.js";
+
 // Map indicator keys to their respective functions
 const indicatorFunctions = {
   dateTime,
@@ -33,7 +35,7 @@ const indicatorFunctions = {
 
 
 export const mainLoop = (input, main) => {
-  const { len, inputParams, priceBased, precisionMultiplier, arrayTypes, verticalOhlcv, verticalOhlcvKeyNames, inputTypes, chunkProcess } = main;
+  const { len, inputParams, priceBased, precisionMultiplier, arrayTypes, verticalOhlcv, verticalOhlcvKeyNames, inputTypes, chunkProcess, scaledGroups } = main;
 
   validateInputParams(inputParams, len)
 
@@ -89,5 +91,7 @@ export const mainLoop = (input, main) => {
       }
   }
 
+  pca(main)
+
   verticalOhlcvKeyNames.push(...Object.keys(verticalOhlcv))
 }

package/src/machine-learning/pca.js

@@ -0,0 +1,69 @@
+import { PCA } from "ml-pca";
+
+export const pca = main => {
+
+    const {inputParams, invalidValueIndex, len, verticalOhlcv} = main
+    const startIndex = invalidValueIndex + 1
+
+    for(const rowParams of inputParams)
+    {
+        const {key: indicatorName, params} = rowParams
+
+        if(indicatorName !== 'scaler') continue
+
+        const [size, keyNames, options] = params
+
+        const {type, group, lag, pca: pcaBoolean, pcaSource} = options
+
+        if(!group || !pcaBoolean) continue
+
+        const scaledKeyNames = keyNames.map(v => `${type}_${size}_${v}`)
+        const laggedKeys = []
+
+        for (const k of scaledKeyNames) {
+            for (let step = 1; step <= lag; step++) {
+                laggedKeys.push(`${k}_lag_${step}`)
+            }
+        }
+
+        scaledKeyNames.push(...laggedKeys)
+
+
+        const diffLen = len - startIndex
+        const numCols = scaledKeyNames.length
+        const tempArr = new Array(diffLen)
+
+        for (let i = startIndex; i < len; i++) {
+
+            const row = new Float64Array(numCols);
+
+            let j = 0
+
+            for (const key of scaledKeyNames) {
+                row[j++] = verticalOhlcv[key][i]
+            }
+
+            tempArr[i - startIndex] = row
+        }
+
+        if(!pcaSource)
+        {
+            for (const key of scaledKeyNames) {
+                delete verticalOhlcv[key]
+            }
+        }
+
+        const pca = new PCA(tempArr)
+        const predictions = [...pca.predict(tempArr)]
+
+        const verticalKey = `pca_${type}_${size}`
+        verticalOhlcv[verticalKey] = new Array(len).fill(null)
+
+        for(let x = 0; x < predictions.length; x++)
+        {
+            verticalOhlcv[verticalKey][x + startIndex + 1] = predictions[x]
+        }
+
+    }
+
+}

package/src/{studies → machine-learning}/scaler.js

@@ -19,7 +19,13 @@ export const scaler = (main, index, size, colKeys, {type, group, range, lag, pre
     const prefix = `${type}_${size}`;
   
     if (index === 0) {
-      const { len } = main;
+      const { len, scaledLabels } = main;
+
+      if(scaledLabels.has(prefix))
+      {
+        throw new Error(`Method "scaler" cannot have both "size" and "options.type" parameters specified together.`)
+      }
+      scaledLabels.add(prefix)
   
       if(!instances.hasOwnProperty('scaler'))
       {

package/src/volatility/atr.js

@@ -1,27 +1,36 @@
 
 import {FasterATR, FasterWSMA} from 'trading-signals';
 
-export const atr = (main, index, size, {lag, type}) => {
+export const atr = (main, index, size, {lag, percentage, upper, lower}) => {
   const { verticalOhlcv, instances } = main
-  const keyName = (type === 'percentage') ? `atr_${size}_percentage`  : `atr_${size}` 
+  const baseKeyName = `atr_${size}`
 
   if (index === 0) {
 
     const {instances, verticalOhlcv, arrayTypes, len, priceBased} = main
 
-    instances[keyName] = new FasterATR(size, FasterWSMA)
+    instances[baseKeyName] = new FasterATR(size, FasterWSMA)
 
-    if(type === 'price')
+    const keyNames = [baseKeyName]
+
+    if(percentage) keyNames.push(`${baseKeyName}_percentage`)
+    if(upper !== null) keyNames.push(`${baseKeyName}_upper`)
+    if(lower !== null) keyNames.push(`${baseKeyName}_lower`)
+
+    for(const k of keyNames)
     {
-      priceBased.add(keyName)
+      if(!k.endsWith('_percentage'))
+      {
+        priceBased.add(k)
+      }
+      
+      verticalOhlcv[k] = new Float64Array(len).fill(NaN)
+      arrayTypes[k] = 'Float64Array'
     }
-    
-    verticalOhlcv[keyName] = new Float64Array(len).fill(NaN)
-    arrayTypes[keyName] = 'Float64Array'
-    
+
     if(lag > 0)
     {
-      main.lag([keyName], lag)
+      main.lag(keyNames, lag)
     }
   }
 
@@ -31,7 +40,7 @@ export const atr = (main, index, size, {lag, type}) => {
       low: verticalOhlcv.low[index],
       close: verticalOhlcv.close[index],
     } 
-  const instance = instances[keyName]
+  const instance = instances[baseKeyName]
 
   // Update the moving average instance.
   instance.update(curr);
@@ -42,13 +51,24 @@ export const atr = (main, index, size, {lag, type}) => {
 
   }
 
-  if(type === 'percentage')
+  if(percentage)
+  {
+    const percentageValue = (Number.isNaN(currAtr)) ? NaN : (currAtr / curr.close)
+    main.pushToMain({ index, key: `${baseKeyName}_percentage`, value: percentageValue });
+  }
+  if(upper !== null)
+  {
+    const upperValue = (Number.isNaN(currAtr)) ? NaN : (curr.close + (currAtr * upper))
+    main.pushToMain({ index, key: `${baseKeyName}_upper`, value: upperValue });
+  }
+  if(lower !== null)
   {
-    currAtr = (Number.isNaN(currAtr)) ? NaN : (currAtr / curr.close)
+    const lowerValue = (Number.isNaN(currAtr)) ? NaN : (curr.close - (currAtr * lower))
+    main.pushToMain({ index, key: `${baseKeyName}_lower`, value: lowerValue });
   }
 
   // Always push the MA value (even if NaN).
-  main.pushToMain({ index, key: keyName, value: currAtr });
+  main.pushToMain({ index, key: baseKeyName, value: currAtr });
 
   return true;
 }

package/webpack.config.js

@@ -1,6 +1,6 @@
 import { resolve, dirname } from 'path';
 import { fileURLToPath } from 'url';
-import TerserPlugin from 'terser-webpack-plugin';
+//import TerserPlugin from 'terser-webpack-plugin';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
@@ -16,7 +16,7 @@ export default {
   output,
   mode: 'production',
   target: 'web',
-  optimization: { //TerserPlugin start
+/*   optimization: { //TerserPlugin start
     minimize: true,
     minimizer: [
       new TerserPlugin({
@@ -28,7 +28,7 @@ export default {
         },
       }),
     ],
-  }, // TerserPlugin end
+  }, // TerserPlugin end */
   module: {
     rules: [
       {