@dreamforgestudiollc/emet 0.2.4 → 0.2.6

package/gems/lean-six-sigma/runes/lss_control_limits.js

@@ -0,0 +1,240 @@
+// Pure function of the caller's inputs. Returns numbers. Writes nothing.
+// Factor table: NIST/SEMATECH e-Handbook 6.3.2.1, D4 for n = 5 is 2.115.
+// Floor only R, moving range, p, np, c, and u. X-bar and individuals stay negative.
+
+const MISSING = "missing-input";
+const ASSUMPTION = "assumption-not-checked";
+const FLOOR = "lcl-floored-at-zero";
+const FACTOR = "factor-out-of-range";
+
+const FACTORS = Object.freeze({
+  __proto__: null,
+  2: Object.freeze({ __proto__: null, a2: 1.88, d3: 0, d4: 3.267 }),
+  3: Object.freeze({ __proto__: null, a2: 1.023, d3: 0, d4: 2.575 }),
+  4: Object.freeze({ __proto__: null, a2: 0.729, d3: 0, d4: 2.282 }),
+  5: Object.freeze({ __proto__: null, a2: 0.577, d3: 0, d4: 2.115 }),
+  6: Object.freeze({ __proto__: null, a2: 0.483, d3: 0, d4: 2.004 }),
+  7: Object.freeze({ __proto__: null, a2: 0.419, d3: 0.076, d4: 1.924 }),
+  8: Object.freeze({ __proto__: null, a2: 0.373, d3: 0.136, d4: 1.864 }),
+  9: Object.freeze({ __proto__: null, a2: 0.337, d3: 0.184, d4: 1.816 }),
+  10: Object.freeze({ __proto__: null, a2: 0.308, d3: 0.223, d4: 1.777 }),
+});
+
+const CHARTS = Object.freeze({
+  __proto__: null,
+  "xbar-r": true,
+  "i-mr": true,
+  p: true,
+  np: true,
+  c: true,
+  u: true,
+});
+
+function isNum(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+
+function push(flags, flag) {
+  if (flag && flags.indexOf(flag) < 0) flags.push(flag);
+}
+
+function empty(flags, missing, error) {
+  return {
+    ok: false,
+    flags,
+    missing,
+    wrote: false,
+    error,
+    center: null,
+    ucl: null,
+    lcl: null,
+    centerR: null,
+    uclR: null,
+    lclR: null,
+    constantsUsed: null,
+  };
+}
+
+function fail(flags, missing, error) {
+  if (missing.length) push(flags, MISSING);
+  return empty(flags, missing, error);
+}
+
+function floorAtZero(value, flags) {
+  if (value < 0) {
+    push(flags, FLOOR);
+    return 0;
+  }
+  return value;
+}
+
+function constantsFrom(input, missing) {
+  const hasA2 = isNum(input.a2);
+  const hasD3 = isNum(input.d3);
+  const hasD4 = isNum(input.d4);
+  const any = hasA2 || hasD3 || hasD4;
+  if (any) {
+    if (!hasA2) missing.push("a2");
+    if (!hasD3) missing.push("d3");
+    if (!hasD4) missing.push("d4");
+    if (missing.length) return null;
+    return { a2: input.a2, d3: input.d3, d4: input.d4, fromTable: false };
+  }
+  if (!isNum(input.n) || !Number.isInteger(input.n)) return false;
+  const key = String(input.n);
+  if (!Object.hasOwn(FACTORS, key)) return false;
+  return { a2: FACTORS[key].a2, d3: FACTORS[key].d3, d4: FACTORS[key].d4, fromTable: true };
+}
+
+export function run(input) {
+  const flags = [];
+  const missing = [];
+  if (input === null || typeof input !== "object" || Array.isArray(input)) {
+    missing.push("chart");
+    return fail(flags, missing, "Missing chart.");
+  }
+  const chart = String(input.chart);
+  if (!Object.hasOwn(CHARTS, chart)) {
+    missing.push("chart");
+    return fail(flags, missing, "Missing chart.");
+  }
+
+  if (chart === "xbar-r") {
+    if (!isNum(input.xDoubleBar)) missing.push("xDoubleBar");
+    if (!isNum(input.rBar)) missing.push("rBar");
+    const constants = constantsFrom(input, missing);
+    if (constants === false) {
+      if (isNum(input.n)) push(flags, FACTOR);
+      else missing.push("n");
+      const error = isNum(input.n)
+        ? "Subgroup size is outside the factor table."
+        : "Missing " + missing.join(", ") + ".";
+      return fail(flags, missing, error);
+    }
+    if (missing.length || constants === null) {
+      return fail(flags, missing, "Missing " + missing.join(", ") + ".");
+    }
+    if (!(input.rBar >= 0)) {
+      missing.push("rBar");
+      return fail(flags, missing, "rBar must be greater than or equal to 0.");
+    }
+    const span = constants.a2 * input.rBar;
+    push(flags, ASSUMPTION);
+    return {
+      ok: true,
+      flags,
+      missing,
+      wrote: false,
+      error: null,
+      center: input.xDoubleBar,
+      ucl: input.xDoubleBar + span,
+      lcl: input.xDoubleBar - span,
+      centerR: input.rBar,
+      uclR: constants.d4 * input.rBar,
+      lclR: floorAtZero(constants.d3 * input.rBar, flags),
+      constantsUsed: constants,
+    };
+  }
+
+  if (chart === "i-mr") {
+    if (!isNum(input.xBar)) missing.push("xBar");
+    if (!isNum(input.mrBar)) missing.push("mrBar");
+    if (missing.length) {
+      return fail(flags, missing, "Missing " + missing.join(", ") + ".");
+    }
+    if (!(input.mrBar >= 0)) {
+      missing.push("mrBar");
+      return fail(flags, missing, "mrBar must be greater than or equal to 0.");
+    }
+    const half = (3 * input.mrBar) / 1.128;
+    const constants = { d2: 1.128, d4: 3.267, fromTable: true };
+    push(flags, ASSUMPTION);
+    return {
+      ok: true,
+      flags,
+      missing,
+      wrote: false,
+      error: null,
+      center: input.xBar,
+      ucl: input.xBar + half,
+      lcl: input.xBar - half,
+      centerR: input.mrBar,
+      uclR: 3.267 * input.mrBar,
+      lclR: 0,
+      constantsUsed: constants,
+    };
+  }
+
+  if (chart === "c") {
+    if (!isNum(input.cBar)) {
+      missing.push("cBar");
+      return fail(flags, missing, "Missing cBar.");
+    }
+    if (!(input.cBar >= 0)) {
+      missing.push("cBar");
+      return fail(flags, missing, "cBar must be greater than or equal to 0.");
+    }
+    const band = 3 * Math.sqrt(input.cBar);
+    push(flags, ASSUMPTION);
+    return {
+      ok: true,
+      flags,
+      missing,
+      wrote: false,
+      error: null,
+      center: input.cBar,
+      ucl: input.cBar + band,
+      lcl: floorAtZero(input.cBar - band, flags),
+      centerR: null,
+      uclR: null,
+      lclR: null,
+      constantsUsed: null,
+    };
+  }
+
+  if (!isNum(input.n) || !(input.n > 0)) missing.push("n");
+  if (chart === "u") {
+    if (!isNum(input.uBar)) missing.push("uBar");
+  } else if (!isNum(input.pBar)) {
+    missing.push("pBar");
+  }
+  if (missing.length) {
+    return fail(flags, missing, "Missing " + missing.join(", ") + ".");
+  }
+  if (chart !== "u" && (input.pBar < 0 || input.pBar > 1)) {
+    missing.push("pBar");
+    return fail(flags, missing, "pBar must be between 0 and 1.");
+  }
+  if (chart === "u" && !(input.uBar >= 0)) {
+    missing.push("uBar");
+    return fail(flags, missing, "uBar must be greater than or equal to 0.");
+  }
+
+  let center = null;
+  let band = null;
+  if (chart === "p") {
+    center = input.pBar;
+    band = 3 * Math.sqrt((input.pBar * (1 - input.pBar)) / input.n);
+  } else if (chart === "np") {
+    center = input.n * input.pBar;
+    band = 3 * Math.sqrt(input.n * input.pBar * (1 - input.pBar));
+  } else {
+    center = input.uBar;
+    band = 3 * Math.sqrt(input.uBar / input.n);
+  }
+  push(flags, ASSUMPTION);
+  return {
+    ok: true,
+    flags,
+    missing,
+    wrote: false,
+    error: null,
+    center,
+    ucl: center + band,
+    lcl: floorAtZero(center - band, flags),
+    centerR: null,
+    uclR: null,
+    lclR: null,
+    constantsUsed: null,
+  };
+}

package/gems/lean-six-sigma/runes/lss_dpmo_sigma.js

@@ -0,0 +1,81 @@
+// Pure function of the caller's inputs. Returns numbers. Writes nothing.
+
+const MISSING = "missing-input";
+const SIGMA = "sigma-not-computed";
+
+function isNum(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+
+function push(flags, flag) {
+  if (flag && flags.indexOf(flag) < 0) flags.push(flag);
+}
+
+function blank(flags, missing, error) {
+  return {
+    ok: false,
+    flags,
+    missing,
+    wrote: false,
+    error,
+    dpo: null,
+    dpmo: null,
+    opportunityYield: null,
+  };
+}
+
+function fail(flags, missing, error) {
+  if (missing.length) push(flags, MISSING);
+  return blank(flags, missing, error);
+}
+
+export function run(input) {
+  const flags = [];
+  const missing = [];
+  if (input === null || typeof input !== "object" || Array.isArray(input)) {
+    missing.push("defects", "units", "opportunitiesPerUnit");
+    return fail(flags, missing, "Missing defects, units, opportunitiesPerUnit.");
+  }
+
+  if (!isNum(input.defects)) missing.push("defects");
+  if (!isNum(input.units)) missing.push("units");
+  if (!isNum(input.opportunitiesPerUnit)) missing.push("opportunitiesPerUnit");
+  if (missing.length) {
+    return fail(flags, missing, "Missing " + missing.join(", ") + ".");
+  }
+
+  const problems = [];
+  if (!(input.defects >= 0)) {
+    missing.push("defects");
+    problems.push("defects must be greater than or equal to 0");
+  }
+  if (!(input.units > 0)) {
+    missing.push("units");
+    problems.push("units must be greater than 0");
+  }
+  if (!(input.opportunitiesPerUnit > 0)) {
+    missing.push("opportunitiesPerUnit");
+    problems.push("opportunities per unit must be greater than 0");
+  }
+  if (problems.length) {
+    return fail(flags, missing, problems.join(". ") + ".");
+  }
+
+  const dpo = input.defects / (input.units * input.opportunitiesPerUnit);
+  const opportunityYield = 1 - dpo;
+  if (opportunityYield < 0 || opportunityYield > 1) {
+    return fail(flags, [], "Opportunity yield is outside 0 to 1.");
+  }
+
+  push(flags, SIGMA);
+  return {
+    ok: true,
+    flags,
+    missing,
+    wrote: false,
+    error: null,
+    dpo,
+    dpmo: dpo * 1000000,
+    opportunityYield,
+  };
+}

package/gems/lean-six-sigma/runes/lss_hypothesis.js

@@ -0,0 +1,298 @@
+// Pure function of the caller's inputs. Returns numbers. Writes nothing.
+// This version does not return a p-value.
+
+const MISSING = "missing-input";
+const ASSUMPTION = "assumption-not-checked";
+const SMALL = "small-n";
+const ZERO = "zero-variance";
+
+const TESTS = Object.freeze({
+  __proto__: null,
+  "one-sample-t": true,
+  "chi-square-gof": true,
+  "anova-oneway": true,
+  "simple-regression": true,
+  "z-interval": true,
+  "t-interval": true,
+});
+
+function isNum(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+
+function push(flags, flag) {
+  if (flag && flags.indexOf(flag) < 0) flags.push(flag);
+}
+
+function shell(flags, missing, ok, error) {
+  return {
+    ok,
+    flags,
+    missing,
+    wrote: false,
+    error,
+    t: null,
+    df: null,
+    exceedsCritical: null,
+    chiSquare: null,
+    grandMean: null,
+    groupMeans: null,
+    ssb: null,
+    ssw: null,
+    msb: null,
+    msw: null,
+    f: null,
+    dfBetween: null,
+    dfWithin: null,
+    slope: null,
+    intercept: null,
+    r2: null,
+    low: null,
+    high: null,
+  };
+}
+
+function refuse(flags, missing, error) {
+  if (missing.length) push(flags, MISSING);
+  return shell(flags, missing, false, error);
+}
+
+function nums(list) {
+  return Array.isArray(list) && list.length > 0 && list.every(isNum);
+}
+
+function sampleN(input, missing) {
+  if (!Number.isInteger(input.n) || !(input.n >= 2)) {
+    missing.push("n");
+    return false;
+  }
+  return true;
+}
+
+export function run(input) {
+  const flags = [];
+  const missing = [];
+  if (input === null || typeof input !== "object" || Array.isArray(input)) {
+    missing.push("test");
+    return refuse(flags, missing, "Missing test.");
+  }
+  const test = String(input.test);
+  if (!Object.hasOwn(TESTS, test)) {
+    missing.push("test");
+    return refuse(flags, missing, "Missing test.");
+  }
+
+  if (test === "one-sample-t") {
+    if (!isNum(input.xBar)) missing.push("xBar");
+    if (!isNum(input.mu0)) missing.push("mu0");
+    if (!isNum(input.s)) missing.push("s");
+    if (!isNum(input.n)) missing.push("n");
+    if (missing.length) {
+      return refuse(flags, missing, "Missing " + missing.join(", ") + ".");
+    }
+    if (!(input.s > 0)) {
+      missing.push("s");
+      return refuse(flags, missing, "s must be greater than 0.");
+    }
+    if (!sampleN(input, missing)) {
+      return refuse(flags, missing, "n must be an integer of 2 or more.");
+    }
+    const t = (input.xBar - input.mu0) / (input.s / Math.sqrt(input.n));
+    const df = input.n - 1;
+    let exceedsCritical = null;
+    if (Object.hasOwn(input, "tCrit")) {
+      if (!isNum(input.tCrit)) {
+        missing.push("tCrit");
+        return refuse(flags, missing, "Missing tCrit.");
+      }
+      exceedsCritical = Math.abs(t) > input.tCrit;
+    }
+    push(flags, ASSUMPTION);
+    return {
+      ...shell(flags, missing, true, null),
+      t,
+      df,
+      exceedsCritical,
+    };
+  }
+
+  if (test === "chi-square-gof") {
+    if (!nums(input.observed)) missing.push("observed");
+    if (!nums(input.expected)) missing.push("expected");
+    if (!isNum(input.parametersEstimated)) missing.push("parametersEstimated");
+    if (missing.length) {
+      return refuse(flags, missing, "Missing " + missing.join(", ") + ".");
+    }
+    if (input.observed.length !== input.expected.length) {
+      missing.push("expected");
+      return refuse(flags, missing, "observed and expected must be the same length.");
+    }
+    if (input.expected.some((value) => !(value > 0))) {
+      missing.push("expected");
+      return refuse(flags, missing, "Each expected count must be greater than 0.");
+    }
+    const df = input.observed.length - 1 - input.parametersEstimated;
+    if (!(df > 0)) {
+      return refuse(flags, missing, "Degrees of freedom must be greater than 0.");
+    }
+    let chi = 0;
+    for (let i = 0; i < input.observed.length; i += 1) {
+      const observed = input.observed.at(i);
+      const expected = input.expected.at(i);
+      const diff = observed - expected;
+      chi += (diff * diff) / expected;
+    }
+    push(flags, ASSUMPTION);
+    return {
+      ...shell(flags, missing, true, null),
+      df,
+      chiSquare: chi,
+    };
+  }
+
+  if (test === "anova-oneway") {
+    const groups = input.groups;
+    if (!Array.isArray(groups) || groups.length < 2 || !groups.every(nums)) {
+      missing.push("groups");
+      return refuse(flags, missing, "Missing groups.");
+    }
+    const flat = groups.flat();
+    const grand = flat.reduce((sum, value) => sum + value, 0) / flat.length;
+    const means = groups.map((group) => group.reduce((sum, value) => sum + value, 0) / group.length);
+    let ssb = 0;
+    let ssw = 0;
+    groups.forEach((group, index) => {
+      const mean = means.at(index);
+      ssb += group.length * (mean - grand) * (mean - grand);
+      group.forEach((value) => {
+        ssw += (value - mean) * (value - mean);
+      });
+    });
+    const dfBetween = groups.length - 1;
+    const dfWithin = flat.length - groups.length;
+    let ok = dfWithin > 0;
+    let error = null;
+    let msb = null;
+    let msw = null;
+    let f = null;
+    if (!(dfWithin > 0)) {
+      push(flags, ZERO);
+      ok = false;
+      error = "Degrees of freedom must be greater than 0.";
+    } else {
+      msb = ssb / dfBetween;
+      msw = ssw / dfWithin;
+      f = msw === 0 ? null : msb / msw;
+      if (msw === 0) {
+        push(flags, ZERO);
+        ok = false;
+        error = "Mean square within is 0.";
+      }
+      if (ok) push(flags, ASSUMPTION);
+    }
+    return {
+      ...shell(flags, missing, ok, error),
+      grandMean: grand,
+      groupMeans: means,
+      ssb,
+      ssw,
+      msb,
+      msw,
+      f,
+      dfBetween,
+      dfWithin,
+    };
+  }
+
+  if (test === "simple-regression") {
+    if (!nums(input.x)) missing.push("x");
+    if (!nums(input.y)) missing.push("y");
+    if (missing.length) {
+      return refuse(flags, missing, "Missing " + missing.join(", ") + ".");
+    }
+    if (input.x.length !== input.y.length) {
+      missing.push("y");
+      return refuse(flags, missing, "x and y must be the same length.");
+    }
+    const n = input.x.length;
+    const xBar = input.x.reduce((sum, value) => sum + value, 0) / n;
+    const yBar = input.y.reduce((sum, value) => sum + value, 0) / n;
+    let num = 0;
+    let den = 0;
+    let tss = 0;
+    for (let i = 0; i < n; i += 1) {
+      const dx = input.x.at(i) - xBar;
+      const y = input.y.at(i);
+      num += dx * (y - yBar);
+      den += dx * dx;
+      const dy = y - yBar;
+      tss += dy * dy;
+    }
+    if (den === 0) {
+      push(flags, ZERO);
+      return shell(flags, missing, false, "The x values have no spread.");
+    }
+    const slope = num / den;
+    const intercept = yBar - slope * xBar;
+    let rss = 0;
+    for (let i = 0; i < n; i += 1) {
+      const residual = input.y.at(i) - (intercept + slope * input.x.at(i));
+      rss += residual * residual;
+    }
+    const r2 = tss === 0 ? 1 : 1 - rss / tss;
+    if (n < 3) push(flags, SMALL);
+    push(flags, ASSUMPTION);
+    return {
+      ...shell(flags, missing, true, null),
+      slope,
+      intercept,
+      r2,
+    };
+  }
+
+  if (test === "z-interval") {
+    if (!isNum(input.xBar)) missing.push("xBar");
+    if (!isNum(input.sigma)) missing.push("sigma");
+    if (!isNum(input.n)) missing.push("n");
+    if (!isNum(input.z)) missing.push("z");
+    if (missing.length) {
+      return refuse(flags, missing, "Missing " + missing.join(", ") + ".");
+    }
+    if (!(input.sigma > 0)) {
+      missing.push("sigma");
+      return refuse(flags, missing, "sigma must be greater than 0.");
+    }
+    if (!sampleN(input, missing)) {
+      return refuse(flags, missing, "n must be an integer of 2 or more.");
+    }
+    const margin = input.z * (input.sigma / Math.sqrt(input.n));
+    push(flags, ASSUMPTION);
+    return {
+      ...shell(flags, missing, true, null),
+      low: input.xBar - margin,
+      high: input.xBar + margin,
+    };
+  }
+
+  if (!isNum(input.xBar)) missing.push("xBar");
+  if (!isNum(input.s)) missing.push("s");
+  if (!isNum(input.n)) missing.push("n");
+  if (!isNum(input.tCrit)) missing.push("tCrit");
+  if (missing.length) {
+    return refuse(flags, missing, "Missing " + missing.join(", ") + ".");
+  }
+  if (!(input.s > 0)) {
+    missing.push("s");
+    return refuse(flags, missing, "s must be greater than 0.");
+  }
+  if (!sampleN(input, missing)) {
+    return refuse(flags, missing, "n must be an integer of 2 or more.");
+  }
+  const margin = input.tCrit * (input.s / Math.sqrt(input.n));
+  push(flags, ASSUMPTION);
+  return {
+    ...shell(flags, missing, true, null),
+    low: input.xBar - margin,
+    high: input.xBar + margin,
+  };
+}

package/gems/lean-six-sigma/runes/lss_sample_size.js

@@ -0,0 +1,81 @@
+// Pure function of the caller's inputs. Returns numbers. Writes nothing.
+
+const MISSING = "missing-input";
+const ASSUMPTION = "assumption-not-checked";
+
+function isNum(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+
+function push(flags, flag) {
+  if (flag && flags.indexOf(flag) < 0) flags.push(flag);
+}
+
+function ceilToInt(value) {
+  const nearest = Math.round(value);
+  if (Math.abs(value - nearest) < 1e-9) return nearest;
+  return Math.ceil(value);
+}
+
+function blank(flags, missing, error) {
+  return {
+    ok: false,
+    flags,
+    missing,
+    wrote: false,
+    error,
+    n: null,
+    marginOfError: false,
+  };
+}
+
+function fail(flags, missing, error) {
+  if (missing.length) push(flags, MISSING);
+  return blank(flags, missing, error);
+}
+
+export function run(input) {
+  const flags = [];
+  const missing = [];
+  if (input === null || typeof input !== "object" || Array.isArray(input)) {
+    missing.push("kind", "z", "e");
+    return fail(flags, missing, "Missing kind, z, e.");
+  }
+  if (input.kind !== "proportion" && input.kind !== "mean") missing.push("kind");
+  if (!isNum(input.z)) missing.push("z");
+  if (!isNum(input.e)) missing.push("e");
+  if (missing.length) {
+    return fail(flags, missing, "Missing " + missing.join(", ") + ".");
+  }
+  if (!(input.e > 0)) {
+    missing.push("e");
+    return fail(flags, missing, "e must be greater than 0.");
+  }
+
+  let raw = null;
+  if (input.kind === "proportion") {
+    if (!isNum(input.p) || input.p < 0 || input.p > 1) {
+      missing.push("p");
+      return fail(flags, missing, "p must be between 0 and 1.");
+    }
+    raw = (input.z * input.z * input.p * (1 - input.p)) / (input.e * input.e);
+  } else {
+    if (!isNum(input.sigma) || !(input.sigma > 0)) {
+      missing.push("sigma");
+      return fail(flags, missing, "sigma must be greater than 0.");
+    }
+    const ratio = (input.z * input.sigma) / input.e;
+    raw = ratio * ratio;
+  }
+
+  push(flags, ASSUMPTION);
+  return {
+    ok: true,
+    flags,
+    missing,
+    wrote: false,
+    error: null,
+    n: ceilToInt(raw),
+    marginOfError: true,
+  };
+}