xy-scale 1.0.2 → 1.0.5

package/README.md

@@ -5,7 +5,7 @@
 
 This repository provides utilities for scaling and preparing datasets in JavaScript, with a primary focus on data preprocessing for machine learning applications. The main functionality includes scaling numerical and categorical data and splitting datasets into training and testing sets.
 
-The primary functions, `parseTrainingDataset` and `parseProductionDataset`, offer a flexible and modular approach to data handling, allowing users to define custom scaling approaches, weighting of features, and specific parsing rules for features and labels.
+The primary functions, `parseTrainingXY` and `parseProductionX`, offer a flexible and modular approach to data handling, allowing users to define custom scaling approaches, weighting of X, and specific parsing rules for X and Y.
 
 ---
 
@@ -17,60 +17,60 @@ The primary functions, `parseTrainingDataset` and `parseProductionDataset`, offe
 
 ## Main Functions
 
-### 1. `parseTrainingDataset`
+### 1. `parseTrainingXY`
 
 This function prepares a dataset for supervised learning by parsing, scaling, and splitting it into training and testing subsets. It includes configurable options for feature weighting and scaling approaches.
 
 #### Parameters:
-- `arrObj` (Array of Objects): Input data array containing all features and labels.
+- `arrObj` (Array of Objects): Input data array containing all X and Y.
 - `trainingSplit` (Number, optional): Defines the training dataset size (default `0.8`).
 - `weights` (Object, optional): Feature weights for scaling.
-- `parseLabels` (Function): Custom function to parse labels for each object.
-- `parseFeatures` (Function): Custom function to parse features for each object.
+- `yCallbackFunc` (Function): Custom function to parse Y for each object.
+- `xCallbackFunc` (Function): Custom function to parse X for each object.
 - `forceScaling` (String, optional): Forces a specific scaling approach for each feature.
 
 #### Features:
-- **Label and Feature Parsing**: Custom parsing for labels and features based on user-defined functions.
-- **Configurable Scaling and Splitting**: Scales features and labels independently and splits data into training and testing sets.
+- **Y and X Parsing**: Custom parsing for Y and X based on user-defined functions.
+- **Configurable Scaling and Splitting**: Scales X and Y independently and splits data into training and testing sets.
 
 #### Scaling Approaches:
 - **Normalization**: Scales values to a range of `[0, 1]`.
 - **Standardization**: Scales values to have a mean of `0` and standard deviation of `1`.
 - **Automatic Selection (Default)**: If `forceScaling = null`, the function automatically selects between `'normalization'` and `'standardization'` for each feature. 
-    - **Normalization** is chosen for features with lower variance (small difference between mean and standard deviation), scaling values to a `[0, 1]` range.
+    - **Normalization** is chosen for X with lower variance (small difference between mean and standard deviation), scaling values to a `[0, 1]` range.
     - **Standardization** is applied when higher variance is detected (large difference between mean and standard deviation), centering values with a mean of `0` and a standard deviation of `1`.
 
     This adaptive scaling approach ensures the most effective transformation is applied based on each feature's statistical properties.
 
 #### Returns:
-- `trainFeatures`, `trainLabels`, `testFeatures`, `testLabels`: Scaled feature and label arrays for training and testing sets.
-- `trainFeaturesConfig`, `trainLabelsConfig`: Scaling configuration for features and labels.
-- `trainFeaturesKeyNames`, `trainLabelKeyNames`: Key names reflecting feature weights.
+- `trainX`, `trainY`, `testX`, `testY`: Scaled feature and label arrays for training and testing sets.
+- `trainXConfig`, `trainYConfig`: Scaling configuration for X and Y.
+- `trainXKeyNames`, `trainLabelKeyNames`: Key names reflecting feature weights.
 
-### 2. `parseProductionDataset`
+### 2. `parseProductionX`
 
-Designed for production environments, this function parses and scales feature data for unseen production datasets. Like `parseTrainingDataset`, it includes options for feature weighting and scaling.
+Designed for production environments, this function parses and scales feature data for unseen production datasets. Like `parseTrainingXY`, it includes options for feature weighting and scaling.
 
 #### Parameters:
 - `arrObj` (Array of Objects): Input data array for production.
 - `weights` (Object, optional): Feature weights for scaling.
-- `parseFeatures` (Function): Custom function to parse features for each object.
+- `xCallbackFunc` (Function): Custom function to parse X for each object.
 - `forceScaling` (String, optional): Forces a specific scaling approach for each feature.
 
 #### Returns:
-- `productionFeatures`: Scaled feature array for production data.
-- `productionFeaturesConfig`: Scaling configuration for production data.
-- `productionFeaturesKeyNames`: Key names reflecting feature weights.
+- `x`: Scaled feature array for production data.
+- `xConfig`: Scaling configuration for production data.
+- `xKeyNames`: Key names reflecting feature weights.
 
 ## Helper Callback Functions for Custom Data Parsing
 
-### `parseFeatures`
+### `xCallbackFunc`
 
-The `parseFeatures` function is used to extract specific feature values from each row of data, defining what the model will use as input. By selecting relevant fields in the dataset, `parseFeatures` ensures only the necessary values are included in the model’s feature set, allowing for streamlined preprocessing and improved model performance.
+The `xCallbackFunc` function is used to extract specific feature values from each row of data, defining what the model will use as input. By selecting relevant fields in the dataset, `xCallbackFunc` ensures only the necessary values are included in the model’s feature set, allowing for streamlined preprocessing and improved model performance.
 
-### `parseLabels`
+### `yCallbackFunc`
 
-The `parseLabels` function defines the target output (or labels) that the machine learning model will learn to predict. This function typically creates labels by comparing each row of data with a future data point, which is especially useful in time-series data for predictive tasks. In our example, `parseLabels` generates labels based on changes between the current and next rows, which can help the model learn to predict directional trends.
+The `yCallbackFunc` function defines the target output (or Y) that the machine learning model will learn to predict. This function typically creates Y by comparing each row of data with a future data point, which is especially useful in time-series data for predictive tasks. In our example, `yCallbackFunc` generates Y based on changes between the current and next rows, which can help the model learn to predict directional trends.
 
 
 ---
@@ -80,7 +80,7 @@ The `parseLabels` function defines the target output (or labels) that the machin
 1. **Parsing and Splitting a Training Dataset:**
 
     ```javascript
-    import { parseTrainingDataset } from './scale.js';
+    import { parseTrainingXY } from './scale.js';
 
     const myArray = [
         { open: 135.23, high: 137.45, low: 134.56, sma_200: 125.34, sma_100: 130.56 },
@@ -88,7 +88,7 @@ The `parseLabels` function defines the target output (or labels) that the machin
         { open: 137.89, high: 139.34, low: 136.34, sma_200: 127.56, sma_100: 132.78 }
     ];
 
-    const parseFeatures = ({ objRow, index }) => {
+    const xCallbackFunc = ({ objRow, index }) => {
         const curr = objRow[index];
         const { open, high, low, sma_200, sma_100 } = curr;
 
@@ -101,7 +101,7 @@ The `parseLabels` function defines the target output (or labels) that the machin
         };
     };
 
-    const parseLabels = ({ objRow, index }) => {
+    const yCallbackFunc = ({ objRow, index }) => {
         const curr = objRow[index];
         const next = objRow[index + 1];
 
@@ -116,12 +116,12 @@ The `parseLabels` function defines the target output (or labels) that the machin
         };
     };
 
-    const trainingData = parseTrainingDataset({
+    const trainingData = parseTrainingXY({
         arrObj: myArray,
         trainingSplit: 0.75,
         weights: { open: 1, high: 1, low: 1, sma_200: 1, sma_100: 1 },
-        parseLabels,
-        parseFeatures,
+        yCallbackFunc,
+        xCallbackFunc,
         forceScaling: 'normalization'
     });
     ```
@@ -129,9 +129,9 @@ The `parseLabels` function defines the target output (or labels) that the machin
 2. **Parsing a Production Dataset:**
 
     ```javascript
-    import { parseProductionDataset } from './scale.js';
+    import { parseProductionX } from './scale.js';
 
-    const parseFeatures = ({ objRow, index }) => {
+    const xCallbackFunc = ({ objRow, index }) => {
         const curr = objRow[index];
         const { open, high, low, sma_200, sma_100 } = curr;
 
@@ -144,16 +144,44 @@ The `parseLabels` function defines the target output (or labels) that the machin
         };
     };
 
-    const productionData = parseProductionDataset({
+    const productionData = parseProductionX({
         arrObj: productionArray,
         weights: { open: 2, high: 1, low: 1, sma_200: 1, sma_100: 1 },
-        parseFeatures: (row) => row.features,
+        xCallbackFunc,
         forceScaling: null
     });
     ```
 
 ---
 
+### Upcoming Feature: Optional Precision Handling with Big.js and BigNumber.js
+
+In the next release, we are introducing an optional **precision** feature to enhance decimal precision in financial and scientific datasets. This feature will allow users to integrate **Big.js** or **BigNumber.js** libraries seamlessly into their data processing workflow by adding a new `precision` property to the parameters of `parseTrainingXY` and `parseProductionX`.
+
+#### How Precision Handling Will Work
+
+With the new `precision` property, users can pass either Big.js or BigNumber.js as callback functions to handle high-precision decimal calculations. This makes the integration fully optional, allowing flexibility based on the precision requirements of the dataset. When `precision` is set, the toolkit will use the specified library for all numeric computations, ensuring high precision and minimizing rounding errors.
+
+1. **Future Example Usage:**
+
+    ```javascript
+    import Big from 'big.js';
+    import BigNumber from 'bignumber.js';
+    import { parseTrainingXY, parseProductionX } from './scale.js';
+
+    const trainingData = parseTrainingXY({
+        arrObj: myArray,
+        trainingSplit: 0.75,
+        weights: { open: 1, high: 1, low: 1, sma_200: 1, sma_100: 1 },
+        yCallbackFunc,
+        xCallbackFunc,
+        precision: Big, // Big or BigNumber callbacks for high-precision calculations
+        forceScaling: 'normalization'
+    });
+    ```
+
+---
+
 ## Technical Details
 
 - **Error Handling**: Validates scaling approach values and ensures positive feature weights.

package/dist/xy-scale.min.js

@@ -1 +1 @@
-var XY_Scale;(()=>{"use strict";var e={d:(t,r)=>{for(var n in r)e.o(r,n)&&!e.o(t,n)&&Object.defineProperty(t,n,{enumerable:!0,get:r[n]})},o:(e,t)=>Object.prototype.hasOwnProperty.call(e,t),r:e=>{"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(e,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(e,"__esModule",{value:!0})}},t={};e.r(t),e.d(t,{parseProductionDataset:()=>o,parseTrainingDataset:()=>n});const r=({arrObj:e,weights:t={},forceScaling:r=null})=>{if(null!==r&&"normalization"!==r&&"standardization"!==r)throw Error('forceScalling should be null, "normalization" or "standardization"');const n=e.length;if(0===n)return{scaledOutput:[],scaledConfig:{},keyNames:[]};const o=Object.keys(e[0]),a=o.map((e=>{if(t.hasOwnProperty(e)){const r=t[e];if(r<=0)throw new Error(`Weight for key "${e}" must be positive.`);return r}return 1})),s=a.reduce(((e,t)=>e+t),0),i=new Array(s);let l=0;for(let e=0;e<o.length;e++){const t=o[e],r=a[e];for(let e=0;e<r;e++)i[l++]=t}const c={},u={},f={},d={},g={},p={},y={},b={};for(const t of o){const r=e[0][t];c[t]=typeof r,"string"===c[t]&&(y[t]={}),u[t]=1/0,f[t]=-1/0,d[t]=0,g[t]=0,b[t]=0}for(const t of e)for(const e of o){let r=t[e];if("string"===c[e]){const n=y[e];n.hasOwnProperty(r)||(n[r]=Object.keys(n).length),r=n[r],t[e]=r}r<u[e]&&(u[e]=r),r>f[e]&&(f[e]=r),b[e]++;const n=r-d[e];d[e]+=n/b[e],g[e]+=n*(r-d[e])}const h={};for(const e of o)h[e]=b[e]>1?Math.sqrt(g[e]/(b[e]-1)):0,p[e]="normalization"===r||"standardization"===r?r:h[e]<1?"normalization":"standardization";const m=new Array(n);for(let t=0;t<n;t++){const r=e[t],n=new Array(s);let i=0;for(let e=0;e<o.length;e++){const t=o[e],s=r[t],l=u[t],c=f[t],g=d[t],y=h[t];let b;b="normalization"===p[t]?c!==l?(s-l)/(c-l):0:0!==y?(s-g)/y:0;const m=a[e];for(let e=0;e<m;e++)n[i++]=b}m[t]=n}return{scaledOutput:m,scaledConfig:{min:u,max:f,std:h,mean:d,approach:p,inputTypes:c,uniqueStringIndexes:y},scaledKeyNames:i}},n=({arrObj:e,trainingSplit:t=.8,weights:n={},parseLabels:o,parseFeatures:a,forceScaling:s})=>{const i=[],l=[];for(let t=0;t<e.length;t++){const r=a({objRow:e,index:t}),n=o({objRow:e,index:t});r&&n&&(i.push(r),l.push(n))}const{scaledOutput:c,scaledConfig:u,scaledKeyNames:f}=r({arrObj:i,weights:n,forceScaling:s}),{scaledOutput:d,scaledConfig:g,scaledKeyNames:p}=r({arrObj:l,weights:n,forceScaling:s}),y=Math.floor(c.length*t);return{trainFeatures:c.slice(0,y),trainLabels:d.slice(0,y),testFeatures:c.slice(y),testLabels:d.slice(y),trainFeaturesConfig:u,trainFeaturesKeyNames:f,trainLabelsConfig:g,trainLabelKeyNames:p}},o=({arrObj:e,weights:t={},parseFeatures:n,forceScaling:o})=>{const a=[];for(let t=0;t<e.length;t++){const r=n({objRow:e,index:t});r&&a.push(r)}const{scaledOutput:s,scaledConfig:i,scaledKeyNames:l}=r({arrObj:a,weights:t,forceScaling:o});return{productionFeatures:s,productionFeaturesConfig:i,productionFeaturesKeyNames:l}};XY_Scale=t})();
+var XY_Scale;(()=>{"use strict";var e={d:(t,r)=>{for(var n in r)e.o(r,n)&&!e.o(t,n)&&Object.defineProperty(t,n,{enumerable:!0,get:r[n]})},o:(e,t)=>Object.prototype.hasOwnProperty.call(e,t),r:e=>{"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(e,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(e,"__esModule",{value:!0})}},t={};e.r(t),e.d(t,{parseProductionX:()=>o,parseTrainingXY:()=>n});const r=({arrObj:e,weights:t={},forceScaling:r=null})=>{if(null!==r&&"normalization"!==r&&"standardization"!==r)throw Error('forceScalling should be null, "normalization" or "standardization"');const n=e.length;if(0===n)return{scaledOutput:[],scaledConfig:{},keyNames:[]};const o=Object.keys(e[0]),a=o.map((e=>{if(t.hasOwnProperty(e)){const r=t[e];if(r<=0)throw new Error(`Weight for key "${e}" must be positive.`);return r}return 1})),s=a.reduce(((e,t)=>e+t),0),i=new Array(s);let l=0;for(let e=0;e<o.length;e++){const t=o[e],r=a[e];for(let e=0;e<r;e++)i[l++]=t}const c={},u={},f={},d={},g={},p={},y={},b={};for(const t of o){const r=e[0][t];c[t]=typeof r,"string"===c[t]&&(y[t]={}),u[t]=1/0,f[t]=-1/0,d[t]=0,g[t]=0,b[t]=0}for(const t of e)for(const e of o){let r=t[e];if("string"===c[e]){const n=y[e];n.hasOwnProperty(r)||(n[r]=Object.keys(n).length),r=n[r],t[e]=r}r<u[e]&&(u[e]=r),r>f[e]&&(f[e]=r),b[e]++;const n=r-d[e];d[e]+=n/b[e],g[e]+=n*(r-d[e])}const h={};for(const e of o)h[e]=b[e]>1?Math.sqrt(g[e]/(b[e]-1)):0,p[e]="normalization"===r||"standardization"===r?r:h[e]<1?"normalization":"standardization";const m=new Array(n);for(let t=0;t<n;t++){const r=e[t],n=new Array(s);let i=0;for(let e=0;e<o.length;e++){const t=o[e],s=r[t],l=u[t],c=f[t],g=d[t],y=h[t];let b;b="normalization"===p[t]?c!==l?(s-l)/(c-l):0:0!==y?(s-g)/y:0;const m=a[e];for(let e=0;e<m;e++)n[i++]=b}m[t]=n}return{scaledOutput:m,scaledConfig:{min:u,max:f,std:h,mean:d,approach:p,inputTypes:c,uniqueStringIndexes:y},scaledKeyNames:i}},n=({arrObj:e,trainingSplit:t=.8,weights:n={},yCallbackFunc:o,xCallbackFunc:a,forceScaling:s})=>{const i=[],l=[];for(let t=0;t<e.length;t++){const r=a({objRow:e,index:t}),n=o({objRow:e,index:t});r&&n&&(i.push(r),l.push(n))}const{scaledOutput:c,scaledConfig:u,scaledKeyNames:f}=r({arrObj:i,weights:n,forceScaling:s}),{scaledOutput:d,scaledConfig:g,scaledKeyNames:p}=r({arrObj:l,weights:n,forceScaling:s}),y=Math.floor(c.length*t);return{trainX:c.slice(0,y),trainY:d.slice(0,y),testX:c.slice(y),testY:d.slice(y),trainXConfig:u,trainXKeyNames:f,trainYConfig:g,trainLabelKeyNames:p}},o=({arrObj:e,weights:t={},xCallbackFunc:n,forceScaling:o})=>{const a=[];for(let t=0;t<e.length;t++){const r=n({objRow:e,index:t});r&&a.push(r)}const{scaledOutput:s,scaledConfig:i,scaledKeyNames:l}=r({arrObj:a,weights:t,forceScaling:o});return{x:s,xConfig:i,xKeyNames:l}};XY_Scale=t})();

package/index.js

@@ -1,3 +1,3 @@
-import { parseTrainingDataset, parseProductionDataset } from "./src/datasets.js"
+import { parseTrainingXY, parseProductionX } from "./src/datasets.js"
 
-export { parseTrainingDataset, parseProductionDataset }
+export { parseTrainingXY, parseProductionX }

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "xy-scale",
-  "version": "1.0.2",
+  "version": "1.0.5",
   "main": "./index.js",
   "type": "module",
   "scripts": {
-    "build": "npx webpack"
+    "build": "npx webpack",
+    "test": "node test/test.js"
   },
   "author": "",
   "license": "ISC",

package/src/datasets.js

@@ -1,75 +1,75 @@
 import { scaleArrayObj } from "./scale.js";
 
-export const parseTrainingDataset = ({ arrObj, trainingSplit = 0.8, weights = {}, parseLabels, parseFeatures, forceScaling }) => {
-    const features = [];
-    const labels = [];
+export const parseTrainingXY = ({ arrObj, trainingSplit = 0.8, weights = {}, yCallbackFunc, xCallbackFunc, forceScaling }) => {
+    const X = [];
+    const Y = [];
 
     for (let x = 0; x < arrObj.length; x++) {
-        const parsedFeatures = parseFeatures({ objRow: arrObj, index: x });
-        const parsedLabels = parseLabels({ objRow: arrObj, index: x });
+        const parsedX = xCallbackFunc({ objRow: arrObj, index: x });
+        const parsedY = yCallbackFunc({ objRow: arrObj, index: x });
 
-        if (parsedFeatures && parsedLabels) {
-            features.push(parsedFeatures)
-            labels.push(parsedLabels)
+        if (parsedX && parsedY) {
+            X.push(parsedX)
+            Y.push(parsedY)
         }
     }
 
-    // Scale features and labels, if applicable
+    // Scale X and Y, if applicable
     const {
-        scaledOutput: scaledFeatures, 
-        scaledConfig: trainFeaturesConfig, 
-        scaledKeyNames: trainFeaturesKeyNames
+        scaledOutput: scaledX, 
+        scaledConfig: trainXConfig, 
+        scaledKeyNames: trainXKeyNames
 
-    } = scaleArrayObj({arrObj: features, weights, forceScaling})
+    } = scaleArrayObj({arrObj: X, weights, forceScaling})
 
     const {
-        scaledOutput: scaledLabels,
-        scaledConfig: trainLabelsConfig,
-        scaledKeyNames: trainLabelKeyNames
-    } = scaleArrayObj({arrObj: labels, weights, forceScaling})
+        scaledOutput: scaledY,
+        scaledConfig: trainYConfig,
+        scaledKeyNames: trainYKeyNames
+    } = scaleArrayObj({arrObj: Y, weights, forceScaling})
 
-    const splitIndex = Math.floor(scaledFeatures.length * trainingSplit)
+    const splitIndex = Math.floor(scaledX.length * trainingSplit)
 
     // Split into training and testing sets
     return {
-        trainFeatures: scaledFeatures.slice(0, splitIndex),
-        trainLabels: scaledLabels.slice(0, splitIndex),
-        testFeatures: scaledFeatures.slice(splitIndex),
-        testLabels: scaledLabels.slice(splitIndex),
-
-        trainFeaturesConfig,
-        trainFeaturesKeyNames,
-        trainLabelsConfig,
-        trainLabelKeyNames
+        trainX: scaledX.slice(0, splitIndex),
+        trainY: scaledY.slice(0, splitIndex),
+        testX: scaledX.slice(splitIndex),
+        testY: scaledY.slice(splitIndex),
+
+        trainXConfig,
+        trainXKeyNames,
+        trainYConfig,
+        trainYKeyNames
     };
 };
 
 
-export const parseProductionDataset = ({ arrObj, weights = {}, parseFeatures, forceScaling }) => {
-    const features = [];
+export const parseProductionX = ({ arrObj, weights = {}, xCallbackFunc, forceScaling }) => {
+    const X = [];
 
     for (let x = 0; x < arrObj.length; x++) {
-        const parsedFeatures = parseFeatures({ objRow: arrObj, index: x })
+        const parsedX = xCallbackFunc({ objRow: arrObj, index: x })
 
-        if (parsedFeatures) {
-            features.push(parsedFeatures)
+        if (parsedX) {
+            X.push(parsedX)
         }
     }
 
-    // Scale features and labels, if applicable
-    // Scale features and labels, if applicable
+    // Scale X and Y, if applicable
+    // Scale X and Y, if applicable
     const {
-        scaledOutput: scaledFeatures, 
-        scaledConfig: productionFeaturesConfig, 
-        scaledKeyNames: productionFeaturesKeyNames
+        scaledOutput: scaledX, 
+        scaledConfig: xConfig, 
+        scaledKeyNames: xKeyNames
 
-    } = scaleArrayObj({arrObj: features, weights, forceScaling})
+    } = scaleArrayObj({arrObj: X, weights, forceScaling})
 
 
     // Split into training and testing sets
     return {
-        productionFeatures: scaledFeatures,
-        productionFeaturesConfig,
-        productionFeaturesKeyNames
+        x: scaledX,
+        xConfig,
+        xKeyNames
     }
 };

package/test/test.js

@@ -0,0 +1,64 @@
+import { parseTrainingXY, parseProductionX } from "../src/datasets.js";
+
+
+const test = () => {
+
+
+    const myArray = [
+        { open: 135.23, high: 137.45, low: 134.56, sma_200: 125.34, sma_100: 130.56 },
+        { open: 136.45, high: 138.67, low: 135.67, sma_200: 126.78, sma_100: 131.45 },
+        { open: 137.89, high: 139.34, low: 136.34, sma_200: 127.56, sma_100: 132.78 }
+    ];
+    
+    const xCallbackFunc = ({ objRow, index }) => {
+        const curr = objRow[index];
+        const { open, high, low, sma_200, sma_100 } = curr;
+    
+        return {
+            open,
+            high,
+            low,
+            sma_200,
+            sma_100
+        };
+    };
+    
+    const yCallbackFunc = ({ objRow, index }) => {
+        const curr = objRow[index];
+        const next = objRow[index + 1];
+    
+        if (typeof next === 'undefined') return null;
+    
+        return {
+            label_1: next.open > curr.open,       // Label indicating if the next open price is higher than the current
+            label_2: next.high > curr.high,       // Label indicating if the next high price is higher than the current
+            label_3: next.low > curr.low,         // Label indicating if the next low price is higher than the current
+            label_4: next.sma_200 > curr.sma_200, // Label indicating if the next 200-day SMA is higher than the current
+            label_5: next.sma_100 > curr.sma_100  // Label indicating if the next 100-day SMA is higher than the current
+        };
+    };
+    
+    const trainingData = parseTrainingXY({
+        arrObj: myArray,
+        trainingSplit: 0.75,
+        weights: { open: 1, high: 1, low: 1, sma_200: 1, sma_100: 1 },
+        yCallbackFunc,
+        xCallbackFunc,
+        forceScaling: 'normalization'
+    });
+
+    //console.log(trainingData)
+
+
+    const productionData = parseProductionX({
+        arrObj: myArray,
+        weights: { open: 2, high: 1, low: 1, sma_200: 1, sma_100: 1 },
+        xCallbackFunc,
+        forceScaling: null
+    })
+
+    console.log(productionData)
+
+}
+
+test()