xy-scale 1.4.2 → 1.4.3

package/package.json

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

package/src/scale.js

@@ -1,18 +1,29 @@
-export const scaleArrayObj = ({ arrObj, repeat = {}, minmaxRange, groups = {}, customMinMaxRanges = null, excludes = new Set() }) => {
+export const scaleArrayObj = ({ arrObj, repeat = {}, minmaxRange, groups = {}, customMinMaxRanges = {}, excludes = new Set() }) => {
     
-    const arrObjClone = [...arrObj]
+    /*
+        1. excluded items can be repeated
+        2. excluded items can not be grouped
+        3. excluded items can not be in customMixMaxRanges
+        4. customMixMaxRanges items can not be grouped
+        6. customMixMaxRanges items can not be excluded
+        5. customMixMaxRanges can be repeated
+        7. hierarchy order: 1 excluded items,  2 customMixMaxRanges items , 3 grouped items, 4 any other item
+        6. customMixMaxRanges min and max must not be updated from values
+    */
+
+    const arrObjClone = arrObj.map(row => ({ ...row })) //[...arrObj] modified june 2
     const arrObjLen = arrObjClone.length;
     const firstRow = arrObjClone[0]
-    const validCustomMinMaxRanges = typeof customMinMaxRanges === 'object' && customMinMaxRanges !== null
+    const inputKeyNames = Object.keys(firstRow);
+
+    const groupSets = {}
 
-    if (arrObjLen === 0) {
-        return {
-            scaledOutput: [],
-            scaledConfig: {}
-        };
+    for(const [k, g] of Object.entries(groups))
+    {
+        groupSets[k] = new Set(g)
     }
-    
-    const inputKeyNames = Object.keys(firstRow);
+
+    validateUniqueProperties({excludes, groupSets, customMinMaxRanges, inputKeyNames, repeat})
 
     const repeatedKeyNames = inputKeyNames.map(key => {
         return repeat.hasOwnProperty(key) ? Math.max(repeat[key], 1) : 1;
@@ -29,7 +40,7 @@ export const scaleArrayObj = ({ arrObj, repeat = {}, minmaxRange, groups = {}, c
         max: {},
         groupMinMax: {},
         repeat,
-        groups,
+        groupSets,
         inputKeyNames,
         outputKeyNames: new Array(countRepeatedKeyNames),
         repeatedKeyNames
@@ -43,8 +54,6 @@ export const scaleArrayObj = ({ arrObj, repeat = {}, minmaxRange, groups = {}, c
         }
     }
 
-    validateUniqueProperties(config.groups);
-
     const validInputTypes = ['number', 'boolean']
 
     for (const key of config.inputKeyNames) {
@@ -56,36 +65,28 @@ export const scaleArrayObj = ({ arrObj, repeat = {}, minmaxRange, groups = {}, c
         }
 
         const firstType = typeof firstRow[key]
-        const thisGroup = findGroup(key, config.groups);
+        const thisGroup = findGroup(key, config.groupSets);
 
 
         if(!validInputTypes.includes(firstType))
         {
-            throw new Error(`Invalid input type "${firstType}" provided for key "${key}". Only accepting `)
+            throw new Error(`Invalid input type "${firstType}" provided for key "${key}". Only accepting ${JSON.stringify(validInputTypes)}`)
         }
 
         config.inputTypes[key] = firstType;
         
-        if(validCustomMinMaxRanges && customMinMaxRanges.hasOwnProperty(key))
+        //customMinMaxRanges can not be grouped
+        if(customMinMaxRanges.hasOwnProperty(key))
         {
-            if (thisGroup)
-            {
-                config.groupMinMax[thisGroup] = customMinMaxRanges[key]
-            }
-            else
-            {
-                config.min[key] = customMinMaxRanges[key].min;
-                config.max[key] = customMinMaxRanges[key].max;                   
-            }
+            config.min[key] = customMinMaxRanges[key].min;
+            config.max[key] = customMinMaxRanges[key].max;
+        }
+        else if(thisGroup && !config.groupMinMax.hasOwnProperty(thisGroup)){
+            config.groupMinMax[thisGroup] = { min: Infinity, max: -Infinity };
         }
         else {
-            if (thisGroup) {
-                config.groupMinMax[thisGroup] = { min: Infinity, max: -Infinity };
-            } 
-            else {
-                config.min[key] = Infinity;
-                config.max[key] = -Infinity;
-            }
+            config.min[key] = Infinity;
+            config.max[key] = -Infinity;
         }
     }
 
@@ -101,11 +102,12 @@ export const scaleArrayObj = ({ arrObj, repeat = {}, minmaxRange, groups = {}, c
 
             if (config.inputTypes[key] === 'boolean') {
                 obj[key] = Number(value);
+                value = obj[key]
             }
 
-            const thisGroup = findGroup(key, config.groups);
+            const thisGroup = findGroup(key, config.groupSets)
 
-            if(validCustomMinMaxRanges === false || (validCustomMinMaxRanges && !customMinMaxRanges.hasOwnProperty(key)))
+            if(!customMinMaxRanges.hasOwnProperty(key))
             {
                 if (thisGroup) {
                     config.groupMinMax[thisGroup].min = Math.min(config.groupMinMax[thisGroup].min, value);
@@ -130,28 +132,31 @@ export const scaleArrayObj = ({ arrObj, repeat = {}, minmaxRange, groups = {}, c
         for (let j = 0; j < config.inputKeyNames.length; j++) {
             const key = config.inputKeyNames[j]
             const value = obj[key]
+            let scaledValue
 
             if (config.inputTypes[key] === 'excluded')
             {
-                scaledRow[idx++] = value
-                continue
+                scaledValue = value
             }
+            else
+            {
+                const thisGroup = findGroup(key, config.groupSets);
+                let minValue, maxValue
 
-            const thisGroup = findGroup(key, config.groups);
-            let minValue, maxValue
+                if (thisGroup) {
+                    minValue = config.groupMinMax[thisGroup].min
+                    maxValue = config.groupMinMax[thisGroup].max
+                } else {
+                    minValue = config.min[key]
+                    maxValue = config.max[key]
+                }
 
-            if (thisGroup) {
-                minValue = config.groupMinMax[thisGroup].min
-                maxValue = config.groupMinMax[thisGroup].max
-            } else {
-                minValue = config.min[key]
-                maxValue = config.max[key]
+                scaledValue =
+                    maxValue !== minValue
+                        ? config.rangeMin + ((value - minValue) / (maxValue - minValue)) * (config.rangeMax - config.rangeMin)
+                        : config.rangeMin;
             }
 
-            const scaledValue =
-                maxValue !== minValue
-                    ? config.rangeMin + ((value - minValue) / (maxValue - minValue)) * (config.rangeMax - config.rangeMin)
-                    : config.rangeMin;
 
             const rep = config.repeatedKeyNames[j]
 
@@ -172,115 +177,88 @@ export const scaleArrayObj = ({ arrObj, repeat = {}, minmaxRange, groups = {}, c
 }
 
 
-const validateUniqueProperties = obj => {
-    const uniqueValues = new Set();
-    const allValues = [];
-
-    for (const [key, arr] of Object.entries(obj)) {
-        uniqueValues.add(key);
-        allValues.push(key);
-
-        arr.forEach(v => {
-            uniqueValues.add(v);
-            allValues.push(v);
-        });
+const validateUniqueProperties = ({
+  excludes,
+  groupSets,
+  customMinMaxRanges,
+  repeat,
+  inputKeyNames
+}) => {
+  // 0. Ensure every 'repeat' key actually exists in inputKeyNames
+  for (const key of Object.keys(repeat)) {
+    if (!inputKeyNames.includes(key)) {
+      throw new Error(`"repeat" references missing key "${key}".`);
     }
+  }
 
-    if (uniqueValues.size !== allValues.length) {
-        throw new Error('Duplicate value found between properties in validateUniqueProperties function.');
+  // 1. Ensure every excluded key actually exists in inputKeyNames
+  for (const key of excludes) {
+    if (!inputKeyNames.includes(key)) {
+      throw new Error(`Excluded property "${key}" does not exist in inputKeyNames.`);
     }
-};
+  }
 
-const findGroup = (key, groups) => {
-    for (const [groupK, groupV] of Object.entries(groups)) {
-        if (groupV.includes(key)) {
-            return groupK;
-        }
+  // 2. Ensure every customMinMaxRanges key exists in inputKeyNames
+  for (const key of Object.keys(customMinMaxRanges)) {
+    if (!inputKeyNames.includes(key)) {
+      throw new Error(`customMinMaxRanges property "${key}" does not exist in inputKeyNames.`);
     }
-    return null;
-};
-
-
-const validateConfig = config => {
-
-    if(!config) return false 
-
-    const requiredKeys = [
-        "rangeMin",
-        "rangeMax",
-        "inputTypes",
-        "min",
-        "max",
-        "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.`);
-        }
+  }
+
+  // 3. Ensure every group member exists in inputKeyNames, and detect if a key appears in more than one group
+  const seenInGroup = new Set();
+  for (const [groupName, members] of Object.entries(groupSets)) {
+    for (const key of members) {
+      if (!inputKeyNames.includes(key)) {
+        throw new Error(`Group "${groupName}" references missing key "${key}".`);
+      }
+      if (seenInGroup.has(key)) {
+        throw new Error(`Property "${key}" appears in more than one group.`);
+      }
+      seenInGroup.add(key);
     }
+  }
 
-    const { 
-        rangeMin, 
-        rangeMax, 
-        inputTypes, 
-        min, 
-        max, 
-        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.");
+  // 4a. A key cannot be both in excludes and in customMinMaxRanges
+  for (const key of excludes) {
+    if (customMinMaxRanges.hasOwnProperty(key)) {
+      throw new Error(`Property "${key}" is in both "excludes" and "customMinMaxRanges".`);
     }
-    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.");
+  // 4b. A key in excludes cannot be grouped
+  for (const key of excludes) {
+    if (findGroup(key, groupSets)) {
+      throw new Error(`Property "${key}" is in "excludes" and also appears in a group.`);
     }
-    if (!isPlainObject(max)) {
-        throw new Error("max must be an object.");
+  }
+
+  // 4c. A key in customMinMaxRanges cannot be grouped
+  for (const key of Object.keys(customMinMaxRanges)) {
+    if (findGroup(key, groupSets)) {
+      throw new Error(
+        `Property "${key}" is in "customMinMaxRanges" and also appears in a group.`
+      );
     }
-    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.");
+  }
+
+  // 5. Ensure customMinMaxRanges[key].min <= customMinMaxRanges[key].max
+  for (const [key, { min, max }] of Object.entries(customMinMaxRanges)) {
+    if (min > max) {
+      throw new Error(
+        `customMinMaxRanges["${key}"].min (${min}) > max (${max}).`
+      );
     }
+  }
+};
 
-    return true;
-}
+
+
+const findGroup = (key, groupSets) => {
+    for (const [groupK, groupV] of Object.entries(groupSets)) {
+        if (groupV.has(key)) {
+            return groupK;
+        }
+    }
+    return null;
+};

package/test/test.js

@@ -14,14 +14,14 @@ const test = async () => {
     const indicators = new OHLCV_INDICATORS({input: ohlcv, ticker: 'BTC', precision: false})
 
     indicators
-        .rsi(40)
+        .rsi(14)
         .bollingerBands(20, 2)
         .ema(50)
         .sma(200)
         .sma(300)
         .scaler(200, ['open', 'high', 'low', 'close'], {group: true})
         .crossPairs([
-            {fast: 'rsi_40', slow: 30},
+            {fast: 'rsi_14', slow: 30},
             {fast: 'price', slow: 'sma_200'},
             {fast: 'price', slow: 'sma_300'},
             {fast: 'price', slow: 'bollinger_bands_upper'}
@@ -33,8 +33,6 @@ const test = async () => {
 
     const {scaledGroups} = indicators
 
-    //console.log(scaledGroups)
-
     const {
         trainX,
         trainY,
@@ -59,15 +57,17 @@ const test = async () => {
         minmaxRange: [0, 1],
         balancing: null,
         groups: scaledGroups,
-        excludes: ['high2'],
-        correlation: {corrExcludes: ['price_x_sma_300', 'price_x_sma_200']}
+        excludes: ['high'],
+        repeat: {
+            high2: 100
+        }
     });
 
     console.log(configX.outputKeyNames)
     console.log(configX.inputTypes)
     //console.log(configX)
 
-    //console.log('trainX', trainX[0])
+    console.log('trainX', [trainX[0], trainX.at(-1)])
 
 
 
@@ -153,7 +153,9 @@ const xCallbackFunc = ({ objRow, index }) => {
         ema50GtSma300: curr.ema_50 > curr.sma_300,
         sma200IsUp: curr.sma_200 > prev.sma_200,
         sma200GtSma300: curr.sma_200 > prev.sma_300,
-        sma_300IsUp: curr.sma_300 > prev.sma_300
+        sma_300IsUp: curr.sma_300 > prev.sma_300,
+        rsi_14: curr.rsi_14,
+        rsi_sma_14: curr.rsi_sma_14,
     }
 
     for(const [key, value]  of Object.entries(curr))