xy-scale 1.0.3 → 1.0.7

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,62 @@ 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.
+- `timeSteps` (Number, optional): Transforms a one-dimensional array into an array of overlapping sequences (timesteps), each of a specified length. Default is 0 returning original output.
 
 #### 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.
+- `timeSteps` (Number, optional): Transforms a one-dimensional array into an array of overlapping sequences (timesteps), each of a specified length. Default is 0 returning original output.
 
 #### 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.
 
 
 ---
@@ -79,8 +81,8 @@ 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';
+```javascript
+    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 +90,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 +103,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,22 +118,28 @@ 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,
-        forceScaling: 'normalization'
+        yCallbackFunc,
+        xCallbackFunc,
+        forceScaling: 'normalization',
+        timeSteps: 0
     });
-    ```
+```
+
+**Output:**
+```json
+    {"trainX":[[0,0,0,0,0]],"trainY":[[0,0,0,0,0]],"testX":[[1,1,1,1,1]],"testY":[[0,0,0,0,0]],"trainXConfig":{"min":{"open":135.23,"high":137.45,"low":134.56,"sma_200":125.34,"sma_100":130.56},"max":{"open":136.45,"high":138.67,"low":135.67,"sma_200":126.78,"sma_100":131.45},"std":{"open":0.8626702730475972,"high":0.8626702730475772,"low":0.7848885271170473,"sma_200":1.0182337649086268,"sma_100":0.6293250352560177},"mean":{"open":135.83999999999997,"high":138.06,"low":135.115,"sma_200":126.06,"sma_100":131.005},"approach":{"open":"normalization","high":"normalization","low":"normalization","sma_200":"normalization","sma_100":"normalization"},"inputTypes":{"open":"number","high":"number","low":"number","sma_200":"number","sma_100":"number"},"uniqueStringIndexes":{}},"trainXKeyNames":["open","high","low","sma_200","sma_100"],"trainYConfig":{"min":{"label_1":true,"label_2":true,"label_3":true,"label_4":true,"label_5":true},"max":{"label_1":true,"label_2":true,"label_3":true,"label_4":true,"label_5":true},"std":{"label_1":0,"label_2":0,"label_3":0,"label_4":0,"label_5":0},"mean":{"label_1":1,"label_2":1,"label_3":1,"label_4":1,"label_5":1},"approach":{"label_1":"normalization","label_2":"normalization","label_3":"normalization","label_4":"normalization","label_5":"normalization"},"inputTypes":{"label_1":"boolean","label_2":"boolean","label_3":"boolean","label_4":"boolean","label_5":"boolean"},"uniqueStringIndexes":{}},"trainYKeyNames":["label_1","label_2","label_3","label_4","label_5"]}
+```
 
 2. **Parsing a Production Dataset:**
 
-    ```javascript
-    import { parseProductionDataset } from './scale.js';
+```javascript
+    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,41 +152,61 @@ The `parseLabels` function defines the target output (or labels) that the machin
         };
     };
 
-    const productionData = parseProductionDataset({
-        arrObj: productionArray,
+    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 productionData = parseProductionX({
+        arrObj: myArray,
         weights: { open: 2, high: 1, low: 1, sma_200: 1, sma_100: 1 },
-        parseFeatures: (row) => row.features,
-        forceScaling: null
+        xCallbackFunc,
+        forceScaling: null,
+        timeSteps: 0
     });
-    ```
+```
+
+**Output:**
+
+```json
+        {"x":[[-0.9713243322194223,-0.9713243322194223,0,0,-1.0832575234857975,-0.9278787875246485],[-0.05507509100212526,-0.05507509100212526,0.6455026455026398,0.6235955056179688,0.19534152062858562,-0.1312754554697336],[1.026399423221569,1.026399423221569,1,1,0.887916002857212,1.059154242994382]],"xConfig":{"min":{"open":135.23,"high":137.45,"low":134.56,"sma_200":125.34,"sma_100":130.56},"max":{"open":137.89,"high":139.34,"low":136.34,"sma_200":127.56,"sma_100":132.78},"std":{"open":1.3315154273733958,"high":0.9582449234581516,"low":0.899017982764145,"sma_200":1.1262326580240862,"sma_100":1.1172436320397328},"mean":{"open":136.5233333333333,"high":138.48666666666668,"low":135.52333333333334,"sma_200":126.56,"sma_100":131.59666666666666},"approach":{"open":"standardization","high":"normalization","low":"normalization","sma_200":"standardization","sma_100":"standardization"},"inputTypes":{"open":"number","high":"number","low":"number","sma_200":"number","sma_100":"number"},"uniqueStringIndexes":{}},"xKeyNames":["open","open","high","low","sma_200","sma_100"]}
+```
 
 ---
 
 ### 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 `parseTrainingDataset` and `parseProductionDataset`.
+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.
 
-**Future Example Usage:**
+1. **Future Example Usage:**
 
-    ```javascript
+```javascript
     import Big from 'big.js';
-    import BigNumber from "bignumber.js";
-    import { parseTrainingDataset, parseProductionDataset } from './scale.js';
+    import BigNumber from 'bignumber.js';
+    import { parseTrainingXY, parseProductionX } from './scale.js';
+
+    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 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,
-        precision: Big, // Big or BigNumber for high-precision calculations
-        forceScaling: 'normalization'
+        yCallbackFunc,
+        xCallbackFunc,
+        precision: Big, // Big or BigNumber callbacks for high-precision calculations
+        forceScaling: 'normalization',
+        timeSteps: 0
     });
-    ```
+```
 
 ---
 

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,n)=>{for(var r in n)e.o(n,r)&&!e.o(t,r)&&Object.defineProperty(t,r,{enumerable:!0,get:n[r]})},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:()=>a,parseTrainingXY:()=>o});const n=({arrObj:e,weights:t={},forceScaling:n=null})=>{if(null!==n&&"normalization"!==n&&"standardization"!==n)throw Error('forceScalling should be null, "normalization" or "standardization"');const r=e.length;if(0===r)return{scaledOutput:[],scaledConfig:{},keyNames:[]};const o=Object.keys(e[0]),a=o.map((e=>{if(t.hasOwnProperty(e)){const n=t[e];if(n<=0)throw new Error(`Weight for key "${e}" must be positive.`);return n}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],n=a[e];for(let e=0;e<n;e++)i[l++]=t}const c={},f={},u={},g={},d={},p={},h={},y={};for(const t of o){const n=e[0][t];c[t]=typeof n,"string"===c[t]&&(h[t]={}),f[t]=1/0,u[t]=-1/0,g[t]=0,d[t]=0,y[t]=0}for(const t of e)for(const e of o){let n=t[e];if("string"===c[e]){const r=h[e];r.hasOwnProperty(n)||(r[n]=Object.keys(r).length),n=r[n],t[e]=n}n<f[e]&&(f[e]=n),n>u[e]&&(u[e]=n),y[e]++;const r=n-g[e];g[e]+=r/y[e],d[e]+=r*(n-g[e])}const m={};for(const e of o)m[e]=y[e]>1?Math.sqrt(d[e]/(y[e]-1)):0,p[e]="normalization"===n||"standardization"===n?n:m[e]<1?"normalization":"standardization";const b=new Array(r);for(let t=0;t<r;t++){const n=e[t],r=new Array(s);let i=0;for(let e=0;e<o.length;e++){const t=o[e],s=n[t],l=f[t],c=u[t],d=g[t],h=m[t];let y;y="normalization"===p[t]?c!==l?(s-l)/(c-l):0:0!==h?(s-d)/h:0;const b=a[e];for(let e=0;e<b;e++)r[i++]=y}b[t]=r}return{scaledOutput:b,scaledConfig:{min:f,max:u,std:m,mean:g,approach:p,inputTypes:c,uniqueStringIndexes:h},scaledKeyNames:i}},r=(e,t)=>{if(0===t)return e;if(t<0)throw new Error("timeSteps must be greater than 0");const n=[];for(let r=0;r<=e.length-t;r++)n.push(e.slice(r,r+t));return n},o=({arrObj:e,trainingSplit:t=.8,weights:o={},yCallbackFunc:a,xCallbackFunc:s,forceScaling:i,timeSteps:l=0})=>{const c=[],f=[];for(let t=0;t<e.length;t++){const n=s({objRow:e,index:t}),r=a({objRow:e,index:t});n&&r&&(c.push(n),f.push(r))}const{scaledOutput:u,scaledConfig:g,scaledKeyNames:d}=n({arrObj:c,weights:o,forceScaling:i}),{scaledOutput:p,scaledConfig:h,scaledKeyNames:y}=n({arrObj:f,weights:o,forceScaling:i}),m=Math.floor(u.length*t);return{trainX:r(u.slice(0,m),l),trainY:r(p.slice(0,m),l),testX:r(u.slice(m),l),testY:r(p.slice(m),l),trainXConfig:g,trainXKeyNames:d,trainYConfig:h,trainYKeyNames:y}},a=({arrObj:e,weights:t={},xCallbackFunc:o,forceScaling:a,timeSteps:s=0})=>{const i=[];for(let t=0;t<e.length;t++){const n=o({objRow:e,index:t});n&&i.push(n)}const{scaledOutput:l,scaledConfig:c,scaledKeyNames:f}=n({arrObj:i,weights:t,forceScaling:a});return{x:r(l,s),xConfig:c,xKeyNames:f}};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.3",
+  "version": "1.0.7",
   "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,90 @@
 import { scaleArrayObj } from "./scale.js";
 
-export const parseTrainingDataset = ({ arrObj, trainingSplit = 0.8, weights = {}, parseLabels, parseFeatures, forceScaling }) => {
-    const features = [];
-    const labels = [];
+const arrayToTimesteps = (arr, timeSteps) => {
+    if (timeSteps === 0) return arr;
+    if (timeSteps < 0) throw new Error("timeSteps must be greater than 0");
+    
+    const timestepsArray = [];
+    
+    for (let i = 0; i <= arr.length - timeSteps; i++) {
+        timestepsArray.push(arr.slice(i, i + timeSteps));
+    }
+    
+    return timestepsArray;
+}
+
+
+
+export const parseTrainingXY = ({ arrObj, trainingSplit = 0.8, weights = {}, yCallbackFunc, xCallbackFunc, forceScaling, timeSteps = 0 }) => {
+    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: arrayToTimesteps(scaledX.slice(0, splitIndex), timeSteps),
+        trainY: arrayToTimesteps(scaledY.slice(0, splitIndex), timeSteps),
+        testX: arrayToTimesteps(scaledX.slice(splitIndex), timeSteps),
+        testY: arrayToTimesteps(scaledY.slice(splitIndex), timeSteps),
+
+        trainXConfig,
+        trainXKeyNames,
+        trainYConfig,
+        trainYKeyNames
     };
 };
 
 
-export const parseProductionDataset = ({ arrObj, weights = {}, parseFeatures, forceScaling }) => {
-    const features = [];
+export const parseProductionX = ({ arrObj, weights = {}, xCallbackFunc, forceScaling, timeSteps = 0 }) => {
+    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: arrayToTimesteps(scaledX, timeSteps),
+        xConfig,
+        xKeyNames
     }
 };

package/test/test.js

@@ -0,0 +1,66 @@
+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',
+        timeSteps: 0
+    });
+
+    //console.log(JSON.stringify(trainingData))
+
+
+    const productionData = parseProductionX({
+        arrObj: myArray,
+        weights: { open: 2, high: 1, low: 1, sma_200: 1, sma_100: 1 },
+        xCallbackFunc,
+        forceScaling: null,
+        timeSteps: 0
+    })
+
+    console.log(JSON.stringify(productionData))
+
+}
+
+test()