qesuite 1.0.51 → 1.0.52

package/dist/index.d.mts

@@ -294,6 +294,20 @@ declare const Gamma: {
     * @param x The value to be evaluated.
     **/
     Trigamma(x: number): number;
+    /**
+    * Evaluates the lower incomplete gamma function for the specified value.
+    * @customfunction
+    * @param n
+    * @param x
+    **/
+    LowerIncomplete(n: number, x: number): number;
+    /**
+    * Evaluates the upper incomplete gamma function for the specified value.
+    * @customfunction
+    * @param n
+    * @param x
+    **/
+    UpperIncomplete(n: number, x: number): number;
 };
 /** ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 */
@@ -340,6 +354,7 @@ declare const Distributions: {
         inv(p: number, a: number, b: number): any;
     };
     ChiSq: {
+        pdf(x: number, df: number): number;
         cdf(x: number, df: number): number;
         RightTail(x: number, df: number): number;
     };
@@ -1021,6 +1036,8 @@ declare const ANOVA: {
     };
     Multifactor: {
         MainEffectsPlot(factors: any, response: any): HTMLCanvasElement;
+        Table(factors: any, response: any): {};
+        GLM(factors: any, response: any): {};
     };
 };
 declare function SumSquaredDeviation(data: number[], referenceValue?: any): number;

package/dist/index.d.ts

@@ -294,6 +294,20 @@ declare const Gamma: {
     * @param x The value to be evaluated.
     **/
     Trigamma(x: number): number;
+    /**
+    * Evaluates the lower incomplete gamma function for the specified value.
+    * @customfunction
+    * @param n
+    * @param x
+    **/
+    LowerIncomplete(n: number, x: number): number;
+    /**
+    * Evaluates the upper incomplete gamma function for the specified value.
+    * @customfunction
+    * @param n
+    * @param x
+    **/
+    UpperIncomplete(n: number, x: number): number;
 };
 /** ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 */
@@ -340,6 +354,7 @@ declare const Distributions: {
         inv(p: number, a: number, b: number): any;
     };
     ChiSq: {
+        pdf(x: number, df: number): number;
         cdf(x: number, df: number): number;
         RightTail(x: number, df: number): number;
     };
@@ -1021,6 +1036,8 @@ declare const ANOVA: {
     };
     Multifactor: {
         MainEffectsPlot(factors: any, response: any): HTMLCanvasElement;
+        Table(factors: any, response: any): {};
+        GLM(factors: any, response: any): {};
     };
 };
 declare function SumSquaredDeviation(data: number[], referenceValue?: any): number;

package/dist/index.js

@@ -937,6 +937,28 @@ var Gamma = {
   **/
   Trigamma(x) {
     return 1 / x + 1 / (2 * (x ^ 2)) + 1 / (6 * (x ^ 3)) - 1 / (30 * (x ^ 5)) + 1 / (42 * (x ^ 7)) - 1 / (30 * (x ^ 9)) + 5 / (66 * (x ^ 11)) - 691 / (2730 * (x ^ 13)) + 15 / (6 * (x ^ 15));
+  },
+  /**
+  * Evaluates the lower incomplete gamma function for the specified value.
+  * @customfunction
+  * @param n 
+  * @param x
+  **/
+  LowerIncomplete(n, x) {
+    return Gamma.fn(n) - Gamma.UpperIncomplete(n, x);
+  },
+  /**
+  * Evaluates the upper incomplete gamma function for the specified value.
+  * @customfunction
+  * @param n 
+  * @param x
+  **/
+  UpperIncomplete(n, x) {
+    let expSum = 0;
+    for (let k = 0; k < n; k++) {
+      expSum += Math.pow(x, k) / Probability.Factorialize(k);
+    }
+    return Probability.Factorialize(n - 1) * Math.exp(-x) * expSum;
   }
 };
 function NewtonRaphson(parameter, parameterizedFunction, derivativeFunction) {
@@ -1058,11 +1080,39 @@ var Distributions = {
     }
   },
   ChiSq: {
+    pdf(x, df) {
+      let num = Math.pow(x, df / 2 - 1) * Math.exp(-x / 2);
+      let den = Math.pow(2, df / 2) * Gamma.fn(df / 2);
+      return num / den;
+    },
     cdf(x, df) {
       if (df === 2) {
         return 1 - Math.exp(-x / 2);
       }
-      return NaN;
+      if (df % 2) {
+        let test = 0;
+        let stepCount = 1e7;
+        let stepSize = x / stepCount;
+        for (let i = 0; i < stepCount + 1; i++) {
+          test += stepSize * Distributions.ChiSq.pdf(i * stepSize, df);
+        }
+        return test;
+        if (x < df) {
+          let y = Math.sqrt(df / 2) * Math.log(df / x);
+          const aFunc = (c1, c2, c3, c4) => {
+            return c1 + c2 * Math.pow(2 / df, 0.5) + c3 * (2 / df) + c4 * Math.pow(2 / df, 1 / 5);
+          };
+          let A = aFunc(0.5, 0.1323, 36e-4, -38e-4);
+          let a1 = aFunc(0.1968, -0.0452, -0.0128, -0.0168);
+          let a2 = aFunc(0.1152, -0.099, 0.0539, -0.0168);
+          let a3 = aFunc(4e-4, 0.0442, -0.0866, 0.0398);
+          let a4 = aFunc(0.0195, -0.0629, 0.0708, 0.0269);
+          return A / Math.pow(1 + a1 * y + a2 * Math.pow(y, 2) + a3 * Math.pow(y, 3) + a4 * Math.pow(y, 4), 4);
+        }
+      }
+      let num = Gamma.LowerIncomplete(df / 2, x / 2);
+      let den = Gamma.fn(df / 2);
+      return num / den;
     },
     RightTail(x, df) {
       return 1 - Distributions.ChiSq.cdf(x, df);
@@ -2594,6 +2644,57 @@ function Sum(data) {
   });
   return sum;
 }
+function SumSquareByGroups(groups, response) {
+  let groupKeys = Object.keys(groups);
+  let groupSets = [];
+  let treatmentCount = 0;
+  groupKeys.forEach((group) => {
+    let set = new Set(groups[group]);
+    groupSets.push(set);
+    treatmentCount += set.size;
+  });
+  let placeFactors = [];
+  groupSets.forEach((s, sI) => {
+    if (sI === groupSets.length - 1) {
+      placeFactors.push(1);
+    } else {
+      placeFactors.push(groupSets[sI + 1].size);
+    }
+  });
+  let returnObject = {};
+  let groupNObject = {};
+  response[Object.keys(response)[0]].forEach((value, index) => {
+    let indexer = [];
+    groupKeys.forEach((k, kI) => {
+      let currentKey = groups[k][index];
+      groupSets[kI].forEach((s, sI) => {
+        if (s === currentKey) {
+          indexer.push(sI);
+        }
+      });
+    });
+    returnObject[JSON.stringify(indexer)] = 0;
+    groupNObject[JSON.stringify(indexer)] = 0;
+  });
+  response[Object.keys(response)[0]].forEach((value, index) => {
+    let indexer = [];
+    groupKeys.forEach((k, kI) => {
+      let currentKey = groups[k][index];
+      groupSets[kI].forEach((s, sI) => {
+        if (s === currentKey) {
+          indexer.push(sI);
+        }
+      });
+    });
+    returnObject[JSON.stringify(indexer)] += value;
+    groupNObject[JSON.stringify(indexer)] += 1;
+  });
+  let sumsq = 0;
+  Object.keys(returnObject).forEach((k) => {
+    sumsq += Math.pow(returnObject[k], 2) / groupNObject[k];
+  });
+  return sumsq;
+}
 function Rang(data) {
   let dataNumbers = data.map((d) => {
     return Number(d);
@@ -3714,7 +3815,125 @@ var ANOVA = {
       chartSet.width += 1e3;
       chartSet.axis.y.tickOnly = true;
       let graph = CreateSplitGraph(individualCharts, `Main Effects Plot of ${Object.keys(response)[0]}`, chartSet);
+      console.log(graph);
       return graph;
+    },
+    Table(factors, response) {
+      let anovaTable = {};
+      let factorKeys = Object.keys(factors);
+      let responseKey = Object.keys(response)[0];
+      let Ntotal = response[responseKey].length;
+      let DFE = 1;
+      let correctionFactor = Math.pow(Sum(response[responseKey]), 2) / Ntotal;
+      factorKeys.forEach((f) => {
+        let fSet = new Set(factors[f]);
+        let Nf = fSet.size;
+        let SS_f = 0;
+        fSet.forEach((level) => {
+          let levelTotal = 0;
+          let levelN = 0;
+          factors[f].forEach((v, j) => {
+            if (v === level) {
+              levelTotal += response[responseKey][j];
+              levelN += 1;
+            }
+          });
+          SS_f += Math.pow(levelTotal, 2) / levelN;
+        });
+        SS_f = SS_f - correctionFactor;
+        anovaTable[f] = {
+          DF: Nf - 1,
+          SS: SS_f,
+          MS: SS_f / (Nf - 1),
+          F: void 0,
+          p: void 0
+        };
+        DFE = DFE * Nf;
+      });
+      DFE = Ntotal - DFE;
+      for (let i = 0; i < factorKeys.length - 1; i++) {
+        let f_i_Set = new Set(factors[factorKeys[i]]);
+        for (let j = i + 1; j < factorKeys.length; j++) {
+          let f_j_Set = new Set(factors[factorKeys[j]]);
+          let SS_subtotal = 0;
+          f_i_Set.forEach((fi) => {
+            f_j_Set.forEach((fj) => {
+              let groupSum = 0;
+              let groupN = 0;
+              response[responseKey].forEach((val, index) => {
+                if (factors[factorKeys[i]][index] === fi && factors[factorKeys[j]][index] === fj) {
+                  groupSum += val;
+                  groupN += 1;
+                }
+              });
+              SS_subtotal += Math.pow(groupSum, 2) / groupN;
+            });
+          });
+          SS_subtotal = SS_subtotal - correctionFactor;
+          let iRow = anovaTable[factorKeys[i]];
+          let jRow = anovaTable[factorKeys[j]];
+          let fi_fj_DF = iRow.DF * jRow.DF;
+          let fi_fj_SS = SS_subtotal - iRow.SS - jRow.SS;
+          anovaTable[`${factorKeys[i]}*${factorKeys[j]}`] = { DF: fi_fj_DF, SS: fi_fj_SS, MS: fi_fj_SS / fi_fj_DF, F: void 0, p: void 0 };
+        }
+      }
+      let interactionSS_subtotal = SumSquareByGroups(factors, response) - correctionFactor;
+      let fullInteractionDF = 1;
+      let SSE = 0;
+      factorKeys.forEach((source) => {
+        fullInteractionDF = fullInteractionDF * anovaTable[source].DF;
+      });
+      Object.keys(anovaTable).forEach((source) => {
+        interactionSS_subtotal = interactionSS_subtotal - anovaTable[source].SS;
+        SSE += anovaTable[source].SS;
+      });
+      let fullInteractionName = factorKeys.join("*");
+      anovaTable[fullInteractionName] = { DF: fullInteractionDF, SS: interactionSS_subtotal, MS: interactionSS_subtotal / fullInteractionDF, F: void 0, p: void 0 };
+      SSE += interactionSS_subtotal;
+      let SStotal = SumSquaredDeviation(response[responseKey], 0) - correctionFactor;
+      SSE = SStotal - SSE;
+      let MSE = SSE / DFE;
+      Object.keys(anovaTable).forEach((source) => {
+        let sourceF = anovaTable[source].MS / MSE;
+        anovaTable[source].F = sourceF;
+        anovaTable[source].p = Distributions.F.RightTail(sourceF, anovaTable[source].DF, DFE);
+      });
+      anovaTable["Error"] = { DF: DFE, SS: SSE, MS: MSE };
+      anovaTable["Total"] = { DF: Ntotal - 1, SS: SStotal };
+      return anovaTable;
+    },
+    GLM(factors, response) {
+      let factorKeys = Object.keys(factors);
+      let anovaTable = {};
+      let responseKey = Object.keys(response)[0];
+      let Ntotal = response[responseKey].length;
+      let DFE = 1;
+      let responseData = response[responseKey];
+      factorKeys.forEach((k) => {
+        let SS = 0;
+        let levels = new Set(factors[k]);
+        let groupedData = GroupData(factors[k], responseData);
+        let descriptiveStats = {};
+        let mean_0;
+        Object.keys(groupedData).forEach((k2, k_i) => {
+          let mean = Mean(groupedData[k2]);
+          descriptiveStats[k2].mean = mean;
+          descriptiveStats[k2].std = StDev.S(groupedData[k2]);
+          descriptiveStats[k2].N = groupedData[k2].length;
+          if (k_i === 0) {
+            mean_0 = mean;
+            groupedData[k2].forEach((d) => {
+              SS += mean;
+            });
+          } else {
+            groupedData[k2].forEach((d) => {
+              SS += mean - Math.pow(mean - d, 2);
+            });
+          }
+        });
+        console.log(k, SS);
+      });
+      return anovaTable;
     }
   }
 };
@@ -3742,6 +3961,21 @@ var Probability = {
     }
   }
 };
+function GroupData(groupingArray, responseArray) {
+  if (groupingArray.length != responseArray.length) {
+    return { forEachGroup() {
+    } };
+  }
+  let returnObj = {};
+  let levels = new Set(groupingArray);
+  levels.forEach((l) => {
+    returnObj[l] = [];
+  });
+  for (let i = 0; i < groupingArray.length; i++) {
+    returnObj[groupingArray[i]].push(responseArray[i]);
+  }
+  return returnObj;
+}
 function CreateCanvas(width, height) {
   let canvas = document.createElement("canvas");
   canvas.height = height;

package/dist/index.mjs

@@ -845,6 +845,28 @@ var Gamma = {
   **/
   Trigamma(x) {
     return 1 / x + 1 / (2 * (x ^ 2)) + 1 / (6 * (x ^ 3)) - 1 / (30 * (x ^ 5)) + 1 / (42 * (x ^ 7)) - 1 / (30 * (x ^ 9)) + 5 / (66 * (x ^ 11)) - 691 / (2730 * (x ^ 13)) + 15 / (6 * (x ^ 15));
+  },
+  /**
+  * Evaluates the lower incomplete gamma function for the specified value.
+  * @customfunction
+  * @param n 
+  * @param x
+  **/
+  LowerIncomplete(n, x) {
+    return Gamma.fn(n) - Gamma.UpperIncomplete(n, x);
+  },
+  /**
+  * Evaluates the upper incomplete gamma function for the specified value.
+  * @customfunction
+  * @param n 
+  * @param x
+  **/
+  UpperIncomplete(n, x) {
+    let expSum = 0;
+    for (let k = 0; k < n; k++) {
+      expSum += Math.pow(x, k) / Probability.Factorialize(k);
+    }
+    return Probability.Factorialize(n - 1) * Math.exp(-x) * expSum;
   }
 };
 function NewtonRaphson(parameter, parameterizedFunction, derivativeFunction) {
@@ -966,11 +988,39 @@ var Distributions = {
     }
   },
   ChiSq: {
+    pdf(x, df) {
+      let num = Math.pow(x, df / 2 - 1) * Math.exp(-x / 2);
+      let den = Math.pow(2, df / 2) * Gamma.fn(df / 2);
+      return num / den;
+    },
     cdf(x, df) {
       if (df === 2) {
         return 1 - Math.exp(-x / 2);
       }
-      return NaN;
+      if (df % 2) {
+        let test = 0;
+        let stepCount = 1e7;
+        let stepSize = x / stepCount;
+        for (let i = 0; i < stepCount + 1; i++) {
+          test += stepSize * Distributions.ChiSq.pdf(i * stepSize, df);
+        }
+        return test;
+        if (x < df) {
+          let y = Math.sqrt(df / 2) * Math.log(df / x);
+          const aFunc = (c1, c2, c3, c4) => {
+            return c1 + c2 * Math.pow(2 / df, 0.5) + c3 * (2 / df) + c4 * Math.pow(2 / df, 1 / 5);
+          };
+          let A = aFunc(0.5, 0.1323, 36e-4, -38e-4);
+          let a1 = aFunc(0.1968, -0.0452, -0.0128, -0.0168);
+          let a2 = aFunc(0.1152, -0.099, 0.0539, -0.0168);
+          let a3 = aFunc(4e-4, 0.0442, -0.0866, 0.0398);
+          let a4 = aFunc(0.0195, -0.0629, 0.0708, 0.0269);
+          return A / Math.pow(1 + a1 * y + a2 * Math.pow(y, 2) + a3 * Math.pow(y, 3) + a4 * Math.pow(y, 4), 4);
+        }
+      }
+      let num = Gamma.LowerIncomplete(df / 2, x / 2);
+      let den = Gamma.fn(df / 2);
+      return num / den;
     },
     RightTail(x, df) {
       return 1 - Distributions.ChiSq.cdf(x, df);
@@ -2502,6 +2552,57 @@ function Sum(data) {
   });
   return sum;
 }
+function SumSquareByGroups(groups, response) {
+  let groupKeys = Object.keys(groups);
+  let groupSets = [];
+  let treatmentCount = 0;
+  groupKeys.forEach((group) => {
+    let set = new Set(groups[group]);
+    groupSets.push(set);
+    treatmentCount += set.size;
+  });
+  let placeFactors = [];
+  groupSets.forEach((s, sI) => {
+    if (sI === groupSets.length - 1) {
+      placeFactors.push(1);
+    } else {
+      placeFactors.push(groupSets[sI + 1].size);
+    }
+  });
+  let returnObject = {};
+  let groupNObject = {};
+  response[Object.keys(response)[0]].forEach((value, index) => {
+    let indexer = [];
+    groupKeys.forEach((k, kI) => {
+      let currentKey = groups[k][index];
+      groupSets[kI].forEach((s, sI) => {
+        if (s === currentKey) {
+          indexer.push(sI);
+        }
+      });
+    });
+    returnObject[JSON.stringify(indexer)] = 0;
+    groupNObject[JSON.stringify(indexer)] = 0;
+  });
+  response[Object.keys(response)[0]].forEach((value, index) => {
+    let indexer = [];
+    groupKeys.forEach((k, kI) => {
+      let currentKey = groups[k][index];
+      groupSets[kI].forEach((s, sI) => {
+        if (s === currentKey) {
+          indexer.push(sI);
+        }
+      });
+    });
+    returnObject[JSON.stringify(indexer)] += value;
+    groupNObject[JSON.stringify(indexer)] += 1;
+  });
+  let sumsq = 0;
+  Object.keys(returnObject).forEach((k) => {
+    sumsq += Math.pow(returnObject[k], 2) / groupNObject[k];
+  });
+  return sumsq;
+}
 function Rang(data) {
   let dataNumbers = data.map((d) => {
     return Number(d);
@@ -3622,7 +3723,125 @@ var ANOVA = {
       chartSet.width += 1e3;
       chartSet.axis.y.tickOnly = true;
       let graph = CreateSplitGraph(individualCharts, `Main Effects Plot of ${Object.keys(response)[0]}`, chartSet);
+      console.log(graph);
       return graph;
+    },
+    Table(factors, response) {
+      let anovaTable = {};
+      let factorKeys = Object.keys(factors);
+      let responseKey = Object.keys(response)[0];
+      let Ntotal = response[responseKey].length;
+      let DFE = 1;
+      let correctionFactor = Math.pow(Sum(response[responseKey]), 2) / Ntotal;
+      factorKeys.forEach((f) => {
+        let fSet = new Set(factors[f]);
+        let Nf = fSet.size;
+        let SS_f = 0;
+        fSet.forEach((level) => {
+          let levelTotal = 0;
+          let levelN = 0;
+          factors[f].forEach((v, j) => {
+            if (v === level) {
+              levelTotal += response[responseKey][j];
+              levelN += 1;
+            }
+          });
+          SS_f += Math.pow(levelTotal, 2) / levelN;
+        });
+        SS_f = SS_f - correctionFactor;
+        anovaTable[f] = {
+          DF: Nf - 1,
+          SS: SS_f,
+          MS: SS_f / (Nf - 1),
+          F: void 0,
+          p: void 0
+        };
+        DFE = DFE * Nf;
+      });
+      DFE = Ntotal - DFE;
+      for (let i = 0; i < factorKeys.length - 1; i++) {
+        let f_i_Set = new Set(factors[factorKeys[i]]);
+        for (let j = i + 1; j < factorKeys.length; j++) {
+          let f_j_Set = new Set(factors[factorKeys[j]]);
+          let SS_subtotal = 0;
+          f_i_Set.forEach((fi) => {
+            f_j_Set.forEach((fj) => {
+              let groupSum = 0;
+              let groupN = 0;
+              response[responseKey].forEach((val, index) => {
+                if (factors[factorKeys[i]][index] === fi && factors[factorKeys[j]][index] === fj) {
+                  groupSum += val;
+                  groupN += 1;
+                }
+              });
+              SS_subtotal += Math.pow(groupSum, 2) / groupN;
+            });
+          });
+          SS_subtotal = SS_subtotal - correctionFactor;
+          let iRow = anovaTable[factorKeys[i]];
+          let jRow = anovaTable[factorKeys[j]];
+          let fi_fj_DF = iRow.DF * jRow.DF;
+          let fi_fj_SS = SS_subtotal - iRow.SS - jRow.SS;
+          anovaTable[`${factorKeys[i]}*${factorKeys[j]}`] = { DF: fi_fj_DF, SS: fi_fj_SS, MS: fi_fj_SS / fi_fj_DF, F: void 0, p: void 0 };
+        }
+      }
+      let interactionSS_subtotal = SumSquareByGroups(factors, response) - correctionFactor;
+      let fullInteractionDF = 1;
+      let SSE = 0;
+      factorKeys.forEach((source) => {
+        fullInteractionDF = fullInteractionDF * anovaTable[source].DF;
+      });
+      Object.keys(anovaTable).forEach((source) => {
+        interactionSS_subtotal = interactionSS_subtotal - anovaTable[source].SS;
+        SSE += anovaTable[source].SS;
+      });
+      let fullInteractionName = factorKeys.join("*");
+      anovaTable[fullInteractionName] = { DF: fullInteractionDF, SS: interactionSS_subtotal, MS: interactionSS_subtotal / fullInteractionDF, F: void 0, p: void 0 };
+      SSE += interactionSS_subtotal;
+      let SStotal = SumSquaredDeviation(response[responseKey], 0) - correctionFactor;
+      SSE = SStotal - SSE;
+      let MSE = SSE / DFE;
+      Object.keys(anovaTable).forEach((source) => {
+        let sourceF = anovaTable[source].MS / MSE;
+        anovaTable[source].F = sourceF;
+        anovaTable[source].p = Distributions.F.RightTail(sourceF, anovaTable[source].DF, DFE);
+      });
+      anovaTable["Error"] = { DF: DFE, SS: SSE, MS: MSE };
+      anovaTable["Total"] = { DF: Ntotal - 1, SS: SStotal };
+      return anovaTable;
+    },
+    GLM(factors, response) {
+      let factorKeys = Object.keys(factors);
+      let anovaTable = {};
+      let responseKey = Object.keys(response)[0];
+      let Ntotal = response[responseKey].length;
+      let DFE = 1;
+      let responseData = response[responseKey];
+      factorKeys.forEach((k) => {
+        let SS = 0;
+        let levels = new Set(factors[k]);
+        let groupedData = GroupData(factors[k], responseData);
+        let descriptiveStats = {};
+        let mean_0;
+        Object.keys(groupedData).forEach((k2, k_i) => {
+          let mean = Mean(groupedData[k2]);
+          descriptiveStats[k2].mean = mean;
+          descriptiveStats[k2].std = StDev.S(groupedData[k2]);
+          descriptiveStats[k2].N = groupedData[k2].length;
+          if (k_i === 0) {
+            mean_0 = mean;
+            groupedData[k2].forEach((d) => {
+              SS += mean;
+            });
+          } else {
+            groupedData[k2].forEach((d) => {
+              SS += mean - Math.pow(mean - d, 2);
+            });
+          }
+        });
+        console.log(k, SS);
+      });
+      return anovaTable;
     }
   }
 };
@@ -3650,6 +3869,21 @@ var Probability = {
     }
   }
 };
+function GroupData(groupingArray, responseArray) {
+  if (groupingArray.length != responseArray.length) {
+    return { forEachGroup() {
+    } };
+  }
+  let returnObj = {};
+  let levels = new Set(groupingArray);
+  levels.forEach((l) => {
+    returnObj[l] = [];
+  });
+  for (let i = 0; i < groupingArray.length; i++) {
+    returnObj[groupingArray[i]].push(responseArray[i]);
+  }
+  return returnObj;
+}
 function CreateCanvas(width, height) {
   let canvas = document.createElement("canvas");
   canvas.height = height;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "qesuite",
-  "version": "1.0.51",
+  "version": "1.0.52",
   "description": "Performs advanced statistical analysis of data. Specifically designed for engineering statistical analysis",
   "main": "dist/index.js",
   "module": "dist/index.mjs",

package/versions/1_0_52.md

@@ -0,0 +1 @@
+- Rebuild of v1.0.51 see for details