qesuite 1.0.67 → 1.0.69

package/dist/index.d.mts

@@ -1142,6 +1142,9 @@ declare const ANOVA: {
             chart: HTMLCanvasElement;
         };
     };
+    Balanced: {
+        Table(responses: any, factors: any, interactions?: any): {};
+    };
     GeneralLinearModel(responses: any, factors: any, covariates: any): void;
     OneWay: {
         Table(data: any): any;

package/dist/index.d.ts

@@ -1142,6 +1142,9 @@ declare const ANOVA: {
             chart: HTMLCanvasElement;
         };
     };
+    Balanced: {
+        Table(responses: any, factors: any, interactions?: any): {};
+    };
     GeneralLinearModel(responses: any, factors: any, covariates: any): void;
     OneWay: {
         Table(data: any): any;

package/dist/index.js

@@ -1316,6 +1316,7 @@ var Capability = {
     if (confidenceInterval == void 0) {
       sides = void 0;
     }
+    console.log(confidenceInterval, sides);
     let results = Capability.Analysis(data, spec, target, subgroupSize, confidenceInterval, sides, method, w, UnbiasingConstant2);
     let mean = Mean(data);
     let std = StDev.S(data);
@@ -5410,6 +5411,110 @@ var ANOVA = {
       };
     }
   },
+  Balanced: {
+    Table(responses, factors, interactions = []) {
+      let grandMean = Mean(responses);
+      let factorsWInteractions = {};
+      Object.keys(factors).forEach((f) => {
+        factorsWInteractions[f] = factors[f];
+      });
+      interactions.forEach((element) => {
+        factorsWInteractions[element] = responses.map((r, i) => {
+          return element.split("*").map((k) => {
+            return factors[k][i];
+          }).join("*");
+        });
+      });
+      let factorInfo = {};
+      let totalLevelCount = 1;
+      Object.keys(factors).forEach((k, i) => {
+        let levels = Unique(factors[k]);
+        totalLevelCount *= levels.length;
+        factorInfo[k] = {
+          Factor: k,
+          Levels: levels.length,
+          Values: levels.join(", ")
+        };
+      });
+      let SSFactors = 0;
+      let DFFactors = 0;
+      let anovaTable = {};
+      Object.keys(factorsWInteractions).forEach((k, i) => {
+        let df = Product(k.split("*").map((f) => {
+          return factorInfo[f].Levels - 1;
+        }));
+        DFFactors += df;
+        let ss = 0;
+        Unique(factorsWInteractions[k]).forEach((group) => {
+          let groupMean = Mean(responses.filter((r, ri) => {
+            return factorsWInteractions[k][ri] == group;
+          }));
+          if (k.includes("*")) {
+            let factorLevelMeans = k.split("*").map((f, fi) => {
+              return responses.filter((r, ri) => {
+                return factors[f][ri] == group.split("*")[fi];
+              });
+            });
+            let factorCombos = [];
+            k.split("*").forEach((f, fi) => {
+              k.split("*").forEach((f2, fi2) => {
+                if (fi2 > fi) {
+                  let responseValues = responses.filter((r, ri) => {
+                    return factors[k.split("*")[fi]][ri] == f && factors[k.split("*")[fi2]][ri] == f2;
+                  });
+                  factorCombos.push(responseValues);
+                }
+              });
+            });
+            ss += Math.pow(groupMean - Sum(factorLevelMeans.map((arr) => {
+              return Mean(arr);
+            })) + grandMean, 2);
+          } else {
+            ss += Math.pow(groupMean - grandMean, 2);
+          }
+        });
+        let n = responses.length / totalLevelCount;
+        ss *= n * Product(Object.keys(factorInfo).filter((f) => {
+          return k.includes(f) == false;
+        }).map((fk) => {
+          return factorInfo[fk].Levels;
+        }));
+        SSFactors += ss;
+        anovaTable[k] = {
+          Source: k,
+          DF: df,
+          SS: ss,
+          MS: ss / df,
+          F: NaN,
+          p: NaN
+        };
+      });
+      let SST = SumSq(responses.map((r) => {
+        return r - grandMean;
+      }));
+      let DFE = responses.length - DFFactors - 1;
+      let SSE = SST - SSFactors;
+      let MSE = SSE / DFE;
+      Object.keys(anovaTable).forEach((key) => {
+        let fValue = anovaTable[key].MS / MSE;
+        let pValue = Distributions.F.RightTail(fValue, anovaTable[key].DF, DFE);
+        anovaTable[key].F = fValue;
+        anovaTable[key].p = pValue;
+      });
+      anovaTable["Error"] = {
+        Source: "Error",
+        DF: DFE,
+        SS: SSE,
+        MS: MSE
+      };
+      anovaTable["Total"] = {
+        Source: "Total",
+        DF: responses.length - 1,
+        SS: SST
+      };
+      return anovaTable;
+    }
+  },
   GeneralLinearModel(responses, factors, covariates) {
   },
   OneWay: {
@@ -7985,11 +8090,15 @@ var NonparametricTesting = {
     let H = 12 * Sum(avgRanks.map((Rj, j) => {
       return data[j].length * Math.pow(Rj - avgOverallRank, 2);
     })) / (N * (N + 1));
+    H = 12 / (N * (N + 1)) * Sum(ranks.map((r) => {
+      return Math.pow(Sum(r), 2) / r.length;
+    })) - 3 * (N + 1);
     let H_not = 0 + H;
     if (adjustH) {
-      H = 12 / (N * (N + 1)) * Sum(ranks.map((r) => {
-        return Math.pow(Sum(r), 2) / r.length;
-      })) - 3 * (N + 1);
+      let T = 1 - 1 / (Math.pow(N, 3) - N) * Sum(tieSets.map((t) => {
+        return Math.pow(t.length, 3) - t.length;
+      }));
+      H = H / T;
     }
     return {
       DescriptiveStatistics: data.map((group, i) => {
@@ -11435,11 +11544,14 @@ function AttirbuteAgreementConfidenceIntervals(object, confidenceLevel) {
   let v1_low = 2 * object.MatchedCount;
   let v2_low = 2 * (object.InspectedCount - object.MatchedCount + 1);
   let lowP = object.MatchedCount == object.InspectedCount ? alpha : alpha / 2;
-  let Fv1v2_a_2 = object.MatchedCount == 0 ? 0 : Distributions.F.inv(lowP, v1_low, v2_low);
+  const F_inv = (p, df1, df2) => {
+    return df2 / (df1 * (1 / Beta.invInc(p, df1 / 2, df2 / 2) - 1));
+  };
+  let Fv1v2_a_2 = object.MatchedCount == 0 ? 0 : F_inv(lowP, v1_low, v2_low);
   let v1_high = 2 * (object.MatchedCount + 1);
   let v2_high = 2 * (object.InspectedCount - object.MatchedCount);
   let highP = object.MatchedCount == 0 ? 1 - alpha : 1 - alpha / 2;
-  let Fv1v2_1_a_2 = object.MatchedCount == object.InspectedCount ? 1 : Distributions.F.inv(highP, v1_high, v2_high);
+  let Fv1v2_1_a_2 = object.MatchedCount == object.InspectedCount ? 1 : F_inv(highP, v1_high, v2_high);
   object.Percent = object.MatchedCount / object.InspectedCount;
   object.CI_Low = v1_low * Fv1v2_a_2 / (v2_low + v1_low * Fv1v2_a_2);
   object.CI_High = v1_high * Fv1v2_1_a_2 / (v2_high + v1_high * Fv1v2_1_a_2);

package/dist/index.mjs

@@ -1190,6 +1190,7 @@ var Capability = {
     if (confidenceInterval == void 0) {
       sides = void 0;
     }
+    console.log(confidenceInterval, sides);
     let results = Capability.Analysis(data, spec, target, subgroupSize, confidenceInterval, sides, method, w, UnbiasingConstant2);
     let mean = Mean(data);
     let std = StDev.S(data);
@@ -5284,6 +5285,110 @@ var ANOVA = {
       };
     }
   },
+  Balanced: {
+    Table(responses, factors, interactions = []) {
+      let grandMean = Mean(responses);
+      let factorsWInteractions = {};
+      Object.keys(factors).forEach((f) => {
+        factorsWInteractions[f] = factors[f];
+      });
+      interactions.forEach((element) => {
+        factorsWInteractions[element] = responses.map((r, i) => {
+          return element.split("*").map((k) => {
+            return factors[k][i];
+          }).join("*");
+        });
+      });
+      let factorInfo = {};
+      let totalLevelCount = 1;
+      Object.keys(factors).forEach((k, i) => {
+        let levels = Unique(factors[k]);
+        totalLevelCount *= levels.length;
+        factorInfo[k] = {
+          Factor: k,
+          Levels: levels.length,
+          Values: levels.join(", ")
+        };
+      });
+      let SSFactors = 0;
+      let DFFactors = 0;
+      let anovaTable = {};
+      Object.keys(factorsWInteractions).forEach((k, i) => {
+        let df = Product(k.split("*").map((f) => {
+          return factorInfo[f].Levels - 1;
+        }));
+        DFFactors += df;
+        let ss = 0;
+        Unique(factorsWInteractions[k]).forEach((group) => {
+          let groupMean = Mean(responses.filter((r, ri) => {
+            return factorsWInteractions[k][ri] == group;
+          }));
+          if (k.includes("*")) {
+            let factorLevelMeans = k.split("*").map((f, fi) => {
+              return responses.filter((r, ri) => {
+                return factors[f][ri] == group.split("*")[fi];
+              });
+            });
+            let factorCombos = [];
+            k.split("*").forEach((f, fi) => {
+              k.split("*").forEach((f2, fi2) => {
+                if (fi2 > fi) {
+                  let responseValues = responses.filter((r, ri) => {
+                    return factors[k.split("*")[fi]][ri] == f && factors[k.split("*")[fi2]][ri] == f2;
+                  });
+                  factorCombos.push(responseValues);
+                }
+              });
+            });
+            ss += Math.pow(groupMean - Sum(factorLevelMeans.map((arr) => {
+              return Mean(arr);
+            })) + grandMean, 2);
+          } else {
+            ss += Math.pow(groupMean - grandMean, 2);
+          }
+        });
+        let n = responses.length / totalLevelCount;
+        ss *= n * Product(Object.keys(factorInfo).filter((f) => {
+          return k.includes(f) == false;
+        }).map((fk) => {
+          return factorInfo[fk].Levels;
+        }));
+        SSFactors += ss;
+        anovaTable[k] = {
+          Source: k,
+          DF: df,
+          SS: ss,
+          MS: ss / df,
+          F: NaN,
+          p: NaN
+        };
+      });
+      let SST = SumSq(responses.map((r) => {
+        return r - grandMean;
+      }));
+      let DFE = responses.length - DFFactors - 1;
+      let SSE = SST - SSFactors;
+      let MSE = SSE / DFE;
+      Object.keys(anovaTable).forEach((key) => {
+        let fValue = anovaTable[key].MS / MSE;
+        let pValue = Distributions.F.RightTail(fValue, anovaTable[key].DF, DFE);
+        anovaTable[key].F = fValue;
+        anovaTable[key].p = pValue;
+      });
+      anovaTable["Error"] = {
+        Source: "Error",
+        DF: DFE,
+        SS: SSE,
+        MS: MSE
+      };
+      anovaTable["Total"] = {
+        Source: "Total",
+        DF: responses.length - 1,
+        SS: SST
+      };
+      return anovaTable;
+    }
+  },
   GeneralLinearModel(responses, factors, covariates) {
   },
   OneWay: {
@@ -7859,11 +7964,15 @@ var NonparametricTesting = {
     let H = 12 * Sum(avgRanks.map((Rj, j) => {
       return data[j].length * Math.pow(Rj - avgOverallRank, 2);
     })) / (N * (N + 1));
+    H = 12 / (N * (N + 1)) * Sum(ranks.map((r) => {
+      return Math.pow(Sum(r), 2) / r.length;
+    })) - 3 * (N + 1);
     let H_not = 0 + H;
     if (adjustH) {
-      H = 12 / (N * (N + 1)) * Sum(ranks.map((r) => {
-        return Math.pow(Sum(r), 2) / r.length;
-      })) - 3 * (N + 1);
+      let T = 1 - 1 / (Math.pow(N, 3) - N) * Sum(tieSets.map((t) => {
+        return Math.pow(t.length, 3) - t.length;
+      }));
+      H = H / T;
     }
     return {
       DescriptiveStatistics: data.map((group, i) => {
@@ -11309,11 +11418,14 @@ function AttirbuteAgreementConfidenceIntervals(object, confidenceLevel) {
   let v1_low = 2 * object.MatchedCount;
   let v2_low = 2 * (object.InspectedCount - object.MatchedCount + 1);
   let lowP = object.MatchedCount == object.InspectedCount ? alpha : alpha / 2;
-  let Fv1v2_a_2 = object.MatchedCount == 0 ? 0 : Distributions.F.inv(lowP, v1_low, v2_low);
+  const F_inv = (p, df1, df2) => {
+    return df2 / (df1 * (1 / Beta.invInc(p, df1 / 2, df2 / 2) - 1));
+  };
+  let Fv1v2_a_2 = object.MatchedCount == 0 ? 0 : F_inv(lowP, v1_low, v2_low);
   let v1_high = 2 * (object.MatchedCount + 1);
   let v2_high = 2 * (object.InspectedCount - object.MatchedCount);
   let highP = object.MatchedCount == 0 ? 1 - alpha : 1 - alpha / 2;
-  let Fv1v2_1_a_2 = object.MatchedCount == object.InspectedCount ? 1 : Distributions.F.inv(highP, v1_high, v2_high);
+  let Fv1v2_1_a_2 = object.MatchedCount == object.InspectedCount ? 1 : F_inv(highP, v1_high, v2_high);
   object.Percent = object.MatchedCount / object.InspectedCount;
   object.CI_Low = v1_low * Fv1v2_a_2 / (v2_low + v1_low * Fv1v2_a_2);
   object.CI_High = v1_high * Fv1v2_1_a_2 / (v2_high + v1_high * Fv1v2_1_a_2);

package/index.ts

@@ -1332,6 +1332,7 @@ SixPack(data: number[], spec: Specification, title?: string){
 },
 Report(data: number[], spec: Specification, target?: number, subgroupSize?: number, confidenceInterval?: number, sides: any = -1, method?: string, w?: number, UnbiasingConstant?: boolean){
   if(confidenceInterval == undefined){sides = undefined}
+  console.log(confidenceInterval, sides)
   let results: any = Capability.Analysis(data, spec, target, subgroupSize, confidenceInterval, sides, method, w, UnbiasingConstant);
   let mean = Mean(data);
   let std = StDev.S(data);
@@ -5683,6 +5684,103 @@ export const ANOVA = {
       }
     }
   },
+  Balanced:{
+    Table(responses, factors, interactions: any = []){
+      let grandMean = Mean(responses)
+      
+      let factorsWInteractions = {};
+
+      Object.keys(factors).forEach(f => {
+        factorsWInteractions[f] = factors[f]
+      })
+
+      interactions.forEach(element => {
+        factorsWInteractions[element] = responses.map((r,i) => {return element.split("*").map(k =>{return factors[k][i]}).join("*")})
+      });
+
+      let factorInfo = {}
+      let totalLevelCount = 1;
+      Object.keys(factors).forEach((k,i) => {
+        let levels = Unique(factors[k])
+        totalLevelCount *= levels.length;
+        factorInfo[k] = {
+          Factor: k,
+          Levels: levels.length,
+          Values: levels.join(", ")
+        }
+      })
+
+      let SSFactors = 0;
+      let DFFactors = 0;
+      let anovaTable = {}
+      Object.keys(factorsWInteractions).forEach((k,i) => {
+        let df = Product(k.split("*").map(f => {return factorInfo[f].Levels - 1}))
+        DFFactors += df;
+
+        let ss = 0;
+        Unique(factorsWInteractions[k]).forEach(group => {
+          let groupMean = Mean(responses.filter((r,ri) => {return factorsWInteractions[k][ri] == group}))
+          if(k.includes("*")){
+            // is an interaction
+            let factorLevelMeans = k.split("*").map((f,fi) => {return responses.filter((r,ri) => {return factors[f][ri] == group.split("*")[fi]})})
+            
+            let factorCombos: any = [];
+            k.split("*").forEach((f,fi) => {
+              k.split("*").forEach((f2, fi2) => {
+                if(fi2 > fi){
+                  let responseValues = responses.filter((r, ri) => {return factors[k.split("*")[fi]][ri] == f && factors[k.split("*")[fi2]][ri] == f2})
+                  factorCombos.push(responseValues)
+                }
+              })
+            })
+            
+            ss += Math.pow(groupMean - Sum(factorLevelMeans.map(arr => {return Mean(arr)})) + grandMean, 2)
+          }else{
+            ss += Math.pow(groupMean - grandMean, 2)
+          }
+        })
+        let n = responses.length / totalLevelCount;
+        ss *= n * Product(Object.keys(factorInfo).filter(f => {return k.includes(f) == false}).map(fk => {return factorInfo[fk].Levels}))
+        SSFactors += ss;
+        anovaTable[k] = {
+          Source: k,
+          DF: df,
+          SS: ss,
+          MS: ss/df,
+          F: NaN,
+          p: NaN
+        }
+      })
+      let SST = SumSq(responses.map(r => {return r - grandMean}))
+
+      let DFE = responses.length - DFFactors - 1;
+      let SSE = SST - SSFactors;
+      let MSE = SSE / DFE;
+
+      Object.keys(anovaTable).forEach(key => {
+        let fValue = anovaTable[key].MS / MSE 
+        let pValue = Distributions.F.RightTail(fValue, anovaTable[key].DF, DFE) 
+        anovaTable[key].F = fValue
+        anovaTable[key].p = pValue
+      })
+
+      anovaTable["Error"] = {
+        Source: "Error",
+        DF: DFE,
+        SS: SSE,
+        MS: MSE
+      }
+      
+      anovaTable["Total"] = {
+        Source: "Total",
+        DF: responses.length - 1,
+        SS: SST
+      }
+
+      return anovaTable
+      
+    }
+  },
   GeneralLinearModel(responses: any, factors: any, covariates: any){
 
   },
@@ -8395,12 +8493,13 @@ export const NonparametricTesting = {
     
     let tieSets = CompileTies(combinedData)
     let adjustH = tieSets.length > 0
-    let H = 12 * Sum(avgRanks.map((Rj, j) => {return data[j].length * Math.pow(Rj - avgOverallRank, 2)}))/(N *(N + 1));
+    let H = 12 * Sum(avgRanks.map((Rj, j) => {return data[j].length * Math.pow(Rj - avgOverallRank, 2)}))/(N *(N + 1));    
+    H = (12 / (N * (N + 1))) * (Sum(ranks.map(r => {return Math.pow(Sum(r),2)/r.length}))) - 3 *(N + 1);
     let H_not = 0 + H;
 
     if(adjustH){
-      // H  = H/(1 - Sum(tieSets.map((t: any) => {return Math.pow(t.length, 3) - t.length}))/(Math.pow(N,3) - N));
-      H = (12 / (N * (N + 1))) * (Sum(ranks.map(r => {return Math.pow(Sum(r),2)/r.length}))) - 3 *(N + 1);
+      let T = 1 - 1 / (Math.pow(N, 3) - N) * Sum(tieSets.map(t => {return Math.pow(t.length, 3) - t.length}))
+      H = H / T
     }
 
     return {
@@ -12252,11 +12351,14 @@ function AttirbuteAgreementConfidenceIntervals(object: any, confidenceLevel?: nu
   let v1_low = 2 * object.MatchedCount
   let v2_low = 2 * (object.InspectedCount - object.MatchedCount + 1)
   let lowP = object.MatchedCount == object.InspectedCount ? alpha : alpha / 2;
-  let Fv1v2_a_2 = object.MatchedCount == 0 ? 0 : Distributions.F.inv(lowP, v1_low, v2_low);
+  const F_inv = (p, df1, df2) => {
+    return df2 / (df1 * (1 / Beta.invInc(p, df1 / 2, df2 / 2) - 1))
+  }
+  let Fv1v2_a_2 = object.MatchedCount == 0 ? 0 : F_inv(lowP, v1_low, v2_low);
   let v1_high = 2 * (object.MatchedCount + 1)
   let v2_high = 2 * (object.InspectedCount - object.MatchedCount)
   let highP = object.MatchedCount == 0 ? 1 - alpha : 1-alpha/2
-  let Fv1v2_1_a_2 = object.MatchedCount == object.InspectedCount ? 1 : Distributions.F.inv(highP, v1_high, v2_high);
+  let Fv1v2_1_a_2 = object.MatchedCount == object.InspectedCount ? 1 : F_inv(highP, v1_high, v2_high);
   object.Percent = object.MatchedCount / object.InspectedCount;
   object.CI_Low = (v1_low * Fv1v2_a_2)/(v2_low + (v1_low * Fv1v2_a_2));
   object.CI_High = (v1_high * Fv1v2_1_a_2)/(v2_high + (v1_high * Fv1v2_1_a_2));
@@ -13960,5 +14062,4 @@ const Matrix = {
     return newMatrix
   },
 }
-// End Matrix Functions
-/** ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ *///  Validation
+// End Matrix Functions

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "qesuite",
-  "version": "1.0.67",
+  "version": "1.0.69",
   "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_68.md

@@ -0,0 +1 @@
+Updated Confidence Interval Calculation in Attribute Agreement Analysis

package/versions/1_0_69.md

@@ -0,0 +1 @@
+Updated KruskalWallis Adjusted for Ties formula