@milaboratories/miplots4 1.0.123 → 1.0.125

package/dist/discrete/layers/stats/MannWhitneyU.js

@@ -0,0 +1,149 @@
+var P = Object.defineProperty;
+var w = (i, t, e) => t in i ? P(i, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : i[t] = e;
+var f = (i, t, e) => w(i, typeof t != "symbol" ? t + "" : t, e);
+import m from "../../../node_modules/lodash/lodash.js";
+function U(i) {
+  const t = Math.abs(i), e = 1 / (1 + t / 2), n = e * Math.exp(-t * t - 1.26551223 + e * (1.00002368 + e * (0.37409196 + e * (0.09678418 + e * (-0.18628806 + e * (0.27886807 + e * (-1.13520398 + e * (1.48851587 + e * (-0.82215223 + e * 0.17087277)))))))));
+  return i >= 0 ? n : 2 - n;
+}
+function b(i) {
+  return 0.5 * U(-i / Math.sqrt(2));
+}
+class N {
+  constructor(t, e) {
+    this.value = t, this.position = e;
+  }
+  getValue() {
+    return this.value;
+  }
+  getPosition() {
+    return this.position;
+  }
+}
+function k(i) {
+  const t = new Array(i.length);
+  for (let s = 0; s < i.length; s++)
+    t[s] = new N(i[s], s);
+  const e = E(t);
+  t.sort((s, h) => s.getValue() - h.getValue());
+  const n = new Array(t.length);
+  let r = 1;
+  n[t[0].getPosition()] = r;
+  let o = [];
+  o.push(t[0].getPosition());
+  for (let s = 1; s < t.length; s++)
+    t[s].getValue() > t[s - 1].getValue() && (r = s + 1, o.length > 1 && p(n, o), o = []), o.push(t[s].getPosition()), n[t[s].getPosition()] = r;
+  return o.length > 1 && p(n, o), A(n, e), n;
+}
+function p(i, t) {
+  const n = (2 * i[t[0]] + t.length - 1) / 2;
+  t.forEach((r) => {
+    i[r] = n;
+  });
+}
+function A(i, t) {
+  t.forEach((e) => {
+    i[e] = NaN;
+  });
+}
+function E(i) {
+  const t = [];
+  for (let e = 0; e < i.length; e++)
+    isNaN(i[e].getValue()) && t.push(e);
+  return t;
+}
+class L {
+  constructor() {
+    f(this, "SMALL_SAMPLE_SIZE", 50);
+  }
+  mannWhitneyU(t, e) {
+    const n = [...t, ...e], r = k(n);
+    let o = 0;
+    for (let l = 0; l < t.length; l++)
+      o += r[l];
+    const s = o - t.length * (t.length + 1) / 2, h = t.length * e.length - s;
+    return Math.min(s, h);
+  }
+  mannWhitneyUTest(t, e, n) {
+    if (typeof n > "u")
+      return t.length + e.length <= this.SMALL_SAMPLE_SIZE && Object.keys(this.tiesMap(t, e)).length === 0 ? this.mannWhitneyUTest(t, e, !0) : this.mannWhitneyUTest(t, e, !1);
+    const r = this.tiesMap(t, e), o = this.mannWhitneyU(t, e);
+    if (n) {
+      if (Object.keys(r).length !== 0)
+        throw new Error();
+      return this.exactP(t.length, e.length, o);
+    }
+    return this.approximateP(
+      o,
+      t.length,
+      e.length,
+      this.varU(t.length, e.length, r)
+    );
+  }
+  approximateP(t, e, n, r) {
+    const o = e * n / 2;
+    if (o == t)
+      return 1;
+    const s = -Math.abs(t - o + 0.5) / Math.sqrt(r);
+    return 2 * b(s);
+  }
+  exactP(t, e, n) {
+    const r = e * t;
+    if (n > r)
+      return 1;
+    const o = n < r / 2 ? n : r / 2 - n;
+    let s = 0, h = 0;
+    for (; h <= o; )
+      s += this.uDensity(t, e, h), h++;
+    return 2 * s;
+  }
+  uDensity(t, e, n) {
+    if (n < 0 || n > e * t)
+      return 0;
+    const r = this.uFrequencies(t, e);
+    return r[Math.round(n + 1)] / m.sum(r);
+  }
+  uFrequencies(t, e) {
+    const n = Math.max(e, t);
+    if (n > 100)
+      throw Error("n or m > 100");
+    const r = Math.min(e, t), o = new Array(t * e + 2), s = new Array(t * e + 2);
+    for (let l = 1; l < o.length; l++)
+      o[l] = l <= n + 1 ? 1 : 0;
+    s[1] = 0;
+    let h = n;
+    for (let l = 2; l <= r; l++) {
+      s[l] = 0, h = h + n;
+      let u = h + 2;
+      const M = 1 + h / 2;
+      let g = l;
+      for (let a = 1; a <= M; a++) {
+        g++, u = u - 1;
+        const c = o[a] + s[a];
+        o[a] = c, s[g] = c - o[u], o[u] = c;
+      }
+    }
+    return o;
+  }
+  varU(t, e, n) {
+    const r = t * e;
+    if (Object.keys(n).length === 0)
+      return r * (t + e + 1) / 12;
+    const o = m.sum(Object.values(n).map((h) => h * h * h - h)), s = t + e;
+    return r / 12 * (s + 1 - o / (s * (s - 1)));
+  }
+  tiesMap(t, e) {
+    const n = {};
+    for (let r = 0; r < t.length; r++)
+      n[t[r]] = n[t[r]] ? n[t[r]] + 1 : 1;
+    for (let r = 0; r < e.length; r++)
+      n[e[r]] = n[e[r]] ? n[e[r]] + 1 : 1;
+    for (const r in n)
+      n[r] === 1 && delete n[r];
+    return n;
+  }
+}
+export {
+  L as MannWhitneyU
+};
+//# sourceMappingURL=MannWhitneyU.js.map

package/dist/discrete/layers/stats/MannWhitneyU.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MannWhitneyU.js","sources":["../../../../src/discrete/layers/stats/MannWhitneyU.ts"],"sourcesContent":["import lodash from 'lodash';\n\n// Normal distribution - complementary error function\n// https://en.wikipedia.org/wiki/Error_function#Complementary_error_function\n// https://github.com/errcw/gaussian/blob/master/lib/gaussian.js#L5\nfunction erfc(x:number):number {\n    const z = Math.abs(x);\n    const t = 1 / (1 + z / 2);\n    const r = t * Math.exp(-z * z - 1.26551223 + t * (1.00002368 +\n        t * (0.37409196 + t * (0.09678418 + t * (-0.18628806 +\n            t * (0.27886807 + t * (-1.13520398 + t * (1.48851587 +\n                t * (-0.82215223 + t * 0.17087277)))))))));\n    return x >= 0 ? r : 2 - r;\n}\n// Normal distribution - cumulative probability, for mean = 0, standardDeviation = 1\n// https://github.com/errcw/gaussian/blob/master/lib/gaussian.js#L54\nfunction standardNormalCumulativeProbability (x:number):number {\n    return 0.5 * erfc(-x / (Math.sqrt(2)));\n}\n\n// Natural ranking\n// https://github.com/apache/commons-math/blob/ece74cff78ae7858827f1913bb63854601d88c06/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/ranking/NaturalRanking.java#L195\nclass IntDoublePair {\n    constructor(private value:number, private position:number) {}\n    public getValue() {\n        return this.value;\n    }\n    public getPosition() {\n        return this.position;\n    }\n}\n// with NaNStrategy.FIXED, TiesStrategy.AVERAGE https://github.com/milaboratory/miplots/blob/559b13065f17dfc7c4dd332247dd1ce0183affcc/src/main/kotlin/com/milaboratory/miplots/stat/util/MannWhitneyU.kt#L36\nfunction rank(data:number[]) {\n    // Array recording initial positions of data to be ranked\n    const ranks:IntDoublePair[] = new Array(data.length);\n    for (let i = 0; i < data.length; i++) {\n        ranks[i] = new IntDoublePair(data[i], i);\n    }\n\n    // Recode, remove or record positions of NaNs\n    const nanPositions = getNanPositions(ranks);\n    // Sort the IntDoublePairs\n    ranks.sort((a, b) => a.getValue() - b.getValue());\n\n    // Walk the sorted array, filling output array using sorted positions,\n    // resolving ties as we go\n    const out:number[] = new Array(ranks.length);\n    let pos = 1;  // position in sorted array\n    out[ranks[0].getPosition()] = pos;\n    let tiesTrace = [];\n    tiesTrace.push(ranks[0].getPosition());\n\n    for (let i = 1; i < ranks.length; i++) {\n        if (ranks[i].getValue() > ranks[i - 1].getValue()) {\n            // tie sequence has ended (or had length 1)\n            pos = i + 1;\n            if (tiesTrace.length > 1) {  // if seq is nontrivial, resolve\n                resolveTie(out, tiesTrace);\n            }\n            tiesTrace = [];\n            tiesTrace.push(ranks[i].getPosition());\n        } else {\n            // tie sequence continues\n            tiesTrace.push(ranks[i].getPosition());\n        }\n        out[ranks[i].getPosition()] = pos;\n    }\n\n    if (tiesTrace.length > 1) {  // handle tie sequence at end\n        resolveTie(out, tiesTrace);\n    }\n    restoreNaNs(out, nanPositions);\n    return out;\n}\n\nfunction resolveTie(ranks:number[], tiesTrace:number[]) {\n    // constant value of ranks over tiesTrace\n    const c = ranks[tiesTrace[0]];\n    const value = (2 * c + tiesTrace.length - 1) / 2;\n\n    tiesTrace.forEach((trace) => {\n        ranks[trace] = value;\n    });\n}\n\nfunction restoreNaNs(ranks:number[], nanPositions:number[]) {\n    nanPositions.forEach((position) => {\n        ranks[position] = NaN;\n    });\n}\n\nfunction getNanPositions(ranks:IntDoublePair[] ) {\n    const out = [];\n    for (let i = 0; i < ranks.length; i++) {\n        if (isNaN(ranks[i].getValue())){\n            out.push(i);\n        }\n    }\n    return out;\n}\n\n// https://github.com/milaboratory/miplots/blob/559b13065f17dfc7c4dd332247dd1ce0183affcc/src/main/kotlin/com/milaboratory/miplots/stat/util/MannWhitneyU.kt#L36\nexport class MannWhitneyU {\n    SMALL_SAMPLE_SIZE = 50;\n\n    mannWhitneyU (x: number[], y: number[]): number {\n        const z = [...x, ...y];\n        const ranks = rank(z);\n        let sumRankX = 0;\n\n        /*\n         * The ranks for x is in the first x.length entries in ranks because x\n         * is in the first x.length entries in z\n         */for (let i = 0; i < x.length; i++) {\n            sumRankX += ranks[i];\n        }\n\n        /*\n         * U1 = R1 - (n1 * (n1 + 1)) / 2 where R1 is sum of ranks for sample 1,\n         * e.g. x, n1 is the number of observations in sample 1.\n         */\n        const U1 = sumRankX - x.length * (x.length + 1) / 2;\n\n        /*\n         * U1 + U2 = n1 * n2\n         */\n        const U2 = x.length * y.length - U1;\n        return Math.min(U1, U2);\n    }\n\n    mannWhitneyUTest(x: number[], y: number[], exact?:boolean): number {\n        if (typeof exact === 'undefined') {\n            // If samples are both small and there are no ties, perform exact test\n            if (x.length + y.length <= this.SMALL_SAMPLE_SIZE && Object.keys(this.tiesMap(x, y)).length === 0) {\n                return this.mannWhitneyUTest(x, y, true);\n            }\n            // Normal approximation\n            return this.mannWhitneyUTest(x, y, false);\n        }\n\n        const tiesMap = this.tiesMap(x, y);\n        const u = this.mannWhitneyU(x, y);\n        if (exact) {\n            if (Object.keys(tiesMap).length !== 0) {\n                throw new Error();\n            }\n            return this.exactP(x.length, y.length, u);\n        }\n        return this.approximateP(\n            u, x.length, y.length,\n            this.varU(x.length, y.length, tiesMap)\n        );\n    }\n\n    approximateP(u: number, n1: number, n2: number, varU: number): number {\n        const mu = n1 * n2 / 2;\n\n        // If u == mu, return 1\n        if (mu == u) {\n            return 1.0;\n        }\n\n        // Force z <= 0 so we get tail probability. Also apply continuity\n        // correction\n        const z = -Math.abs(u - mu + 0.5) / Math.sqrt(varU);\n        return 2 * standardNormalCumulativeProbability(z);\n    }\n\n    exactP(n: number, m: number, u: number): number {\n        const nm = m * n;\n        if (u > nm) { // Quick exit if u is out of range\n            return 1.0;\n        }\n        // Need to convert u to a mean deviation, so cumulative probability is\n        // tail probability\n        const crit = (u < nm / 2) ? u : nm / 2 - u;\n        let cum = 0;\n        let ct = 0;\n        while (ct <= crit) {\n            cum += this.uDensity(n, m, ct);\n            ct++;\n        }\n        return 2 * cum;\n    }\n\n    uDensity(n: number, m: number, u: number): number {\n        if (u < 0 || u > m * n) {\n            return 0;\n        }\n        const freq = this.uFrequencies(n, m);\n        return freq[Math.round(u + 1)] / lodash.sum(freq);\n    }\n\n    uFrequencies(n: number, m: number): number[] {\n        const max = Math.max(m, n);\n        if (max > 100) {\n            throw Error('n or m > 100');\n        }\n        const min = Math.min(m, n);\n        const out = new Array(n * m + 2);\n        const work = new Array(n * m + 2);\n        for (let i = 1; i < out.length; i++) {\n            out[i] = (i <= max + 1) ? 1 : 0;\n        }\n        work[1] = 0;\n        let in_ = max;\n        for (let i = 2; i <= min; i++) {\n            work[i] = 0;\n            in_ = in_ + max;\n            let n1 = in_ + 2;\n            const l = (1 + in_ / 2);\n            let k = i;\n            for (let j = 1; j <= l; j++) {\n                k++;\n                n1 = n1 - 1;\n                const sum_ = out[j] + work[j];\n                out[j] = sum_;\n                work[k] = sum_ - out[n1];\n                out[n1] = sum_;\n            }\n        }\n        return out;\n    }\n\n    varU(n: number, m: number, tiesMap: Record<number, number>): number {\n        const nm = n * m;\n        if (Object.keys(tiesMap).length === 0) {\n            return nm * (n + m + 1) / 12.0;\n        }\n        const tSum = lodash.sum(Object.values(tiesMap).map(( value) => value * value * value - value));\n        const totalN = n + m;\n        return nm / 12 * (totalN + 1 - tSum / (totalN * (totalN - 1)));\n    }\n\n    tiesMap(x: number[], y: number[]): Record<number, number> {\n        const tiesMap: Record<number, number> = {};\n        for (let i = 0; i < x.length; i++) {\n            tiesMap[x[i]] = tiesMap[x[i]] ? tiesMap[x[i]] + 1 : 1;\n        }\n        for (let i = 0; i < y.length; i++) {\n            tiesMap[y[i]] = tiesMap[y[i]] ? tiesMap[y[i]] + 1 : 1;\n        }\n        for (const key in tiesMap) {\n            if (tiesMap[key] === 1) {\n                delete tiesMap[key];\n            }\n        }\n        return tiesMap;\n    }\n}\n"],"names":["erfc","x","z","t","r","standardNormalCumulativeProbability","IntDoublePair","value","position","rank","data","ranks","i","nanPositions","getNanPositions","a","b","out","pos","tiesTrace","resolveTie","restoreNaNs","trace","MannWhitneyU","__publicField","y","sumRankX","U1","U2","exact","tiesMap","u","n1","n2","varU","mu","n","m","nm","crit","cum","ct","freq","lodash","max","min","work","in_","l","k","j","sum_","tSum","totalN","key"],"mappings":"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"}

package/dist/discrete/layers/stats/index.d.ts

@@ -0,0 +1,5 @@
+import { DataFrame, GroupKey } from '../../../DataFrame';
+import { DiscreteSettingsImpl, StatLayer } from '../../DiscreteSettingsImpl';
+import { StatsData } from '../types';
+export declare function getStatsData(layer: StatLayer, facetKeys: GroupKey[][], primaryKeys: GroupKey[], y: DiscreteSettingsImpl['y'], data: DataFrame): StatsData;
+//# sourceMappingURL=index.d.ts.map

package/dist/discrete/layers/stats/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/discrete/layers/stats/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,SAAS,EAAE,QAAQ,EAAC,MAAM,oBAAoB,CAAC;AAE5D,OAAO,KAAK,EAAC,oBAAoB,EAAE,SAAS,EAAC,MAAM,4BAA4B,CAAC;AAGhF,OAAO,KAAK,EAAC,SAAS,EAAC,MAAM,UAAU,CAAC;AAcxC,wBAAgB,YAAY,CACxB,KAAK,EAAE,SAAS,EAChB,SAAS,EAAE,QAAQ,EAAE,EAAE,EACvB,WAAW,EAAE,QAAQ,EAAE,EACvB,CAAC,EAAE,oBAAoB,CAAC,GAAG,CAAC,EAC5B,IAAI,EAAE,SAAS,GAChB,SAAS,CAqFX"}

package/dist/discrete/layers/stats/index.js

@@ -0,0 +1,84 @@
+import { NO_GROUPED as h } from "../../../DataFrame.js";
+import { calculatePValue as f } from "./pValueCalculation.js";
+import { adjustPValues as d } from "./pValueCorrection.js";
+import { getFacetStringKey as G } from "../../utils/getFacetStringKey.js";
+function k(e) {
+  return e.slice(0, -1).reduce(
+    (a, c, u) => a.concat(e.slice(u + 1).map((i) => [c, i])),
+    []
+  );
+}
+function B(e, a, c, u, i) {
+  return {
+    type: "stats",
+    values: a.reduce((m, p) => {
+      let g = [];
+      switch (e.statType) {
+        case "overall": {
+          const n = c.map((l) => i.getColumnByGrouping([...p, l], u.value)).filter((l) => l.length > 0);
+          if (n.length < 2)
+            break;
+          const r = f(n, e.testMethod, e.paired);
+          g = [[["overall"], r]];
+          break;
+        }
+        case "referenceGroup": {
+          const n = e.referenceGroup === null ? h : String(e.referenceGroup);
+          if (n !== h && !c.includes(n))
+            throw new Error(`Reference group ${String(n)} for ${e.testMethod} test is not in available groups`);
+          const r = i.getColumnByGrouping([...p, n], u.value);
+          if (r.length === 0) {
+            g = [];
+            break;
+          }
+          const t = c.filter((o) => o !== n).map((o) => [o, i.getColumnByGrouping([...p, o], u.value)]).filter(([, o]) => o.length > 0);
+          if (t.length < 2 && e.correctionMethod !== null)
+            break;
+          const s = d(
+            t.map(
+              ([, o]) => f(
+                [r, o],
+                e.testMethod,
+                e.paired
+              )
+            ),
+            e.correctionMethod
+          );
+          g = t.map(([o], v) => [[o], s[v]]);
+          break;
+        }
+        case "pairwise": {
+          const r = k(c).map(([t, s]) => [
+            [t, s],
+            [
+              i.getColumnByGrouping([...p, t], u.value),
+              i.getColumnByGrouping([...p, s], u.value)
+            ]
+          ]).filter(([, [t, s]]) => t.length && s.length);
+          if (r.length < 1)
+            break;
+          const l = d(
+            r.map(([, t]) => f(t, e.testMethod, e.paired)),
+            e.correctionMethod
+          );
+          g = r.map(([t], s) => [t, l[s]]);
+          break;
+        }
+        default:
+          throw new Error("Unknown statType");
+      }
+      return m[G(p)] = g, m;
+    }, {}),
+    meta: {
+      statType: e.statType,
+      testMethod: e.testMethod,
+      format: e.format,
+      ns: e.ns,
+      significanceLevels: e.significanceLevels
+    }
+  };
+}
+export {
+  B as getStatsData
+};
+//# sourceMappingURL=index.js.map

package/dist/discrete/layers/stats/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../../src/discrete/layers/stats/index.ts"],"sourcesContent":["import type {DataFrame, GroupKey} from '../../../DataFrame';\nimport {NO_GROUPED} from '../../../DataFrame';\nimport type {DiscreteSettingsImpl, StatLayer} from '../../DiscreteSettingsImpl';\nimport {calculatePValue} from './pValueCalculation';\nimport {adjustPValues} from './pValueCorrection';\nimport type {StatsData} from '../types';\nimport {getFacetStringKey} from '../../utils/getFacetStringKey';\n\n// all available pairs of unequal keys from array of keys\nfunction getAllKeyPairs (keys:GroupKey[]) {\n    return keys\n        .slice(0,-1)\n        .reduce(\n            (res: [GroupKey, GroupKey][], key1, index) =>\n                res.concat(keys.slice(index + 1).map(key2 => [key1, key2])),\n            []\n        );\n}\n\nexport function getStatsData(\n    layer: StatLayer,\n    facetKeys: GroupKey[][],\n    primaryKeys: GroupKey[],\n    y: DiscreteSettingsImpl['y'],\n    data: DataFrame\n): StatsData {\n    return {\n        type: 'stats',\n        values: facetKeys.reduce((res: StatsData['values'], facetKey) => {\n            let values: [string[], number][] = [];\n            switch (layer.statType) {\n                case 'overall': {\n                    const groups = primaryKeys\n                        .map(primaryKey => data.getColumnByGrouping([...facetKey, primaryKey], y.value))\n                        .filter((group) => group.length > 0);\n                    if (groups.length < 2) {\n                        break;\n                    }\n                    const pValue = calculatePValue(groups, layer.testMethod, layer.paired);\n                    values = [[['overall'], pValue]];\n                    break;\n                }\n                case 'referenceGroup': {\n                    const referenceKey = layer.referenceGroup === null ? NO_GROUPED : String(layer.referenceGroup);\n                    if (referenceKey !== NO_GROUPED && !primaryKeys.includes(referenceKey)) {\n                        throw new Error(`Reference group ${String(referenceKey)} for ${layer.testMethod} test is not in available groups`);\n                    }\n                    const referenceGroup = data.getColumnByGrouping([...facetKey, referenceKey], y.value);\n                    if (referenceGroup.length === 0) {\n                        values = [];\n                        break;\n                    }\n\n                    const keys = primaryKeys.filter(key => key !== referenceKey);\n                    const keysAndGroupsNonEmpty:[string, number[]][] = keys\n                        .map(primaryKey => [primaryKey, data.getColumnByGrouping([...facetKey, primaryKey], y.value)] as [string, number[]])\n                        .filter(([, group]) => group.length > 0);\n                    if (keysAndGroupsNonEmpty.length < 2 && layer.correctionMethod !== null) {\n                        break;\n                    }\n                    const pValues = adjustPValues(\n                        keysAndGroupsNonEmpty.map(([,group]) =>\n                            calculatePValue(\n                                [referenceGroup, group],\n                                layer.testMethod,\n                                layer.paired\n                            )\n                        ),\n                        layer.correctionMethod\n                    );\n                    values = keysAndGroupsNonEmpty.map(([primaryKey], index) => [[primaryKey], pValues[index]]);\n                    break;\n                }\n                case 'pairwise': {\n                    const keysPairs = getAllKeyPairs(primaryKeys);\n                    const keysAndGroupsNonEmpty:[string[], number[][]][] = keysPairs\n                        .map(([key1, key2]) => [\n                            [key1, key2],\n                            [\n                                data.getColumnByGrouping([...facetKey, key1], y.value),\n                                data.getColumnByGrouping([...facetKey, key2], y.value)\n                            ]\n                        ] as [string[], number[][]])\n                        .filter(([,[gr1, gr2]]) => gr1.length && gr2.length);\n\n                    if (keysAndGroupsNonEmpty.length < 1) {\n                        break;\n                    }\n                    const pValues = adjustPValues(\n                        keysAndGroupsNonEmpty.map(([,groups]) => calculatePValue(groups, layer.testMethod, layer.paired)),\n                        layer.correctionMethod\n                    );\n                    values = keysAndGroupsNonEmpty.map(([keysPair], index) => [keysPair, pValues[index]]);\n                    break;\n                }\n                default: {\n                    throw new Error('Unknown statType');\n                }\n            }\n            res[getFacetStringKey(facetKey)] = values;\n            return res;\n        }, {}),\n        meta: {\n            statType: layer.statType,\n            testMethod: layer.testMethod,\n            format: layer.format,\n            ns: layer.ns,\n            significanceLevels: layer.significanceLevels\n        },\n    };\n}\n"],"names":["getAllKeyPairs","keys","res","key1","index","key2","getStatsData","layer","facetKeys","primaryKeys","y","data","facetKey","values","groups","primaryKey","group","pValue","calculatePValue","referenceKey","NO_GROUPED","referenceGroup","keysAndGroupsNonEmpty","key","pValues","adjustPValues","gr1","gr2","keysPair","getFacetStringKey"],"mappings":"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"}

package/dist/discrete/layers/stats/pValueCalculation.d.ts

@@ -0,0 +1,3 @@
+import { StatTestMethod } from '../../../types';
+export declare function calculatePValue(groups: number[][], testMethod: StatTestMethod, paired: boolean): number;
+//# sourceMappingURL=pValueCalculation.d.ts.map

package/dist/discrete/layers/stats/pValueCalculation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pValueCalculation.d.ts","sourceRoot":"","sources":["../../../../src/discrete/layers/stats/pValueCalculation.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAC,cAAc,EAAC,MAAM,gBAAgB,CAAC;AAGnD,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,EAAE,OAAO,UA+C9F"}

package/dist/discrete/layers/stats/pValueCalculation.js

@@ -0,0 +1,50 @@
+import l from "../../../node_modules/@stdlib/stats-anova1/lib/index.js";
+import s from "../../../node_modules/@stdlib/stats-ttest/lib/index.js";
+import f from "../../../node_modules/@stdlib/stats-ttest2/lib/index.js";
+import m from "../../../node_modules/@stdlib/stats-kruskal-test/lib/index.js";
+import h from "../../../node_modules/@stdlib/stats-wilcoxon/lib/index.js";
+import { MannWhitneyU as c } from "./MannWhitneyU.js";
+import n from "../../../node_modules/lodash/lodash.js";
+function u(t, a, r) {
+  switch (a) {
+    case "ttest": {
+      if (t.length > 2)
+        throw new Error("more than 2 datasets passed");
+      if (r) {
+        if (t[0].length !== t[1].length)
+          throw Error("Different size groups in paired test");
+        return s(t[0], t[1]).pValue;
+      }
+      const e = f(t[0], t[1]).pValue;
+      return isNaN(e) ? 1 : e;
+    }
+    case "anova": {
+      const e = l(
+        n.flatten(t),
+        n.flatten(t.map((i, o) => i.map(() => String(o))))
+      ).pValue;
+      return isNaN(e) ? 1 : e;
+    }
+    case "wilcoxon": {
+      if (t.length > 2)
+        throw new Error("more than 2 datasets passed");
+      if (r) {
+        if (t[0].length !== t[1].length)
+          throw Error("Different size groups in paired test");
+        return h(t[0], t[1]).pValue;
+      }
+      const e = new c().mannWhitneyUTest(t[0], t[1]);
+      return isNaN(e) ? 1 : e;
+    }
+    case "kruskalWallis": {
+      const e = m(...t).pValue;
+      return isNaN(e) ? 1 : e;
+    }
+    default:
+      throw new Error("Unknown test method");
+  }
+}
+export {
+  u as calculatePValue
+};
+//# sourceMappingURL=pValueCalculation.js.map

package/dist/discrete/layers/stats/pValueCalculation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pValueCalculation.js","sources":["../../../../src/discrete/layers/stats/pValueCalculation.ts"],"sourcesContent":["import anova1 from '@stdlib/stats-anova1';\nimport ttest from '@stdlib/stats-ttest';\nimport ttest2 from '@stdlib/stats-ttest2';\nimport kruskal from '@stdlib/stats-kruskal-test';\nimport wilcoxon from '@stdlib/stats-wilcoxon';\nimport {MannWhitneyU} from './MannWhitneyU';\nimport type {StatTestMethod} from '../../../types';\nimport lodash from 'lodash';\n\nexport function calculatePValue(groups: number[][], testMethod: StatTestMethod, paired: boolean) {\n    switch (testMethod) {\n        case 'ttest': {\n            if (groups.length > 2) {\n                throw new Error('more than 2 datasets passed');\n            }\n            if (paired) {\n                if (groups[0].length !== groups[1].length) {\n                    throw Error('Different size groups in paired test');\n                }\n                return ttest(groups[0], groups[1]).pValue;\n            }\n\n            const res = ttest2(groups[0], groups[1]).pValue;\n            return isNaN(res) ? 1 : res;\n        }\n        case 'anova': {\n            const res = anova1(\n                lodash.flatten(groups),\n                lodash.flatten(groups.map((g, index) => g.map(() => String(index))))\n            ).pValue;\n            return isNaN(res) ? 1 : res;\n        }\n        case 'wilcoxon': {\n            if (groups.length > 2) {\n                throw new Error('more than 2 datasets passed');\n            }\n            if (paired) {\n                if (groups[0].length !== groups[1].length) {\n                    throw Error('Different size groups in paired test');\n                }\n                return wilcoxon(groups[0], groups[1]).pValue;\n            }\n            const res =  new MannWhitneyU().mannWhitneyUTest(groups[0], groups[1]);\n            return isNaN(res) ? 1 : res;\n        }\n        case 'kruskalWallis': {\n            // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n            // @ts-ignore\n            // NB: kruskal test works correct with more than 3 groups, but only 1,2 or 3 groups in its signature\n            const res = kruskal(...groups).pValue;\n            return isNaN(res) ? 1 : res;\n        }\n        default: {\n            throw new Error('Unknown test method');\n        }\n    }\n}\n"],"names":["calculatePValue","groups","testMethod","paired","ttest","res","ttest2","anova1","lodash","g","index","wilcoxon","MannWhitneyU","kruskal"],"mappings":";;;;;;;AASO,SAASA,EAAgBC,GAAoBC,GAA4BC,GAAiB;AAC7F,UAAQD,GAAA;AAAA,IACJ,KAAK,SAAS;AACV,UAAID,EAAO,SAAS;AAChB,cAAM,IAAI,MAAM,6BAA6B;AAEjD,UAAIE,GAAQ;AACR,YAAIF,EAAO,CAAC,EAAE,WAAWA,EAAO,CAAC,EAAE;AAC/B,gBAAM,MAAM,sCAAsC;AAEtD,eAAOG,EAAMH,EAAO,CAAC,GAAGA,EAAO,CAAC,CAAC,EAAE;AAAA,MACvC;AAEA,YAAMI,IAAMC,EAAOL,EAAO,CAAC,GAAGA,EAAO,CAAC,CAAC,EAAE;AACzC,aAAO,MAAMI,CAAG,IAAI,IAAIA;AAAA,IAC5B;AAAA,IACA,KAAK,SAAS;AACV,YAAMA,IAAME;AAAA,QACRC,EAAO,QAAQP,CAAM;AAAA,QACrBO,EAAO,QAAQP,EAAO,IAAI,CAACQ,GAAGC,MAAUD,EAAE,IAAI,MAAM,OAAOC,CAAK,CAAC,CAAC,CAAC;AAAA,MAAA,EACrE;AACF,aAAO,MAAML,CAAG,IAAI,IAAIA;AAAA,IAC5B;AAAA,IACA,KAAK,YAAY;AACb,UAAIJ,EAAO,SAAS;AAChB,cAAM,IAAI,MAAM,6BAA6B;AAEjD,UAAIE,GAAQ;AACR,YAAIF,EAAO,CAAC,EAAE,WAAWA,EAAO,CAAC,EAAE;AAC/B,gBAAM,MAAM,sCAAsC;AAEtD,eAAOU,EAASV,EAAO,CAAC,GAAGA,EAAO,CAAC,CAAC,EAAE;AAAA,MAC1C;AACA,YAAMI,IAAO,IAAIO,EAAA,EAAe,iBAAiBX,EAAO,CAAC,GAAGA,EAAO,CAAC,CAAC;AACrE,aAAO,MAAMI,CAAG,IAAI,IAAIA;AAAA,IAC5B;AAAA,IACA,KAAK,iBAAiB;AAIlB,YAAMA,IAAMQ,EAAQ,GAAGZ,CAAM,EAAE;AAC/B,aAAO,MAAMI,CAAG,IAAI,IAAIA;AAAA,IAC5B;AAAA,IACA;AACI,YAAM,IAAI,MAAM,qBAAqB;AAAA,EACzC;AAER;"}

package/dist/discrete/layers/stats/pValueCorrection.d.ts

@@ -0,0 +1,3 @@
+import { PValueCorrectionMethod } from '../../../types';
+export declare function adjustPValues(pValues: number[], method: PValueCorrectionMethod | null): number[];
+//# sourceMappingURL=pValueCorrection.d.ts.map

package/dist/discrete/layers/stats/pValueCorrection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pValueCorrection.d.ts","sourceRoot":"","sources":["../../../../src/discrete/layers/stats/pValueCorrection.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,sBAAsB,EAAC,MAAM,gBAAgB,CAAC;AA+O3D,wBAAgB,aAAa,CAAC,OAAO,EAAC,MAAM,EAAE,EAAE,MAAM,EAAC,sBAAsB,GAAG,IAAI,YA0BnF"}

package/dist/discrete/layers/stats/pValueCorrection.js

@@ -0,0 +1,191 @@
+import b from "../../../node_modules/lodash/lodash.js";
+function E(t, e) {
+  let r;
+  if (t == e) {
+    r = new Array(e + 1);
+    for (let n = 0; n < r.length; ++n)
+      r[n] = n + 1;
+  } else if (t < e) {
+    r = new Array(e - t + 1);
+    for (let n = 0; n < r.length; ++n)
+      r[n] = t + n;
+  } else {
+    r = new Array(t - e + 1);
+    for (let n = 0; n < r.length; ++n)
+      r[n] = t - n;
+  }
+  return r;
+}
+function m(t, e) {
+  return b.orderBy(
+    t.map((r, n) => [r, n]),
+    ([r]) => r,
+    [e ? "desc" : "asc"]
+  ).map(([, r]) => r);
+}
+function H(t) {
+  if (t.length < 1)
+    throw new Error("cummin requires at least one element");
+  const e = new Array(t.length);
+  let r = t[0];
+  for (let n = 0; n < t.length; ++n)
+    t[n] < r && (r = t[n]), e[n] = r;
+  return e;
+}
+function x(t) {
+  if (t.length < 1)
+    throw new Error("cummax requires at least one element");
+  const e = new Array(t.length);
+  let r = t[0];
+  for (let n = 0; n < t.length; ++n)
+    t[n] > r && (r = t[n]), e[n] = r;
+  return e;
+}
+function y(t, e) {
+  if (t.length < 1)
+    throw new Error("pmin requires at least one element");
+  return t.map((r) => Math.min(r, e));
+}
+function z(t) {
+  if (t.length < 1)
+    throw new Error("pAdjust requires at least one element");
+  return Math.min(...t);
+}
+function B(t) {
+  const e = t.length;
+  if (e < 1)
+    throw new Error("pAdjust requires at least one element");
+  const r = new Array(e);
+  for (let n = 0; n < e; ++n) {
+    const o = t[n] * e;
+    if (o >= 1)
+      r[n] = 1;
+    else if (0 <= o)
+      r[n] = o;
+    else
+      throw new Error(`${o} is outside [0, 1)`);
+  }
+  return r;
+}
+function p(t) {
+  const e = t.length;
+  if (e < 1)
+    throw new Error("pAdjust requires at least one element");
+  const r = m(t, !1), n = r.slice(), o = new Array(e).fill(0);
+  for (let c = 0; c < e; ++c)
+    o[c] = (e - c) * t[r[c]];
+  const s = m(n, !1), a = x(o), u = y(a, 1), f = new Array(e);
+  for (let c = 0; c < e; ++c)
+    f[c] = u[s[c]];
+  return f;
+}
+function M(t) {
+  const e = t.length;
+  if (e < 1)
+    throw new Error("pAdjust requires at least one element");
+  const r = E(e, e), n = m(t, !1), o = new Array(e);
+  for (let l = 0; l < e; ++l)
+    o[l] = t[n[l]];
+  const s = n.slice(), a = m(s, !1), u = new Array(e), f = new Array(e), c = new Array(e);
+  for (let l = 0; l < e; ++l)
+    c[l] = o[l] * e / r[l];
+  const q = z(c);
+  u.fill(q), f.fill(q);
+  for (let l = e; l >= 2; --l) {
+    const A = E(1, e - l + 1);
+    for (let i = 0; i < e - l + 1; ++i)
+      A[i]--;
+    const h = l - 1, w = new Array(h);
+    for (let i = 0; i < h; ++i)
+      w[i] = e - l + 2 + i - 1;
+    let g = l * o[w[0]] / 2;
+    for (let i = 1; i < h; ++i) {
+      const j = o[w[i]] * l / (2 + i);
+      j < g && (g = j);
+    }
+    for (let i = 0; i < e - l + 1; ++i)
+      u[A[i]] = Math.min(o[A[i]] * l, g);
+    for (let i = 0; i < h; ++i)
+      u[w[i]] = u[e - l];
+    for (let i = 0; i < e; ++i)
+      f[i] < u[i] && (f[i] = u[i]);
+  }
+  for (let l = 0; l < e; ++l)
+    u[l] = f[a[l]];
+  return u;
+}
+class D {
+  constructor(e, r, n) {
+    this.ni = e, this.o = r, this.ro = n;
+  }
+  result(e) {
+    const r = H(e), n = y(r, 1), o = new Array(e.length);
+    for (let s = 0; s < e.length; ++s)
+      o[s] = n[this.ro[s]];
+    return o;
+  }
+}
+function d(t) {
+  const e = t.length, r = new Array(e), n = m(t, !0);
+  for (let s = 0; s < e; ++s) {
+    if (t[s] < 0 || t[s] > 1)
+      throw new Error("array[" + s + "] = " + t[s] + " is outside [0, 1]");
+    r[s] = e / (e - s);
+  }
+  const o = m(n, !1);
+  return new D(r, n, o);
+}
+function I(t) {
+  const e = t.length;
+  if (e < 1)
+    throw new Error("pAdjust requires at least one element");
+  const r = d(t), n = new Array(e);
+  for (let o = 0; o < e; ++o)
+    n[o] = r.ni[o] * t[r.o[o]];
+  return r.result(n);
+}
+function k(t) {
+  const e = t.length;
+  if (e < 1)
+    throw new Error("pAdjust requires at least one element");
+  const r = d(t), n = new Array(e);
+  let o = 0;
+  for (let s = 1; s < e + 1; ++s)
+    o += 1 / s;
+  for (let s = 0; s < e; ++s)
+    n[s] = o * r.ni[s] * t[r.o[s]];
+  return r.result(n);
+}
+function L(t) {
+  const e = t.length;
+  if (e < 1)
+    throw new Error("pAdjust requires at least one element");
+  const r = d(t), n = new Array(e);
+  for (let o = 0; o < e; ++o)
+    n[o] = (o + 1) * t[r.o[o]];
+  return r.result(n);
+}
+function $(t, e) {
+  switch (e) {
+    case "BenjaminiHochberg":
+      return I(t);
+    case "BenjaminiYekutieli":
+      return k(t);
+    case "Bonferroni":
+      return B(t);
+    case "Hochberg":
+      return L(t);
+    case "Holm":
+      return p(t);
+    case "Hommel":
+      return M(t);
+    case null:
+      return t;
+    default:
+      throw new Error(`Unknown p-value correction method: ${e}`);
+  }
+}
+export {
+  $ as adjustPValues
+};
+//# sourceMappingURL=pValueCorrection.js.map

package/dist/discrete/layers/stats/pValueCorrection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pValueCorrection.js","sources":["../../../../src/discrete/layers/stats/pValueCorrection.ts"],"sourcesContent":["import type {PValueCorrectionMethod} from '../../../types';\nimport lodash from 'lodash';\n\n// calculations from https://github.com/milaboratory/miplots/blob/559b13065f17dfc7c4dd332247dd1ce0183affcc/src/main/java/com/milaboratory/miplots/stat/util/PValueCorrection.java#L43\nfunction seqLen(start:number, end:number) {\n    let result:number[];\n    if (start == end) {\n        result = new Array(end + 1);\n        for (let i = 0; i < result.length; ++i) {\n            result[i] = i + 1;\n        }\n    } else if (start < end) {\n        result = new Array(end - start + 1);\n        for (let i = 0; i < result.length; ++i) {\n            result[i] = start + i;\n        }\n    } else {\n        result = new Array(start - end + 1);\n        for (let i = 0; i < result.length; ++i) {\n            result[i] = start - i;\n        }\n    }\n    return result;\n}\n\nfunction order(array:number[], decreasing:boolean):number[] {\n    return lodash.orderBy(\n        array.map((value, index) => [value, index]),\n        ([value]) => value,\n        [decreasing ? 'desc' : 'asc']\n    ).map(([, index]) => index);\n}\n\nfunction cummin(array:number[]):number[] {\n    if (array.length < 1)\n        throw new Error('cummin requires at least one element');\n    const output = new Array(array.length);\n    let cumulativeMin = array[0];\n    for (let i = 0; i < array.length; ++i) {\n        if (array[i] < cumulativeMin)\n            cumulativeMin = array[i];\n        output[i] = cumulativeMin;\n    }\n    return output;\n}\n\nfunction cummax(array:number[]):number[] {\n    if (array.length < 1) {\n        throw new Error('cummax requires at least one element');\n    }\n    const output = new Array(array.length);\n    let cumulativeMax = array[0];\n    for (let i = 0; i < array.length; ++i) {\n        if (array[i] > cumulativeMax)\n            cumulativeMax = array[i];\n        output[i] = cumulativeMax;\n    }\n    return output;\n}\n\nfunction pminx(array:number[], x:number):number[] {\n    if (array.length < 1) {\n        throw new Error('pmin requires at least one element');\n    }\n    return array.map((el) => Math.min(el, x));\n}\n\nfunction doubleArrayMin(array:number[]):number {\n    if (array.length < 1)\n        throw new Error('pAdjust requires at least one element');\n    return Math.min(...array);\n}\n\nfunction Bonferoni(pvalues:number[]):number[] {\n    const size = pvalues.length;\n    if (size < 1)\n        throw new Error('pAdjust requires at least one element');\n\n    const result:number[] = new Array(size);\n    for (let i = 0; i < size; ++i) {\n        const b = pvalues[i] * size;\n        if (b >= 1) {\n            result[i] = 1;\n        } else if (0 <= b) {\n            result[i] = b;\n        } else {\n            throw new Error(`${b} is outside [0, 1)`);\n        }\n    }\n    return result;\n}\n\nfunction Holm(pvalues:number[]):number[] {\n    const size = pvalues.length;\n    if (size < 1)\n        throw new Error('pAdjust requires at least one element');\n\n    const o = order(pvalues, false);\n    const o2Double = o.slice();\n    const cummaxInput = new Array(size).fill(0);\n    for (let i = 0; i < size; ++i) {\n        cummaxInput[i] = (size - i) * pvalues[o[i]];\n    }\n    const ro = order(o2Double, false);\n    const cummaxOutput = cummax(cummaxInput);\n    const pmin = pminx(cummaxOutput, 1.0);\n    const result = new Array(size);\n    for (let i = 0; i < size; ++i) {\n        result[i] = pmin[ro[i]];\n    }\n    return result;\n}\n\nfunction Hommel(pvalues:number[]):number[] {\n    const size = pvalues.length;\n    if (size < 1)\n        throw new Error('pAdjust requires at least one element');\n    const indices = seqLen(size, size);\n    const o = order(pvalues, false);\n    const p = new Array(size);\n    for (let i = 0; i < size; ++i) {\n        p[i] = pvalues[o[i]];\n    }\n    const o2Double = o.slice();\n    const ro = order(o2Double, false);\n    const q = new Array(size);\n    const pa = new Array(size);\n    const npi = new Array(size);\n    for (let i = 0; i < size; ++i) {\n        npi[i] = p[i] * size / indices[i];\n    }\n    const min = doubleArrayMin(npi);\n    q.fill(min);\n    pa.fill(min);\n    for (let j = size; j >= 2; --j) {\n        const ij = seqLen(1, size - j + 1);\n        for (let i = 0; i < size - j + 1; ++i) {\n            ij[i]--;\n        }\n        const i2Length = j - 1;\n        const i2 = new Array(i2Length);\n        for (let i = 0; i < i2Length; ++i) {\n            i2[i] = size - j + 2 + i - 1;\n        }\n        let q1 = j * p[i2[0]] / 2.0;\n        for (let i = 1; i < i2Length; ++i) {\n            const temp_q1 = p[i2[i]] * j / (2.0 + i);\n            if (temp_q1 < q1) {\n                q1 = temp_q1;\n            }\n        }\n        for (let i = 0; i < size - j + 1; ++i) {\n            q[ij[i]] = Math.min(p[ij[i]] * j, q1);\n        }\n        for (let i = 0; i < i2Length; ++i) {\n            q[i2[i]] = q[size - j];\n        }\n        for (let i = 0; i < size; ++i) {\n            if (pa[i] < q[i]) {\n                pa[i] = q[i];\n            }\n        }\n    }\n    for (let i = 0; i < size; ++i) {\n        q[i] = pa[ro[i]];\n    }\n    return q;\n}\n\nclass IntermediateData {\n    constructor(readonly ni: number[], readonly o: number[], readonly ro: number[]) {}\n    result(cumminInput:number[]):number[] {\n        const cumminArray:number[] = cummin(cumminInput);\n        const pmin:number[] = pminx(cumminArray, 1);\n        const result:number[] = new Array(cumminInput.length);\n        for (let i = 0; i < cumminInput.length; ++i) {\n            result[i] = pmin[this.ro[i]];\n        }\n        return result;\n    }\n}\n\nfunction computeIntermediateData(pvalues:number[]) {\n    const size = pvalues.length;\n    const ni = new Array(size);\n    const o = order(pvalues, true);\n    for (let i = 0; i < size; ++i) {\n        if (pvalues[i] < 0 || pvalues[i] > 1) {\n            throw new Error('array[' + i + '] = ' + pvalues[i] + ' is outside [0, 1]');\n        }\n        ni[i] = size / (size - i);\n    }\n    const ro = order(o, false);\n    return new IntermediateData(ni, o, ro);\n}\n\nfunction BenjaminiHochberg(pvalues:number[]) {\n    const size = pvalues.length;\n    if (size < 1)\n        throw new Error('pAdjust requires at least one element');\n\n    const data = computeIntermediateData(pvalues);\n    const cumminInput:number[] = new Array(size);\n    for (let i = 0; i < size; ++i) {\n        cumminInput[i] = data.ni[i] * pvalues[data.o[i]];\n    }\n    return data.result(cumminInput);\n}\n\nfunction BenjaminiYekutieli(pvalues:number[]):number[] {\n    const size = pvalues.length;\n    if (size < 1)\n        throw new Error('pAdjust requires at least one element');\n\n    const data:IntermediateData = computeIntermediateData(pvalues);\n    const cumminInput = new Array(size);\n    let q = 0;\n    for (let i = 1; i < size + 1; ++i) {\n        q += 1 / i;\n    }\n    for (let i = 0; i < size; ++i) {\n        cumminInput[i] = q * data.ni[i] * pvalues[data.o[i]];\n    }\n    return data.result(cumminInput);\n}\n\nfunction Hochberg(pvalues:number[]):number[] {\n    const size = pvalues.length;\n    if (size < 1)\n        throw new Error('pAdjust requires at least one element');\n\n    const data:IntermediateData = computeIntermediateData(pvalues);\n    const cumminInput = new Array(size);\n    for (let i = 0; i < size; ++i) {\n        cumminInput[i] = (i + 1) * pvalues[data.o[i]];\n    }\n    return data.result(cumminInput);\n}\n\nexport function adjustPValues(pValues:number[], method:PValueCorrectionMethod | null) {\n    switch (method) {\n        case 'BenjaminiHochberg': {\n            return BenjaminiHochberg(pValues);\n        }\n        case 'BenjaminiYekutieli': {\n            return BenjaminiYekutieli(pValues);\n        }\n        case 'Bonferroni': {\n            return Bonferoni(pValues);\n        }\n        case 'Hochberg': {\n            return Hochberg(pValues);\n        }\n        case 'Holm': {\n            return Holm(pValues);\n        }\n        case 'Hommel': {\n            return Hommel(pValues);\n        }\n        case null: {\n            return pValues;\n        }\n        default:\n            throw new Error(`Unknown p-value correction method: ${method}`);\n    }\n}\n"],"names":["seqLen","start","end","result","i","order","array","decreasing","lodash","value","index","cummin","output","cumulativeMin","cummax","cumulativeMax","pminx","x","el","doubleArrayMin","Bonferoni","pvalues","size","b","Holm","o","o2Double","cummaxInput","ro","cummaxOutput","pmin","Hommel","indices","p","q","pa","npi","min","j","ij","i2Length","i2","q1","temp_q1","IntermediateData","ni","cumminInput","cumminArray","computeIntermediateData","BenjaminiHochberg","data","BenjaminiYekutieli","Hochberg","adjustPValues","pValues","method"],"mappings":"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"}