qesuite 1.0.65 → 1.0.68

package/dist/index.d.mts

@@ -503,7 +503,8 @@ declare const Beta: {
     * @param a The first shape parameter; x^(a-1).
     * @param b The second shape parameter; (1 - x)^(b-1).
     */
-    inc(x: number, a: number, b: number): number;
+    inc(X: number, A: number, B: number): number;
+    incomplete(x: any, a: any, b: any): any;
     /**
     * Evaluates the regularized incomplete beta function of x for the beta function with specified shape parameters a and b.
     * @customfunction
@@ -512,6 +513,7 @@ declare const Beta: {
     * @param b The second shape parameter; (1 - x)^(b-1).
     */
     incr(x: number, a: number, b: number): number;
+    invInc(p: any, a: any, b: any): any;
 };
 declare const ERF: {
     /**
@@ -589,7 +591,7 @@ declare const Distributions: {
         * @param a The first shape parameter, x^(a-1).
         * @param b The second shape parameter; (1 - x)^(b-1).
         */
-        cdf(x: number, a: number, b: number): number;
+        cdf(x: number, a: number, b: number): any;
         /**
         * Probability Density Function. Calculates the probability of random variable x occuring from the beta distribution with the specified shape parameters a and b.
         * @param x The value to evaluate.
@@ -662,7 +664,7 @@ declare const Distributions: {
         * @param df2 Denominator degrees of freedom
         * @returns the Right-Tailed P-Value of the F Distribution
         */
-        cdf(x: number, df1: number, df2: number): number;
+        cdf(x: number, df1: number, df2: number): any;
         /**
         * Calculates the right-tailed p-value of the supplied F distribution.
         * @param f F value to evaluate
@@ -1140,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

@@ -503,7 +503,8 @@ declare const Beta: {
     * @param a The first shape parameter; x^(a-1).
     * @param b The second shape parameter; (1 - x)^(b-1).
     */
-    inc(x: number, a: number, b: number): number;
+    inc(X: number, A: number, B: number): number;
+    incomplete(x: any, a: any, b: any): any;
     /**
     * Evaluates the regularized incomplete beta function of x for the beta function with specified shape parameters a and b.
     * @customfunction
@@ -512,6 +513,7 @@ declare const Beta: {
     * @param b The second shape parameter; (1 - x)^(b-1).
     */
     incr(x: number, a: number, b: number): number;
+    invInc(p: any, a: any, b: any): any;
 };
 declare const ERF: {
     /**
@@ -589,7 +591,7 @@ declare const Distributions: {
         * @param a The first shape parameter, x^(a-1).
         * @param b The second shape parameter; (1 - x)^(b-1).
         */
-        cdf(x: number, a: number, b: number): number;
+        cdf(x: number, a: number, b: number): any;
         /**
         * Probability Density Function. Calculates the probability of random variable x occuring from the beta distribution with the specified shape parameters a and b.
         * @param x The value to evaluate.
@@ -662,7 +664,7 @@ declare const Distributions: {
         * @param df2 Denominator degrees of freedom
         * @returns the Right-Tailed P-Value of the F Distribution
         */
-        cdf(x: number, df1: number, df2: number): number;
+        cdf(x: number, df1: number, df2: number): any;
         /**
         * Calculates the right-tailed p-value of the supplied F distribution.
         * @param f F value to evaluate
@@ -1140,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

@@ -1078,7 +1078,6 @@ var Capability = {
   */
   Cp(data, spec, subgroupSize = 1, method, w, UnbiasingConstant2 = true) {
     let standarddeviation = StDev.W(data, subgroupSize, method, w, UnbiasingConstant2);
-    console.log({ StDevW: standarddeviation });
     if (!Number.isNaN(spec.USL) && !Number.isNaN(spec.LSL)) {
       return Number((spec.USL - spec.LSL) / (6 * standarddeviation));
     } else {
@@ -1317,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);
@@ -1802,10 +1802,34 @@ var Beta = {
   * @param a The first shape parameter; x^(a-1).
   * @param b The second shape parameter; (1 - x)^(b-1). 
   */
-  inc(x, a, b) {
+  inc(X, A, B) {
+    var A0 = 0;
+    var B0 = 1;
+    var A1 = 1;
+    var B1 = 1;
+    var M9 = 0;
+    var A2 = 0;
+    var C9;
+    while (Math.abs((A1 - A2) / A1) > 1e-5) {
+      A2 = A1;
+      C9 = -(A + M9) * (A + B + M9) * X / (A + 2 * M9) / (A + 2 * M9 + 1);
+      A0 = A1 + C9 * A0;
+      B0 = B1 + C9 * B0;
+      M9 = M9 + 1;
+      C9 = M9 * (B - M9) * X / (A + 2 * M9 - 1) / (A + 2 * M9);
+      A1 = A0 + C9 * A1;
+      B1 = B0 + C9 * B1;
+      A0 = A0 / B1;
+      B0 = B0 / B1;
+      A1 = A1 / B1;
+      B1 = 1;
+    }
+    return A1 / A;
+  },
+  incomplete(x, a, b) {
     var bt = x === 0 || x === 1 ? 0 : Math.exp(Gamma.ln(a + b) - Gamma.ln(a) - Gamma.ln(b) + a * Math.log(x) + b * Math.log(1 - x));
     if (x < 0 || x > 1)
-      return NaN;
+      return false;
     if (x < (a + 1) / (a + b + 2))
       return bt * Beta.cf(x, a, b) / a;
     return 1 - bt * Beta.cf(1 - x, b, a) / b;
@@ -1819,6 +1843,54 @@ var Beta = {
   */
   incr(x, a, b) {
     return Beta.inc(x, a, b) / Beta.fn(a, b);
+  },
+  invInc(p, a, b) {
+    var EPS = 1e-8;
+    var a1 = a - 1;
+    var b1 = b - 1;
+    var j = 0;
+    var lna, lnb, pp, t, u, err, x, al, h, w, afac;
+    if (p <= 0)
+      return 0;
+    if (p >= 1)
+      return 1;
+    if (a >= 1 && b >= 1) {
+      pp = p < 0.5 ? p : 1 - p;
+      t = Math.sqrt(-2 * Math.log(pp));
+      x = (2.30753 + t * 0.27061) / (1 + t * (0.99229 + t * 0.04481)) - t;
+      if (p < 0.5)
+        x = -x;
+      al = (x * x - 3) / 6;
+      h = 2 / (1 / (2 * a - 1) + 1 / (2 * b - 1));
+      w = x * Math.sqrt(al + h) / h - (1 / (2 * b - 1) - 1 / (2 * a - 1)) * (al + 5 / 6 - 2 / (3 * h));
+      x = a / (a + b * Math.exp(2 * w));
+    } else {
+      lna = Math.log(a / (a + b));
+      lnb = Math.log(b / (a + b));
+      t = Math.exp(a * lna) / a;
+      u = Math.exp(b * lnb) / b;
+      w = t + u;
+      if (p < t / w)
+        x = Math.pow(a * w * p, 1 / a);
+      else
+        x = 1 - Math.pow(b * w * (1 - p), 1 / b);
+    }
+    afac = -Gamma.ln(a) - Gamma.ln(b) + Gamma.ln(a + b);
+    for (; j < 10; j++) {
+      if (x === 0 || x === 1)
+        return x;
+      err = Beta.incomplete(x, a, b) - p;
+      t = Math.exp(a1 * Math.log(x) + b1 * Math.log(1 - x) + afac);
+      u = err / t;
+      x -= t = u / (1 - 0.5 * Math.min(1, u * (a1 / x - b1 / (1 - x))));
+      if (x <= 0)
+        x = 0.5 * (x + t);
+      if (x >= 1)
+        x = 0.5 * (x + t + 1);
+      if (Math.abs(t) < EPS * x && j > 0)
+        break;
+    }
+    return x;
   }
 };
 var ERF = {
@@ -1983,7 +2055,17 @@ var Distributions = {
     * @param b The second shape parameter; (1 - x)^(b-1). 
     */
     cdf(x, a, b) {
-      return Beta.incr(x, a, b);
+      var S;
+      var BT;
+      var Bcdf;
+      S = a + b;
+      BT = Math.exp(Gamma.ln(S) - Gamma.ln(b) - Gamma.ln(a) + a * Math.log(x) + b * Math.log(1 - x));
+      if (x < (a + 1) / (S + 2)) {
+        Bcdf = BT * Beta.inc(x, a, b);
+      } else {
+        Bcdf = 1 - BT * Beta.inc(1 - x, b, a);
+      }
+      return Bcdf;
     },
     /**
     * Probability Density Function. Calculates the probability of random variable x occuring from the beta distribution with the specified shape parameters a and b.
@@ -3852,8 +3934,8 @@ var Distributions = {
     * @returns the Right-Tailed P-Value of the F Distribution
     */
     cdf(x, df1, df2) {
-      let subX = df1 * x / (df1 * x + df2);
-      let p = Beta.incr(subX, df1 / 2, df2 / 2);
+      let z = x / (x + df2 / df1);
+      let p = Distributions.Beta.cdf(z, df1 / 2, df2 / 2);
       if (p > 1) {
         p = 1;
       }
@@ -4771,7 +4853,7 @@ var Distributions = {
       if (p == 0.5) {
         return 0;
       }
-      let x = Distributions.Beta.inv(2 * Math.min(p, 1 - p), 0.5 * df, 0.5);
+      var x = Beta.invInc(2 * Math.min(p, 1 - p), 0.5 * df, 0.5);
       x = Math.sqrt(df * (1 - x) / x);
       return p > 0.5 ? x : -x;
     }
@@ -5304,9 +5386,7 @@ var ANOVA = {
       let pooledSTD = StDev.Pooled(pooledData);
       let alphaADJ = (1 - Math.pow(1 - alpha, 1 / rCount)) / 2;
       let hAlpha = Math.abs(Distributions.T.inv(alphaADJ, grandArray.length - rCount));
-      console.log({ alphaADJ, ln: grandArray.length, rCount });
       let scaleDF = Math.sqrt((rCount - 1) / (rCount * tCount));
-      console.log({ grandMean, pooledSTD, hAlpha, scaleDF });
       let UDL = grandMean + pooledSTD * hAlpha * scaleDF;
       let LDL = grandMean - pooledSTD * hAlpha * scaleDF;
       let chartSettings = new ChartSettings();
@@ -5331,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: {
@@ -7572,7 +7756,7 @@ var EquivalenceTesting = {
     let mean = Mean(dta);
     let se = StandardError(dta);
     let LSL = multiply ? lowerSpecification * target : lowerSpecification;
-    let USL = multiply ? upperSpecification * target : lowerSpecification;
+    let USL = multiply ? upperSpecification * target : upperSpecification;
     let diff = mean - target;
     let CI_Low = Math.min((LSL + USL) / 2, diff - Distributions.T.inv(1 - confidenceLevel, dta.length - 1) * se);
     let CI_High = Math.max((LSL + USL) / 2, diff + Distributions.T.inv(1 - confidenceLevel, dta.length - 1) * se);
@@ -7899,7 +8083,7 @@ var NonparametricTesting = {
     let avgOverallRank = Mean(combinedRanks);
     let N = combinedData.length;
     let zValues = avgRanks.map((Rj, j) => {
-      return (Rj - avgOverallRank) / Math.sqrt((N + 1) * (N / data[j].length - 1) / 12);
+      return (Rj - avgOverallRank) / Math.sqrt((N + 1) * (N / extractedData[j].length - 1) / 12);
     });
     let tieSets = CompileTies(combinedData);
     let adjustH = tieSets.length > 0;
@@ -11356,11 +11540,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);
@@ -11951,7 +12138,6 @@ function GageLinearityAndBias(parts, referenceValues, responses, processVariatio
       let \u03C3B2 = \u03C3R2 / Math.sqrt(m);
       let t2 = avgBias3 / \u03C3B2;
       let p2 = Distributions.T.cdf(-Math.abs(t2), df2) + (1 - Distributions.T.cdf(Math.abs(t2), df2));
-      console.log({ t: t2, df: df2, \u03C3B: \u03C3B2, \u03C3R: \u03C3R2, m, rBar: rBar2, d2: d22 });
       partBiasObjects.push({
         ReferenceValue: ref,
         Bias: avgBias3,

package/dist/index.mjs

@@ -952,7 +952,6 @@ var Capability = {
   */
   Cp(data, spec, subgroupSize = 1, method, w, UnbiasingConstant2 = true) {
     let standarddeviation = StDev.W(data, subgroupSize, method, w, UnbiasingConstant2);
-    console.log({ StDevW: standarddeviation });
     if (!Number.isNaN(spec.USL) && !Number.isNaN(spec.LSL)) {
       return Number((spec.USL - spec.LSL) / (6 * standarddeviation));
     } else {
@@ -1191,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);
@@ -1676,10 +1676,34 @@ var Beta = {
   * @param a The first shape parameter; x^(a-1).
   * @param b The second shape parameter; (1 - x)^(b-1). 
   */
-  inc(x, a, b) {
+  inc(X, A, B) {
+    var A0 = 0;
+    var B0 = 1;
+    var A1 = 1;
+    var B1 = 1;
+    var M9 = 0;
+    var A2 = 0;
+    var C9;
+    while (Math.abs((A1 - A2) / A1) > 1e-5) {
+      A2 = A1;
+      C9 = -(A + M9) * (A + B + M9) * X / (A + 2 * M9) / (A + 2 * M9 + 1);
+      A0 = A1 + C9 * A0;
+      B0 = B1 + C9 * B0;
+      M9 = M9 + 1;
+      C9 = M9 * (B - M9) * X / (A + 2 * M9 - 1) / (A + 2 * M9);
+      A1 = A0 + C9 * A1;
+      B1 = B0 + C9 * B1;
+      A0 = A0 / B1;
+      B0 = B0 / B1;
+      A1 = A1 / B1;
+      B1 = 1;
+    }
+    return A1 / A;
+  },
+  incomplete(x, a, b) {
     var bt = x === 0 || x === 1 ? 0 : Math.exp(Gamma.ln(a + b) - Gamma.ln(a) - Gamma.ln(b) + a * Math.log(x) + b * Math.log(1 - x));
     if (x < 0 || x > 1)
-      return NaN;
+      return false;
     if (x < (a + 1) / (a + b + 2))
       return bt * Beta.cf(x, a, b) / a;
     return 1 - bt * Beta.cf(1 - x, b, a) / b;
@@ -1693,6 +1717,54 @@ var Beta = {
   */
   incr(x, a, b) {
     return Beta.inc(x, a, b) / Beta.fn(a, b);
+  },
+  invInc(p, a, b) {
+    var EPS = 1e-8;
+    var a1 = a - 1;
+    var b1 = b - 1;
+    var j = 0;
+    var lna, lnb, pp, t, u, err, x, al, h, w, afac;
+    if (p <= 0)
+      return 0;
+    if (p >= 1)
+      return 1;
+    if (a >= 1 && b >= 1) {
+      pp = p < 0.5 ? p : 1 - p;
+      t = Math.sqrt(-2 * Math.log(pp));
+      x = (2.30753 + t * 0.27061) / (1 + t * (0.99229 + t * 0.04481)) - t;
+      if (p < 0.5)
+        x = -x;
+      al = (x * x - 3) / 6;
+      h = 2 / (1 / (2 * a - 1) + 1 / (2 * b - 1));
+      w = x * Math.sqrt(al + h) / h - (1 / (2 * b - 1) - 1 / (2 * a - 1)) * (al + 5 / 6 - 2 / (3 * h));
+      x = a / (a + b * Math.exp(2 * w));
+    } else {
+      lna = Math.log(a / (a + b));
+      lnb = Math.log(b / (a + b));
+      t = Math.exp(a * lna) / a;
+      u = Math.exp(b * lnb) / b;
+      w = t + u;
+      if (p < t / w)
+        x = Math.pow(a * w * p, 1 / a);
+      else
+        x = 1 - Math.pow(b * w * (1 - p), 1 / b);
+    }
+    afac = -Gamma.ln(a) - Gamma.ln(b) + Gamma.ln(a + b);
+    for (; j < 10; j++) {
+      if (x === 0 || x === 1)
+        return x;
+      err = Beta.incomplete(x, a, b) - p;
+      t = Math.exp(a1 * Math.log(x) + b1 * Math.log(1 - x) + afac);
+      u = err / t;
+      x -= t = u / (1 - 0.5 * Math.min(1, u * (a1 / x - b1 / (1 - x))));
+      if (x <= 0)
+        x = 0.5 * (x + t);
+      if (x >= 1)
+        x = 0.5 * (x + t + 1);
+      if (Math.abs(t) < EPS * x && j > 0)
+        break;
+    }
+    return x;
   }
 };
 var ERF = {
@@ -1857,7 +1929,17 @@ var Distributions = {
     * @param b The second shape parameter; (1 - x)^(b-1). 
     */
     cdf(x, a, b) {
-      return Beta.incr(x, a, b);
+      var S;
+      var BT;
+      var Bcdf;
+      S = a + b;
+      BT = Math.exp(Gamma.ln(S) - Gamma.ln(b) - Gamma.ln(a) + a * Math.log(x) + b * Math.log(1 - x));
+      if (x < (a + 1) / (S + 2)) {
+        Bcdf = BT * Beta.inc(x, a, b);
+      } else {
+        Bcdf = 1 - BT * Beta.inc(1 - x, b, a);
+      }
+      return Bcdf;
     },
     /**
     * Probability Density Function. Calculates the probability of random variable x occuring from the beta distribution with the specified shape parameters a and b.
@@ -3726,8 +3808,8 @@ var Distributions = {
     * @returns the Right-Tailed P-Value of the F Distribution
     */
     cdf(x, df1, df2) {
-      let subX = df1 * x / (df1 * x + df2);
-      let p = Beta.incr(subX, df1 / 2, df2 / 2);
+      let z = x / (x + df2 / df1);
+      let p = Distributions.Beta.cdf(z, df1 / 2, df2 / 2);
       if (p > 1) {
         p = 1;
       }
@@ -4645,7 +4727,7 @@ var Distributions = {
       if (p == 0.5) {
         return 0;
       }
-      let x = Distributions.Beta.inv(2 * Math.min(p, 1 - p), 0.5 * df, 0.5);
+      var x = Beta.invInc(2 * Math.min(p, 1 - p), 0.5 * df, 0.5);
       x = Math.sqrt(df * (1 - x) / x);
       return p > 0.5 ? x : -x;
     }
@@ -5178,9 +5260,7 @@ var ANOVA = {
       let pooledSTD = StDev.Pooled(pooledData);
       let alphaADJ = (1 - Math.pow(1 - alpha, 1 / rCount)) / 2;
       let hAlpha = Math.abs(Distributions.T.inv(alphaADJ, grandArray.length - rCount));
-      console.log({ alphaADJ, ln: grandArray.length, rCount });
       let scaleDF = Math.sqrt((rCount - 1) / (rCount * tCount));
-      console.log({ grandMean, pooledSTD, hAlpha, scaleDF });
       let UDL = grandMean + pooledSTD * hAlpha * scaleDF;
       let LDL = grandMean - pooledSTD * hAlpha * scaleDF;
       let chartSettings = new ChartSettings();
@@ -5205,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: {
@@ -7446,7 +7630,7 @@ var EquivalenceTesting = {
     let mean = Mean(dta);
     let se = StandardError(dta);
     let LSL = multiply ? lowerSpecification * target : lowerSpecification;
-    let USL = multiply ? upperSpecification * target : lowerSpecification;
+    let USL = multiply ? upperSpecification * target : upperSpecification;
     let diff = mean - target;
     let CI_Low = Math.min((LSL + USL) / 2, diff - Distributions.T.inv(1 - confidenceLevel, dta.length - 1) * se);
     let CI_High = Math.max((LSL + USL) / 2, diff + Distributions.T.inv(1 - confidenceLevel, dta.length - 1) * se);
@@ -7773,7 +7957,7 @@ var NonparametricTesting = {
     let avgOverallRank = Mean(combinedRanks);
     let N = combinedData.length;
     let zValues = avgRanks.map((Rj, j) => {
-      return (Rj - avgOverallRank) / Math.sqrt((N + 1) * (N / data[j].length - 1) / 12);
+      return (Rj - avgOverallRank) / Math.sqrt((N + 1) * (N / extractedData[j].length - 1) / 12);
     });
     let tieSets = CompileTies(combinedData);
     let adjustH = tieSets.length > 0;
@@ -11230,11 +11414,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);
@@ -11825,7 +12012,6 @@ function GageLinearityAndBias(parts, referenceValues, responses, processVariatio
       let \u03C3B2 = \u03C3R2 / Math.sqrt(m);
       let t2 = avgBias3 / \u03C3B2;
       let p2 = Distributions.T.cdf(-Math.abs(t2), df2) + (1 - Distributions.T.cdf(Math.abs(t2), df2));
-      console.log({ t: t2, df: df2, \u03C3B: \u03C3B2, \u03C3R: \u03C3R2, m, rBar: rBar2, d2: d22 });
       partBiasObjects.push({
         ReferenceValue: ref,
         Bias: avgBias3,

package/index.ts

@@ -1080,7 +1080,6 @@ CI:{
 */
 Cp(data: number[], spec: Specification, subgroupSize: number = 1, method?: string, w?: number, UnbiasingConstant: boolean = true){      
   let standarddeviation = StDev.W(data, subgroupSize, method, w, UnbiasingConstant);
-  console.log({StDevW: standarddeviation})
   if(!Number.isNaN(spec.USL) && !Number.isNaN(spec.LSL)){
     return Number((spec.USL - spec.LSL) / (6 * standarddeviation));
   }else{
@@ -1333,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);
@@ -1899,28 +1899,39 @@ export const Beta = {
   * @param a The first shape parameter; x^(a-1).
   * @param b The second shape parameter; (1 - x)^(b-1). 
   */
-  inc(x: number, a: number, b: number){
-    // let sum = 0;
-
-    // for(let n = 0; n < 1000; n++){
-    //   let ploc = PlochhammerSymbol(1-b, n);
-    //   let den = Probability.Factorialize(n) * (a + n);
-    //   let xn = Math.pow(x, n);
-    //   let term_n = ploc / den * xn;
-    //   if(Math.abs(term_n) < 1e-9 && n > 100){
-    //     n = 1001
-    //   }
-    //   sum += term_n;
-    // }
-    // return Math.pow(x, a) * sum;
-    
+  inc(X: number, A: number, B: number){
+    var A0=0;
+    var B0=1;
+    var A1=1;
+    var B1=1;
+    var M9=0;
+    var A2=0;
+    var C9;
+    while (Math.abs((A1-A2)/A1)>.00001) {
+      A2=A1;
+      C9=-(A+M9)*(A+B+M9)*X/(A+2*M9)/(A+2*M9+1);
+      A0=A1+C9*A0;
+      B0=B1+C9*B0;
+      M9=M9+1;
+      C9=M9*(B-M9)*X/(A+2*M9-1)/(A+2*M9);
+      A1=A0+C9*A1;
+      B1=B0+C9*B1;
+      A0=A0/B1;
+      B0=B0/B1;
+      A1=A1/B1;
+      B1=1;
+    }
+    return A1/A
+
+  },
+  incomplete(x, a, b): any{
     // Factors in front of the continued fraction.
     var bt = (x === 0 || x === 1) ?  0 :
       Math.exp(Gamma.ln(a + b) - Gamma.ln(a) -
-               Gamma.ln(b) + a * Math.log(x) + b *
+      Gamma.ln(b) + a * Math.log(x) + b *
                Math.log(1 - x));
     if (x < 0 || x > 1)
-      return NaN;
+      return false;
     if (x < (a + 1) / (a + b + 2))
       // Use continued fraction directly.
       return bt * Beta.cf(x, a, b) / a;
@@ -1936,7 +1947,56 @@ export const Beta = {
   */
   incr(x: number, a: number, b: number){
     return Beta.inc(x, a, b)/Beta.fn(a, b)
-  }
+  },
+  invInc(p, a, b){
+    var EPS = 1e-8;
+    var a1 = a - 1;
+    var b1 = b - 1;
+    var j = 0;
+    var lna, lnb, pp, t, u, err, x, al, h, w, afac;
+    if (p <= 0)
+      return 0;
+    if (p >= 1)
+      return 1;
+    if (a >= 1 && b >= 1) {
+      pp = (p < 0.5) ? p : 1 - p;
+      t = Math.sqrt(-2 * Math.log(pp));
+      x = (2.30753 + t * 0.27061) / (1 + t* (0.99229 + t * 0.04481)) - t;
+      if (p < 0.5)
+        x = -x;
+      al = (x * x - 3) / 6;
+      h = 2 / (1 / (2 * a - 1)  + 1 / (2 * b - 1));
+      w = (x * Math.sqrt(al + h) / h) - (1 / (2 * b - 1) - 1 / (2 * a - 1)) *
+          (al + 5 / 6 - 2 / (3 * h));
+      x = a / (a + b * Math.exp(2 * w));
+    } else {
+      lna = Math.log(a / (a + b));
+      lnb = Math.log(b / (a + b));
+      t = Math.exp(a * lna) / a;
+      u = Math.exp(b * lnb) / b;
+      w = t + u;
+      if (p < t / w)
+        x = Math.pow(a * w * p, 1 / a);
+      else
+        x = 1 - Math.pow(b * w * (1 - p), 1 / b);
+    }
+    afac = -Gamma.ln(a) - Gamma.ln(b) + Gamma.ln(a + b);
+    for(; j < 10; j++) {
+      if (x === 0 || x === 1)
+        return x;
+      err = Beta.incomplete(x, a, b) - p;
+      t = Math.exp(a1 * Math.log(x) + b1 * Math.log(1 - x) + afac);
+      u = err / t;
+      x -= (t = u / (1 - 0.5 * Math.min(1, u * (a1 / x - b1 / (1 - x)))));
+      if (x <= 0)
+        x = 0.5 * (x + t);
+      if (x >= 1)
+        x = 0.5 * (x + t + 1);
+      if (Math.abs(t) < EPS * x && j > 0)
+        break;
+    }
+    return x;
+    }
 }
 
 export const ERF = {  
@@ -2136,7 +2196,18 @@ export const Distributions = {
     * @param b The second shape parameter; (1 - x)^(b-1). 
     */
     cdf(x: number, a: number, b: number){
-      return Beta.incr(x, a, b);
+      var S;
+      var BT;
+      var Bcdf;
+      
+      S = a + b;
+      BT = Math.exp(Gamma.ln(S) - Gamma.ln(b) - Gamma.ln(a) + a * Math.log(x) + b * Math.log(1 - x));
+      if (x < (a + 1)/(S + 2)) {
+        Bcdf = BT * Beta.inc(x, a, b)
+      } else {
+        Bcdf = 1 - BT * Beta.inc(1 - x, b, a)
+      }
+      return Bcdf
     },
     /**
     * Probability Density Function. Calculates the probability of random variable x occuring from the beta distribution with the specified shape parameters a and b.
@@ -4011,8 +4082,8 @@ export const Distributions = {
     * @returns the Right-Tailed P-Value of the F Distribution
     */
     cdf(x: number, df1: number, df2: number){
-      let subX = (df1 * x)/(df1 * x + df2);
-      let p = Beta.incr(subX, df1/2, df2/2);
+      let z = x / (x + df2/df1)
+      let p = Distributions.Beta.cdf(z, df1/2, df2/2)
       if(p > 1){p = 1}
       if(p < 0){p = 0}
       return p
@@ -4943,9 +5014,9 @@ export const Distributions = {
       // if(t){
       //   return t
       // } 
-      let x = Distributions.Beta.inv(2*Math.min(p, 1-p), 0.5*df, 0.5);
-      x = Math.sqrt(df*(1-x)/x);
-      return p > 0.5 ? x : -x;
+      var x = Beta.invInc(2 * Math.min(p, 1 - p), 0.5 * df, 0.5);
+      x = Math.sqrt(df * (1 - x) / x);
+      return (p > 0.5) ? x : -x;
     },
     // invTable(p: number, df: number){
     //   // let table = tTable
@@ -5583,10 +5654,9 @@ export const ANOVA = {
       let pooledSTD = StDev.Pooled(pooledData);
       let alphaADJ = (1 - Math.pow(1-alpha,1/rCount))/2;
       let hAlpha = Math.abs(Distributions.T.inv(alphaADJ, grandArray.length - rCount))
-      console.log({alphaADJ, ln: grandArray.length, rCount})
+      
       let scaleDF = Math.sqrt((rCount-1)/(rCount*tCount));
       
-      console.log({grandMean, pooledSTD, hAlpha, scaleDF})
       let UDL = grandMean + pooledSTD*hAlpha*scaleDF
       let LDL = grandMean - pooledSTD*hAlpha*scaleDF
 
@@ -5614,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){
 
   },
@@ -6829,10 +6996,10 @@ export const ANOVA = {
             refMeanIndex += fx_i * prod
           })
           let refMean = refMeans[refMeanIndex]
-
+          
           SumSq += Math.pow(levelMean - refMeans[refMeanIndex], 2);
         })
-
+        
         ANOVA[fi].SS = abc * SumSq;
         ANOVA[fi].MS = ANOVA[fi].SS/ANOVA[fi].DF
       })
@@ -6841,6 +7008,7 @@ export const ANOVA = {
       factors.forEach((factor, factor_i) => {
         if(factor_i != factors.length - 1){
           ANOVA[factor_i].F = ANOVA[factor_i].MS / ANOVA[factor_i + 1].MS
+          
           ANOVA[factor_i].p = Distributions.F.RightTail(ANOVA[factor_i].F, ANOVA[factor_i].DF, ANOVA[factor_i + 1].DF)
         }
       })
@@ -7944,11 +8112,11 @@ export const EquivalenceTesting = {
     let mean = Mean(dta)
     let se = StandardError(dta)
     let LSL = multiply ? lowerSpecification * target : lowerSpecification
-    let USL = multiply ? upperSpecification * target : lowerSpecification
+    let USL = multiply ? upperSpecification * target : upperSpecification
     let diff = mean - target;
 
     let CI_Low = Math.min((LSL + USL)/2, diff - Distributions.T.inv(1 - confidenceLevel, dta.length - 1)*se);
-    let CI_High = Math.max((LSL + USL)/2, diff + Distributions.T.inv(1 - confidenceLevel, dta.length - 1)*se)
+    let CI_High = Math.max((LSL + USL)/2, diff + Distributions.T.inv(1 - confidenceLevel, dta.length - 1)*se);
 
     let equivChart = EquivalenceCharts.Equivalence({name: `Mean(${name ?? "Sample"})`, value: mean}, {name: "Target", value: target}, LSL, USL, CI_Low, CI_High, confidenceLevel);
     let histograms = EquivalenceCharts.Histogram([data])
@@ -8321,12 +8489,13 @@ export const NonparametricTesting = {
     let avgOverallRank = Mean(combinedRanks);
 
     let N = combinedData.length;
-    let zValues = avgRanks.map((Rj, j) => {return (Rj - avgOverallRank)/Math.sqrt(((N + 1)*(N/data[j].length - 1))/12)})
-  
+    let zValues = avgRanks.map((Rj, j) => {return (Rj - avgOverallRank)/Math.sqrt(((N + 1)*(N/extractedData[j].length - 1))/12)})
+    
     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_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);
@@ -12181,11 +12350,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));
@@ -12840,7 +13012,7 @@ export function GageLinearityAndBias(parts: any[], referenceValues: number[], re
       let σB = σR / Math.sqrt(m);
       let t = avgBias / σB
       let p = Distributions.T.cdf(-Math.abs(t), df) + (1 - Distributions.T.cdf(Math.abs(t), df))
-      console.log({t, df, σB, σR, m, rBar, d2});
+      
       partBiasObjects.push({
         ReferenceValue: ref,
         Bias: avgBias,
@@ -13889,5 +14061,4 @@ const Matrix = {
     return newMatrix
   },
 }
-// End Matrix Functions
-/** ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ *///  Validation
+// End Matrix Functions

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "qesuite",
-  "version": "1.0.65",
+  "version": "1.0.68",
   "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_67.md

@@ -0,0 +1 @@
+- Updated T.Inv()

package/versions/1_0_68.md

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