xy-scale 1.2.1 → 1.2.2

package/dist/xy-scale.min.js

@@ -1 +1 @@
-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,{arrayToTimesteps:()=>c,descaleArrayObj:()=>l,parseProductionX:()=>s,parseTrainingXY:()=>o});const n=({arrObj:e,repeat:t={},minmaxRange:n=[0,1],groups:o={}})=>{const s=e.length;if(r(o),0===s)return{scaledOutput:[],scaledConfig:{},keyNames:[]};const[l,c]=n;if(l>=c)throw new Error("Invalid minmaxRange: rangeMin must be less than rangeMax");const i=Object.keys(e[0]),u=i.map((e=>t.hasOwnProperty(e)?Math.max(t[e],1):1)),f=u.reduce(((e,t)=>e+t),0),m=new Array(f);let h=0;for(let e=0;e<i.length;e++)for(let t=0;t<u[e];t++)m[h++]=i[e];const p={},g={},d={},b={},y={};for(const t of i){const n=e[0][t];p[t]=typeof n,"string"===p[t]&&(b[t]={});const r=a(t,o);r?y[r]||(y[r]={min:1/0,max:-1/0}):(g[t]=1/0,d[t]=-1/0)}for(const t of e)for(const e of i){let n=t[e];if("string"===p[e]){const r=b[e];r.hasOwnProperty(n)||(r[n]=Object.keys(r).length),n=r[n],t[e]=n}else"boolean"===p[e]&&(t[e]=Number(n));const r=a(e,o);r?(y[r].min=Math.min(y[r].min,n),y[r].max=Math.max(y[r].max,n)):(g[e]=Math.min(g[e],n),d[e]=Math.max(d[e],n))}const O=new Array(s);for(let t=0;t<s;t++){const n=e[t],r=new Array(f);let s=0;for(let e=0;e<i.length;e++){const t=i[e],f=n[t],m=a(t,o);let h,p;m?(h=y[m].min,p=y[m].max):(h=g[t],p=d[t]);const b=p!==h?l+(f-h)/(p-h)*(c-l):l,O=u[e];for(let e=0;e<O;e++)r[s++]=b}O[t]=r}return{scaledOutput:O,scaledConfig:{min:g,max:d,inputTypes:p,uniqueStringIndexes:b,rangeMin:l,rangeMax:c,groupMinMax:y},scaledKeyNames:m}},r=e=>{const t=new Set,n=[];for(const[r,a]of Object.entries(e))t.add(r),n.push(r),a.forEach((e=>{t.add(e),n.push(e)}));if(t.size!==n.length)throw new Error("Duplicate value found between properties in validateUniqueProperties function.")},a=(e,t)=>{for(const[n,r]of Object.entries(t))if(r.includes(e))return n;return null},o=({arrObj:e,trainingSplit:t=.8,repeat:r={},yCallbackFunc:a,xCallbackFunc:o,groups:s,shuffle:l=!1,minmaxRange:c,balancing:i=""})=>{let u=[],f=[];for(let t=0;t<e.length;t++){const n=o({objRow:e,index:t}),r=a({objRow:e,index:t});null!=n&&null!=r&&(u.push(n),f.push(r))}if(l){const{shuffledX:e,shuffledY:t}=((e,t)=>{if(e.length!==t.length)throw new Error("X and Y arrays must have the same length");const n=Array.from({length:e.length},((e,t)=>t));for(let e=n.length-1;e>0;e--){const t=Math.floor(Math.random()*(e+1));[n[e],n[t]]=[n[t],n[e]]}return{shuffledX:n.map((t=>e[t])),shuffledY:n.map((e=>t[e]))}})(u,f);u=e,f=t}let{scaledOutput:m,scaledConfig:h,scaledKeyNames:p}=n({arrObj:u,repeat:r,groups:s,minmaxRange:c}),{scaledOutput:g,scaledConfig:d,scaledKeyNames:b}=n({arrObj:f,repeat:r,groups:s,minmaxRange:c});if(i){let e;if("oversample"===i)e=((e,t)=>{const n={},r={};t.forEach(((a,o)=>{n[a]||(n[a]=0,r[a]=[]),n[a]++,r[a].push([e[o],t[o]])}));const a=Math.max(...Object.values(n)),o=[],s=[];return Object.keys(r).forEach((e=>{const t=r[e],n=t.length;for(let e=0;e<a;e++){const r=t[e%n];o.push(r[0]),s.push(r[1])}})),{X:o,Y:s}})(m,g),m=e.X,g=e.Y;else{if("undersample"!==i)throw Error('balancing argument only accepts "false", "oversample" and "undersample". Defaults to "false".');e=((e,t)=>{const n={},r={};t.forEach(((a,o)=>{n[a]||(n[a]=0,r[a]=[]),n[a]++,r[a].push([e[o],t[o]])}));const a=Math.min(...Object.values(n)),o=[],s=[];return Object.keys(r).forEach((e=>{const t=r[e];for(let e=0;e<a;e++){const n=t[e];o.push(n[0]),s.push(n[1])}})),{X:o,Y:s}})(m,g),m=e.X,g=e.Y}}const y=Math.floor(m.length*t);return{trainX:m.slice(0,y),trainY:g.slice(0,y),testX:m.slice(y),testY:g.slice(y),configX:h,keyNamesX:p,configY:d,keyNamesY:b}},s=({arrObj:e,repeat:t={},xCallbackFunc:r,groups:a,shuffle:o=!1,minmaxRange:s})=>{let l=[];for(let t=0;t<e.length;t++){const n=r({objRow:e,index:t});n&&l.push(n)}o&&(l=(e=>{const t=[...e];for(let e=t.length-1;e>0;e--){const n=Math.floor(Math.random()*(e+1));[t[e],t[n]]=[t[n],t[e]]}return t})(l));const{scaledOutput:c,scaledConfig:i,scaledKeyNames:u}=n({arrObj:l,repeat:t,groups:a,minmaxRange:s});return{X:c,configX:i,keyNamesX:u}},l=({scaled:e,config:t,keyNames:n})=>{const{min:r,max:a,std:o,mean:s,approach:l,inputTypes:c,uniqueStringIndexes:i}=t;return e.map((e=>{const t={};let u=0;for(const f of Object.keys(r)){const m=l[f],h=r[f],p=a[f],g=s[f],d=o[f],b=n.filter((e=>e===f)).length;let y=0;for(let t=0;t<b;t++)y+=e[u++];const O=y/b;let x;if("normalization"===m?x=O*(p-h)+h:"standardization"===m&&(x=O*d+g),"string"===c[f]){const e=Object.keys(i[f]).find((e=>i[f][e]===x));x=void 0!==e?e:x}t[f]=x}return t}))},c=(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};XY_Scale=t})();
+var XY_Scale;(()=>{"use strict";var e={d:(r,t)=>{for(var n in t)e.o(t,n)&&!e.o(r,n)&&Object.defineProperty(r,n,{enumerable:!0,get:t[n]})},o:(e,r)=>Object.prototype.hasOwnProperty.call(e,r),r:e=>{"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(e,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(e,"__esModule",{value:!0})}},r={};e.r(r),e.d(r,{arrayToTimesteps:()=>f,descaleArrayObj:()=>p,parseProductionX:()=>u,parseTrainingXY:()=>i});const t=({arrObj:e,repeat:r={},minmaxRange:t=[0,1],groups:i={},prevConfig:u=null})=>{const p=[...e],f=p.length,c=p[0];if(0===f)return{scaledOutput:[],scaledConfig:{}};let l={};const m=u&&o(u);if(m)s(u,{minmaxRange:t,repeat:r,groups:i,firstRow:c}),l={...u};else{const e=Object.keys(c),n=e.map((e=>r.hasOwnProperty(e)?Math.max(r[e],1):1)),a=n.reduce(((e,r)=>e+r),0);l={rangeMin:t[0],rangeMax:t[1],inputTypes:{},min:{},max:{},uniqueStrIdx:{},groupMinMax:{},repeat:r,groups:i,inputKeyNames:e,outputKeyNames:new Array(a),repeatedKeyNames:n};let s=0;for(let e=0;e<l.inputKeyNames.length;e++)for(let r=0;r<l.repeatedKeyNames[e];r++)l.outputKeyNames[s++]=l.inputKeyNames[e];o(l)}n(l.groups);for(const e of l.inputKeyNames){const r=typeof c[e];if(m){if(!l.inputTypes.hasOwnProperty(e))throw new Error(`Error: A new unknown inputType property "${e}" found.`);if(l.inputTypes[e]!==r)throw new Error(`Error: Current inputType of property "${e}" is not the same as in the prevConfig inputType.`);continue}l.inputTypes[e]=r,"string"===r&&(l.uniqueStrIdx[e]={});const t=a(e,l.groups);t?l.groupMinMax[t]={min:1/0,max:-1/0}:(l.min[e]=1/0,l.max[e]=-1/0)}for(const e of p)for(const r of l.inputKeyNames){let t=e[r];if("string"===l.inputTypes[r]){const n=l.uniqueStrIdx[r];n.hasOwnProperty(t)||(n[t]=Object.keys(n).length),t=n[t],e[r]=t}else"boolean"===l.inputTypes[r]&&(e[r]=Number(t));const n=a(r,l.groups);n?(l.groupMinMax[n].min=Math.min(l.groupMinMax[n].min,t),l.groupMinMax[n].max=Math.max(l.groupMinMax[n].max,t)):(l.min[r]=Math.min(l.min[r],t),l.max[r]=Math.max(l.max[r],t))}const g=new Array(f);for(let e=0;e<f;e++){const r=p[e],t=new Array(l.outputKeyNames.length);let n=0;for(let e=0;e<l.inputKeyNames.length;e++){const o=l.inputKeyNames[e],s=r[o],i=a(o,l.groups);let u,p;i?(u=l.groupMinMax[i].min,p=l.groupMinMax[i].max):(u=l.min[o],p=l.max[o]);const f=p!==u?l.rangeMin+(s-u)/(p-u)*(l.rangeMax-l.rangeMin):l.rangeMin,c=l.repeatedKeyNames[e];for(let e=0;e<c;e++)t[n++]=f}g[e]=t}return{scaledOutput:g,scaledConfig:l}},n=e=>{const r=new Set,t=[];for(const[n,a]of Object.entries(e))r.add(n),t.push(n),a.forEach((e=>{r.add(e),t.push(e)}));if(r.size!==t.length)throw new Error("Duplicate value found between properties in validateUniqueProperties function.")},a=(e,r)=>{for(const[t,n]of Object.entries(r))if(n.includes(e))return t;return null},o=e=>{if(!e)return!1;const r=["rangeMin","rangeMax","inputTypes","min","max","uniqueStrIdx","groupMinMax","repeat","groups","inputKeyNames","outputKeyNames","repeatedKeyNames"];for(const t of r)if(!e.hasOwnProperty(t))throw new Error(`Missing key "${t}" in config.`);const{rangeMin:t,rangeMax:n,inputTypes:a,min:o,max:s,uniqueStrIdx:i,groupMinMax:u,repeat:p,groups:f,inputKeyNames:c,outputKeyNames:l,repeatedKeyNames:m}=e;if("number"!=typeof t||"number"!=typeof n)throw new Error("rangeMin and rangeMax must be numbers.");if(t>=n)throw new Error("rangeMin must be less than rangeMax.");const g=e=>"object"==typeof e&&null!==e&&!Array.isArray(e);if(!g(a))throw new Error("inputTypes must be an object.");if(!g(o))throw new Error("min must be an object.");if(!g(s))throw new Error("max must be an object.");if(!g(i))throw new Error("uniqueStrIdx must be an object.");if(!g(u))throw new Error("groupMinMax must be an object.");if(!g(p))throw new Error("repeat must be an object.");if(!g(f))throw new Error("groups must be an object.");if(!Array.isArray(c))throw new Error("inputKeyNames must be an array.");if(!Array.isArray(l))throw new Error("outputKeyNames must be an array.");if(!Array.isArray(m))throw new Error("repeatedKeyNames must be an array.");return!0},s=(e,{minmaxRange:r,repeat:t,groups:n,firstRow:a})=>{if(e.rangeMin!==r[0]||e.rangeMax!==r[1])throw new Error('"prevConfig.minmaxRange" is not equal "minmaxRange".');if(JSON.stringify(e.inputKeyNames)!==JSON.stringify(Object.keys(a)))throw new Error('"prevConfig.inputKeyNames" structure does not match "Object.keys(firstRow)" structure. The order of keys is important.');if(JSON.stringify(e.repeat)!==JSON.stringify(t))throw new Error('"prevConfig.repeat" structure does not match "repeat" structure. The order of keys is important.');if(JSON.stringify(e.groups)!==JSON.stringify(n))throw new Error('"prevConfig.groups" structure does not match "groups" structure. The order of keys is important.');return!0},i=({arrObj:e,trainingSplit:r=.8,repeat:n={},yCallbackFunc:a,xCallbackFunc:o,validateRows:s=e=>e,groups:i,shuffle:u=!1,minmaxRange:p,balancing:f="",state:c={}})=>{let l=[],m=[];for(let r=0;r<e.length;r++){if(!s(e[r]))continue;const t=o({objRow:e,index:r,state:c}),n=a({objRow:e,index:r,state:c});null!=t&&null!=n&&(l.push(t),m.push(n))}if(u){const{shuffledX:e,shuffledY:r}=((e,r)=>{if(e.length!==r.length)throw new Error("X and Y arrays must have the same length");const t=Array.from({length:e.length},((e,r)=>r));for(let e=t.length-1;e>0;e--){const r=Math.floor(Math.random()*(e+1));[t[e],t[r]]=[t[r],t[e]]}return{shuffledX:t.map((r=>e[r])),shuffledY:t.map((e=>r[e]))}})(l,m);l=e,m=r}let{scaledOutput:g,scaledConfig:y}=t({arrObj:l,repeat:n,groups:i,minmaxRange:p}),{scaledOutput:h,scaledConfig:d}=t({arrObj:m,repeat:n,groups:i,minmaxRange:p});const w=Math.floor(g.length*r);let b=g.slice(0,w),x=h.slice(0,w),M=g.slice(w),O=h.slice(w);if(f){let e;if("oversample"===f)e=((e,r)=>{const t={},n={};r.forEach(((a,o)=>{t[a]||(t[a]=0,n[a]=[]),t[a]++,n[a].push([e[o],r[o]])}));const a=Math.max(...Object.values(t)),o=[],s=[];return Object.keys(n).forEach((e=>{const r=n[e],t=r.length;for(let e=0;e<a;e++){const n=r[e%t];o.push(n[0]),s.push(n[1])}})),{X:o,Y:s}})(b,x),b=e.X,x=e.Y;else{if("undersample"!==f)throw Error('balancing argument only accepts "false", "oversample" and "undersample". Defaults to "false".');e=((e,r)=>{const t={},n={};r.forEach(((a,o)=>{t[a]||(t[a]=0,n[a]=[]),t[a]++,n[a].push([e[o],r[o]])}));const a=Math.min(...Object.values(t)),o=[],s=[];return Object.keys(n).forEach((e=>{const r=n[e];for(let e=0;e<a;e++){const t=r[e];o.push(t[0]),s.push(t[1])}})),{X:o,Y:s}})(b,x),b=e.X,x=e.Y}}return{trainX:b,trainY:x,testX:M,testY:O,configX:y,configY:d}},u=({arrObj:e,repeat:r={},xCallbackFunc:n,validateRows:a=e=>e,groups:o,shuffle:s=!1,minmaxRange:i,state:u={}})=>{let p=[];for(let r=0;r<e.length;r++){if(!a(e[r]))continue;const t=n({objRow:e,index:r,state:u});t&&p.push(t)}s&&(p=(e=>{const r=[...e];for(let e=r.length-1;e>0;e--){const t=Math.floor(Math.random()*(e+1));[r[e],r[t]]=[r[t],r[e]]}return r})(p));const{scaledOutput:f,scaledConfig:c}=t({arrObj:p,repeat:r,groups:o,minmaxRange:i});return{X:f,configX:c,keyNamesX}},p=({scaled:e,config:r,keyNames:t})=>{const{min:n,max:a,std:o,mean:s,approach:i,inputTypes:u,uniqueStringIndexes:p}=r;return e.map((e=>{const r={};let f=0;for(const c of Object.keys(n)){const l=i[c],m=n[c],g=a[c],y=s[c],h=o[c],d=t.filter((e=>e===c)).length;let w=0;for(let r=0;r<d;r++)w+=e[f++];const b=w/d;let x;if("normalization"===l?x=b*(g-m)+m:"standardization"===l&&(x=b*h+y),"string"===u[c]){const e=Object.keys(p[c]).find((e=>p[c][e]===x));x=void 0!==e?e:x}r[c]=x}return r}))},f=(e,r)=>{if(0===r)return e;if(r<0)throw new Error("timeSteps must be greater than 0");const t=[];for(let n=0;n<=e.length-r;n++)t.push(e.slice(n,n+r));return t};XY_Scale=r})();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xy-scale",
-  "version": "1.2.1",
+  "version": "1.2.2",
   "main": "./index.js",
   "type": "module",
   "scripts": {

package/src/datasets.js

@@ -41,15 +41,12 @@ export const parseTrainingXY = ({
 
     let {
         scaledOutput: scaledX, 
-        scaledConfig: configX, 
-        scaledKeyNames: keyNamesX
-
+        scaledConfig: configX
     } = scaleArrayObj({arrObj: X, repeat, groups, minmaxRange})
 
     let {
         scaledOutput: scaledY,
         scaledConfig: configY,
-        scaledKeyNames: keyNamesY
     } = scaleArrayObj({arrObj: Y, repeat, groups, minmaxRange})
 
 
@@ -93,11 +90,8 @@ export const parseTrainingXY = ({
         trainY,
         testX,
         testY,
-
         configX,
-        keyNamesX,
         configY,
-        keyNamesY
     };
 };
 
@@ -133,9 +127,7 @@ export const parseProductionX = ({
     // Scale X
     const {
         scaledOutput: scaledX, 
-        scaledConfig: configX, 
-        scaledKeyNames: keyNamesX
-
+        scaledConfig: configX
     } = scaleArrayObj({arrObj: X, repeat, groups, minmaxRange})
 
 

package/src/scale.js

@@ -1,120 +1,155 @@
-export const scaleArrayObj = ({ arrObj, repeat = {}, minmaxRange = [0, 1], groups = {} }) => {
-    const n = arrObj.length;
-
-    validateUniqueProperties(groups);
+export const scaleArrayObj = ({ arrObj, repeat = {}, minmaxRange = [0, 1], groups = {}, prevConfig = null }) => {
+    
+    const arrObjClone = [...arrObj]
+    const n = arrObjClone.length;
+    const firstRow = arrObjClone[0]
 
     if (n === 0) {
         return {
             scaledOutput: [],
-            scaledConfig: {},
-            keyNames: []
+            scaledConfig: {}
         };
     }
 
-    const [rangeMin, rangeMax] = minmaxRange;
+    let config = {}
 
-    if (rangeMin >= rangeMax) {
-        throw new Error('Invalid minmaxRange: rangeMin must be less than rangeMax');
+    const isValidPrevConfig = prevConfig && validateConfig(prevConfig)
+
+    if(isValidPrevConfig)
+    {
+        validateCurrPrevConfig(prevConfig, {minmaxRange, repeat, groups, firstRow})
+        config = {...prevConfig}
     }
+    else
+    {
+        const inputKeyNames = Object.keys(firstRow);
 
-    const keyNames = Object.keys(arrObj[0]);
+        const repeatedKeyNames = inputKeyNames.map(key => {
+            return repeat.hasOwnProperty(key) ? Math.max(repeat[key], 1) : 1;
+        });
+    
+        const countRepeatedKeyNames = repeatedKeyNames.reduce((sum, rep) => sum + rep, 0);
+
+        config = {
+            rangeMin: minmaxRange[0], 
+            rangeMax: minmaxRange[1],
+            inputTypes: {},
+            min: {},
+            max: {},
+            uniqueStrIdx: {},
+            groupMinMax: {},
+            repeat,
+            groups,
+            inputKeyNames,
+            outputKeyNames: new Array(countRepeatedKeyNames),
+            repeatedKeyNames,
+        } 
+            
+        let keyNamesIdx = 0;
 
-    const repeatedKeyNames = keyNames.map(key => {
-        return repeat.hasOwnProperty(key) ? Math.max(repeat[key], 1) : 1;
-    });
+        for (let i = 0; i < config.inputKeyNames.length; i++) {
+            for (let w = 0; w < config.repeatedKeyNames[i]; w++) {
+                config.outputKeyNames[keyNamesIdx++] = config.inputKeyNames[i];
+            }
+        }
 
-    const totalColumns = repeatedKeyNames.reduce((sum, rep) => sum + rep, 0);
+        validateConfig(config)
 
-    const outputKeyNames = new Array(totalColumns);
-    let idx = 0;
-    for (let i = 0; i < keyNames.length; i++) {
-        for (let w = 0; w < repeatedKeyNames[i]; w++) {
-            outputKeyNames[idx++] = keyNames[i];
-        }
     }
 
-    const inputTypes = {};
-    const min = {};
-    const max = {};
-    const uniqueStringIndexes = {};
-    const groupMinMax = {};
+    validateUniqueProperties(config.groups);
+
+    for (const key of config.inputKeyNames) {
 
-    for (const key of keyNames) {
-        const firstValue = arrObj[0][key];
-        inputTypes[key] = typeof firstValue;
+        const firstType = typeof firstRow[key]
+
+        if(isValidPrevConfig)
+        {
+            if(!config.inputTypes.hasOwnProperty(key))
+            {
+                // If prevConfig is set, no new inputTypes can be introduced
+                throw new Error(`Error: A new unknown inputType property "${key}" found.`)
+            }
+            if(config.inputTypes[key] !== firstType)
+            {
+                 //is prevConfig is set the types of "typeof firstRow[key]" and config.inputTypes[key] must be the same
+                throw new Error(`Error: Current inputType of property "${key}" is not the same as in the prevConfig inputType.`)
+            }
 
-        if (inputTypes[key] === 'string') {
-            uniqueStringIndexes[key] = {};
+            continue;
         }
 
+        config.inputTypes[key] = firstType;
+
+        if (firstType === 'string') {
+            config.uniqueStrIdx[key] = {};
+        }
 
+        const thisGroup = findGroup(key, config.groups);
 
-        const thisGroup = findGroup(key, groups);
         if (thisGroup) {
-            if (!groupMinMax[thisGroup]) {
-                groupMinMax[thisGroup] = { min: Infinity, max: -Infinity };
-            }
+            config.groupMinMax[thisGroup] = { min: Infinity, max: -Infinity };
         } else
         {
-            min[key] = Infinity;
-            max[key] = -Infinity;
+            config.min[key] = Infinity;
+            config.max[key] = -Infinity;
         }
     }
 
-    for (const obj of arrObj) {
-        for (const key of keyNames) {
+    for (const obj of arrObjClone) {
+        for (const key of config.inputKeyNames) {
             let value = obj[key];
 
-            if (inputTypes[key] === 'string') {
-                const uniqueIndexes = uniqueStringIndexes[key];
+            if (config.inputTypes[key] === 'string') {
+                const uniqueIndexes = config.uniqueStrIdx[key];
                 if (!uniqueIndexes.hasOwnProperty(value)) {
                     uniqueIndexes[value] = Object.keys(uniqueIndexes).length;
                 }
                 value = uniqueIndexes[value];
                 obj[key] = value;
-            } else if (inputTypes[key] === 'boolean') {
+            } else if (config.inputTypes[key] === 'boolean') {
                 obj[key] = Number(value);
             }
 
-            const thisGroup = findGroup(key, groups);
+            const thisGroup = findGroup(key, config.groups);
 
             if (thisGroup) {
-                groupMinMax[thisGroup].min = Math.min(groupMinMax[thisGroup].min, value);
-                groupMinMax[thisGroup].max = Math.max(groupMinMax[thisGroup].max, value);
+                config.groupMinMax[thisGroup].min = Math.min(config.groupMinMax[thisGroup].min, value);
+                config.groupMinMax[thisGroup].max = Math.max(config.groupMinMax[thisGroup].max, value);
             } else {
-                min[key] = Math.min(min[key], value);
-                max[key] = Math.max(max[key], value);
+                config.min[key] = Math.min(config.min[key], value);
+                config.max[key] = Math.max(config.max[key], value);
             }
         }
     }
 
     const scaledOutput = new Array(n);
     for (let i = 0; i < n; i++) {
-        const obj = arrObj[i];
-        const scaledRow = new Array(totalColumns);
+        const obj = arrObjClone[i];
+        const scaledRow = new Array(config.outputKeyNames.length);
         let idx = 0;
 
-        for (let j = 0; j < keyNames.length; j++) {
-            const key = keyNames[j];
+        for (let j = 0; j < config.inputKeyNames.length; j++) {
+            const key = config.inputKeyNames[j];
             const value = obj[key];
 
-            const thisGroup = findGroup(key, groups);
+            const thisGroup = findGroup(key, config.groups);
             let minValue, maxValue;
 
             if (thisGroup) {
-                minValue = groupMinMax[thisGroup].min;
-                maxValue = groupMinMax[thisGroup].max;
+                minValue = config.groupMinMax[thisGroup].min;
+                maxValue = config.groupMinMax[thisGroup].max;
             } else {
-                minValue = min[key];
-                maxValue = max[key];
+                minValue = config.min[key];
+                maxValue = config.max[key];
             }
 
             const scaledValue =
                 maxValue !== minValue
-                    ? rangeMin + ((value - minValue) / (maxValue - minValue)) * (rangeMax - rangeMin)
-                    : rangeMin;
+                    ? config.rangeMin + ((value - minValue) / (maxValue - minValue)) * (config.rangeMax - config.rangeMin)
+                    : config.rangeMin;
 
-            const rep = repeatedKeyNames[j];
+            const rep = config.repeatedKeyNames[j];
 
             for (let w = 0; w < rep; w++) {
                 scaledRow[idx++] = scaledValue;
@@ -124,15 +159,15 @@ export const scaleArrayObj = ({ arrObj, repeat = {}, minmaxRange = [0, 1], group
         scaledOutput[i] = scaledRow;
     }
 
-    const scaledConfig = { min, max, inputTypes, uniqueStringIndexes, rangeMin, rangeMax, groupMinMax };
+    
 
     return {
         scaledOutput,
-        scaledConfig,
-        scaledKeyNames: outputKeyNames
+        scaledConfig: config
     };
 };
 
+
 const validateUniqueProperties = obj => {
     const uniqueValues = new Set();
     const allValues = [];
@@ -160,3 +195,116 @@ const findGroup = (key, groups) => {
     }
     return null;
 };
+
+
+const validateConfig = config => {
+
+    if(!config) return false 
+
+    const requiredKeys = [
+        "rangeMin",
+        "rangeMax",
+        "inputTypes",
+        "min",
+        "max",
+        "uniqueStrIdx",
+        "groupMinMax",
+        "repeat",
+        "groups",
+        "inputKeyNames",
+        "outputKeyNames",
+        "repeatedKeyNames"
+    ];
+
+    // Check for missing keys
+    for (const key of requiredKeys) {
+        if (!config.hasOwnProperty(key)) {
+            throw new Error(`Missing key "${key}" in config.`);
+        }
+    }
+
+    const { 
+        rangeMin, 
+        rangeMax, 
+        inputTypes, 
+        min, 
+        max, 
+        uniqueStrIdx, 
+        groupMinMax, 
+        repeat, 
+        groups,
+        inputKeyNames,
+        outputKeyNames,
+        repeatedKeyNames
+    } = config;
+
+    // Validate rangeMin and rangeMax are numbers and in proper order
+    if (typeof rangeMin !== 'number' || typeof rangeMax !== 'number') {
+        throw new Error("rangeMin and rangeMax must be numbers.");
+    }
+    if (rangeMin >= rangeMax) {
+        throw new Error("rangeMin must be less than rangeMax.");
+    }
+
+    // Helper to check if a value is a plain object (and not null or an array)
+    const isPlainObject = (obj) => typeof obj === 'object' && obj !== null && !Array.isArray(obj);
+
+    if (!isPlainObject(inputTypes)) {
+        throw new Error("inputTypes must be an object.");
+    }
+    if (!isPlainObject(min)) {
+        throw new Error("min must be an object.");
+    }
+    if (!isPlainObject(max)) {
+        throw new Error("max must be an object.");
+    }
+    if (!isPlainObject(uniqueStrIdx)) {
+        throw new Error("uniqueStrIdx must be an object.");
+    }
+    if (!isPlainObject(groupMinMax)) {
+        throw new Error("groupMinMax must be an object.");
+    }
+    if (!isPlainObject(repeat)) {
+        throw new Error("repeat must be an object.");
+    }
+    if (!isPlainObject(groups)) {
+        throw new Error("groups must be an object.");
+    }
+    if(!Array.isArray(inputKeyNames))
+    {
+        throw new Error("inputKeyNames must be an array.");
+    }
+    if(!Array.isArray(outputKeyNames))
+    {
+        throw new Error("outputKeyNames must be an array.");
+    }
+    if(!Array.isArray(repeatedKeyNames))
+    {
+        throw new Error("repeatedKeyNames must be an array.");
+    }
+
+    return true;
+}
+
+const validateCurrPrevConfig = (prevConfig, {minmaxRange, repeat, groups, firstRow}) => {
+
+    if(prevConfig.rangeMin !== minmaxRange[0] || prevConfig.rangeMax !== minmaxRange[1])
+    {
+        throw new Error(`"prevConfig.minmaxRange" is not equal "minmaxRange".`);
+    }
+
+    //it is important o keep the same key order
+    if (JSON.stringify(prevConfig.inputKeyNames) !== JSON.stringify(Object.keys(firstRow))) {
+        throw new Error(`"prevConfig.inputKeyNames" structure does not match "Object.keys(firstRow)" structure. The order of keys is important.`);
+    }
+
+    if (JSON.stringify(prevConfig.repeat) !== JSON.stringify(repeat)) {
+        throw new Error(`"prevConfig.repeat" structure does not match "repeat" structure. The order of keys is important.`);
+    }
+
+    if (JSON.stringify(prevConfig.groups) !== JSON.stringify(groups)) {
+        throw new Error(`"prevConfig.groups" structure does not match "groups" structure. The order of keys is important.`);
+    }
+
+    return true
+}

package/test/test.js

@@ -15,9 +15,10 @@ const test = async () => {
         //returning null or undefined will exclude current row X and Y from training
         if(typeof prev === 'undefined') return null
 
-        const { open, high, low, close, volume } = curr
+        const { open, high, low, close, volume, date } = curr
 
         return {
+            date,
             open,
             high,
             low,
@@ -82,10 +83,10 @@ const test = async () => {
     const inputX = tf.tensor3d(timeSteppedTrainX, [timeSteppedTrainX.length, timeSteps, colsX])
     const targetY = tf.tensor2d(trimedTrainY,  [trimedTrainY.length, colsY])
 
-    console.log('trainX', trainX[trainX.length - 1])
-    console.log('configX', keyNamesX)
-    console.log('inputX', inputX)
-    console.log('inputX', targetY)
+    //console.log('trainX', trainX[trainX.length - 1])
+    console.log('configX', configX)
+    //console.log('inputX', inputX)
+    //console.log('inputX', targetY)
 }
 
 test()