@datagrok-libraries/statistics 0.1.4 → 0.1.7

package/.eslintrc.json

@@ -1,29 +1,29 @@
-{
-	"env": {
-		"browser": true,
-		"es2021": true
-	},
-	"extends": [
-		"google"
-	],
-	"parserOptions": {
-		"ecmaVersion": 12,
-		"sourceType": "module"
-	},
-	"rules": {
-		"indent": [
-			"error",
-			2
-		],
-		"max-len": [
-			"error",
-			120
-		],
-		"require-jsdoc": "off",
-		"spaced-comment": "off"
-	},
-	"parser": "@typescript-eslint/parser",
-	"plugins": [
-		"@typescript-eslint"
-	]
+{
+	"env": {
+		"browser": true,
+		"es2021": true
+	},
+	"extends": [
+		"google"
+	],
+	"parserOptions": {
+		"ecmaVersion": 12,
+		"sourceType": "module"
+	},
+	"rules": {
+		"indent": [
+			"error",
+			2
+		],
+		"max-len": [
+			"error",
+			120
+		],
+		"require-jsdoc": "off",
+		"spaced-comment": "off"
+	},
+	"parser": "@typescript-eslint/parser",
+	"plugins": [
+		"@typescript-eslint"
+	]
 }

package/README.md

@@ -1,3 +1,3 @@
-# statistics
-
+# statistics
+
 statistics is a [package](https://datagrok.ai/help/develop/develop#packages) for the [Datagrok](https://datagrok.ai) platform.

package/package.json

@@ -1,32 +1,36 @@
-{
-	"name": "@datagrok-libraries/statistics",
-	"publishConfig": {
-		"access": "public"
-	},
-	"friendlyName": "statistics",
-	"version": "0.1.4",
-	"description": "",
-	"dependencies": {
-		"datagrok-api": ">0.95.4",
-		"cash-dom": "latest",
-		"dayjs": "latest",
-		"jstat": "latest"
-	},
-	"devDependencies": {
-		"ts-loader": "^9.2.6",
-		"typescript": "^4.2.3",
-		"eslint": "latest",
-		"eslint-config-google": "latest",
-		"@typescript-eslint/eslint-plugin": "latest",
-		"@typescript-eslint/parser": "latest"
-	},
-	"scripts": {
-		"link": "npm link",
-		"debug-statistics": "grok publish --rebuild",
-		"release-statistics": "grok publish --rebuild --release",
-		"build-statistics": "tsc",
-		"build": "tsc",
-		"lint": "eslint src --ext .ts",
-		"lint-fix": "eslint src --ext .ts --fix"
-	}
-}
+{
+  "name": "@datagrok-libraries/statistics",
+  "publishConfig": {
+    "access": "public"
+  },
+  "friendlyName": "statistics",
+  "version": "0.1.7",
+  "description": "",
+  "dependencies": {
+    "datagrok-api": ">0.95.4",
+    "@datagrok-libraries/utils": ">=0.0.22",
+    "cash-dom": "latest",
+    "dayjs": "latest",
+    "jstat": "latest"
+  },
+  "devDependencies": {
+    "ts-loader": "^9.2.6",
+    "typescript": "^4.2.3",
+    "eslint": "latest",
+    "eslint-config-google": "latest",
+    "@typescript-eslint/eslint-plugin": "latest",
+    "@typescript-eslint/parser": "latest"
+  },
+  "scripts": {
+    "link": "npm link",
+    "link-api": "npm link datagrok-api",
+    "link-utils": "npm link @datagrok-libraries/utils",
+    "link-all": "npm link datagrok-api @datagrok-libraries/utils",
+    "debug-statistics": "grok publish --rebuild",
+    "release-statistics": "grok publish --rebuild --release",
+    "build-statistics": "tsc",
+    "build": "tsc",
+    "lint": "eslint src --ext .ts",
+    "lint-fix": "eslint src --ext .ts --fix"
+  }
+}

package/src/correlation-coefficient.d.ts

@@ -0,0 +1,15 @@
+import { Options } from '../../utils/src/type-declarations';
+/**
+ * Calculates Kendall's tau, a correlation measure for ordinal data, and an associated p-value.
+ * Returns: Kendall's tau, two-tailed p-value.
+ * Derived from older SciPy: http://web.mit.edu/6.863/spring2011/packages/scipy_src/scipy/stats/stats.py
+ *
+ * @export
+ * @param {number[]} x The first array.
+ * @param {number[]} y The second array.
+ * @return {Options} The result.
+ * @link https://github.com/pdfernhout/narrafirma/blob/
+ * c9c122d577a4b8868ce603badabbb7d10f45740c/webapp/source/statistics/kendallsTau.ts#L8
+ */
+export declare function kendallsTau(x: number[], y: number[]): Options;
+//# sourceMappingURL=correlation-coefficient.d.ts.map

package/src/correlation-coefficient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"correlation-coefficient.d.ts","sourceRoot":"","sources":["correlation-coefficient.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,OAAO,EAAC,MAAM,mCAAmC,CAAC;AAwD1D;;;;;;;;;;;GAWG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,MAAM,EAAE,GAAG,OAAO,CAiC7D"}

package/src/correlation-coefficient.js

@@ -0,0 +1,100 @@
+//import {Options} from '@datagrok-libraries/utils/src/type-declarations';
+/**
+ * Returns the error function erf(x).
+ *
+ * @param {number} x An argument.
+ * @return {number} The result.
+ * @link https://github.com/jstat/jstat/blob/65ce096a99f753d6a22482e5e74accbfc1c33767/dist/jstat.js#L1562
+ */
+function erf(x) {
+    const cof = [-1.3026537197817094, 6.4196979235649026e-1, 1.9476473204185836e-2,
+        -9.561514786808631e-3, -9.46595344482036e-4, 3.66839497852761e-4,
+        4.2523324806907e-5, -2.0278578112534e-5, -1.624290004647e-6,
+        1.303655835580e-6, 1.5626441722e-8, -8.5238095915e-8,
+        6.529054439e-9, 5.059343495e-9, -9.91364156e-10,
+        -2.27365122e-10, 9.6467911e-11, 2.394038e-12,
+        -6.886027e-12, 8.94487e-13, 3.13092e-13,
+        -1.12708e-13, 3.81e-16, 7.106e-15,
+        -1.523e-15, -9.4e-17, 1.21e-16,
+        -2.8e-17];
+    let j = cof.length - 1;
+    let isneg = false;
+    let d = 0;
+    let dd = 0;
+    let t = 0;
+    let ty = 0;
+    let tmp = 0;
+    let res = 0;
+    if (x < 0) {
+        x = -x;
+        isneg = true;
+    }
+    t = 2 / (2 + x);
+    ty = 4 * t - 2;
+    for (; j > 0; j--) {
+        tmp = d;
+        d = ty * d - dd + cof[j];
+        dd = tmp;
+    }
+    res = t * Math.exp(-x * x + 0.5 * (cof[0] + ty * d) - dd);
+    return isneg ? res - 1 : 1 - res;
+}
+/**
+ * Returns the complmentary error function erfc(x)
+ *
+ * @param {number} x An argument.
+ * @return {number} The result.
+ * @link https://github.com/jstat/jstat/blob/65ce096a99f753d6a22482e5e74accbfc1c33767/dist/jstat.js#L1599
+ */
+function erfc(x) {
+    return 1 - erf(x);
+}
+/**
+ * Calculates Kendall's tau, a correlation measure for ordinal data, and an associated p-value.
+ * Returns: Kendall's tau, two-tailed p-value.
+ * Derived from older SciPy: http://web.mit.edu/6.863/spring2011/packages/scipy_src/scipy/stats/stats.py
+ *
+ * @export
+ * @param {number[]} x The first array.
+ * @param {number[]} y The second array.
+ * @return {Options} The result.
+ * @link https://github.com/pdfernhout/narrafirma/blob/
+ * c9c122d577a4b8868ce603badabbb7d10f45740c/webapp/source/statistics/kendallsTau.ts#L8
+ */
+export function kendallsTau(x, y) {
+    let n1 = 0;
+    let n2 = 0;
+    let iss = 0;
+    for (let j = 0; j < x.length - 1; j++) {
+        for (let k = j + 1; k < y.length; k++) {
+            const a1 = x[j] - x[k];
+            const a2 = y[j] - y[k];
+            const aa = a1 * a2;
+            if (aa) {
+                // neither array has a tie
+                n1 = n1 + 1;
+                n2 = n2 + 1;
+                if (aa > 0) {
+                    iss = iss + 1;
+                }
+                else {
+                    iss = iss - 1;
+                }
+            }
+            else {
+                if (a1) {
+                    n1 = n1 + 1;
+                }
+                if (a2) {
+                    n2 = n2 + 1;
+                }
+            }
+        }
+    }
+    const tau = iss / Math.sqrt(n1 * n2);
+    const svar = (4.0 * x.length + 10.0) / (9.0 * x.length * (x.length - 1));
+    const z = tau / Math.sqrt(svar);
+    const prob = erfc(Math.abs(z) / 1.4142136);
+    return { test: tau, z: z, prob: prob };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"correlation-coefficient.js","sourceRoot":"","sources":["correlation-coefficient.ts"],"names":[],"mappings":"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","sourcesContent":["import {Options} from '../../utils/src/type-declarations';\n//import {Options} from '@datagrok-libraries/utils/src/type-declarations';\n\n/**\n * Returns the error function erf(x).\n *\n * @param {number} x An argument.\n * @return {number} The result.\n * @link https://github.com/jstat/jstat/blob/65ce096a99f753d6a22482e5e74accbfc1c33767/dist/jstat.js#L1562\n */\nfunction erf(x: number): number {\n  const cof = [-1.3026537197817094, 6.4196979235649026e-1, 1.9476473204185836e-2,\n    -9.561514786808631e-3, -9.46595344482036e-4, 3.66839497852761e-4,\n    4.2523324806907e-5, -2.0278578112534e-5, -1.624290004647e-6,\n    1.303655835580e-6, 1.5626441722e-8, -8.5238095915e-8,\n    6.529054439e-9, 5.059343495e-9, -9.91364156e-10,\n    -2.27365122e-10, 9.6467911e-11, 2.394038e-12,\n    -6.886027e-12, 8.94487e-13, 3.13092e-13,\n    -1.12708e-13, 3.81e-16, 7.106e-15,\n    -1.523e-15, -9.4e-17, 1.21e-16,\n    -2.8e-17];\n  let j = cof.length - 1;\n  let isneg = false;\n  let d = 0;\n  let dd = 0;\n  let t: number = 0; let ty: number = 0; let tmp: number = 0; let res: number = 0;\n\n  if (x < 0) {\n    x = -x;\n    isneg = true;\n  }\n\n  t = 2 / (2 + x);\n  ty = 4 * t - 2;\n\n  for (; j > 0; j--) {\n    tmp = d;\n    d = ty * d - dd + cof[j];\n    dd = tmp;\n  }\n\n  res = t * Math.exp(-x * x + 0.5 * (cof[0] + ty * d) - dd);\n  return isneg ? res - 1 : 1 - res;\n}\n\n/**\n * Returns the complmentary error function erfc(x)\n *\n * @param {number} x An argument.\n * @return {number} The result.\n * @link https://github.com/jstat/jstat/blob/65ce096a99f753d6a22482e5e74accbfc1c33767/dist/jstat.js#L1599\n */\nfunction erfc(x: number): number {\n  return 1 - erf(x);\n}\n\n/**\n * Calculates Kendall's tau, a correlation measure for ordinal data, and an associated p-value.\n * Returns: Kendall's tau, two-tailed p-value.\n * Derived from older SciPy: http://web.mit.edu/6.863/spring2011/packages/scipy_src/scipy/stats/stats.py\n *\n * @export\n * @param {number[]} x The first array.\n * @param {number[]} y The second array.\n * @return {Options} The result.\n * @link https://github.com/pdfernhout/narrafirma/blob/\n * c9c122d577a4b8868ce603badabbb7d10f45740c/webapp/source/statistics/kendallsTau.ts#L8\n */\nexport function kendallsTau(x: number[], y: number[]): Options {\n  let n1 = 0;\n  let n2 = 0;\n  let iss = 0;\n  for (let j = 0; j < x.length - 1; j++) {\n    for (let k = j + 1; k < y.length; k++) {\n      const a1 = x[j] - x[k];\n      const a2 = y[j] - y[k];\n      const aa = a1 * a2;\n      if (aa) {\n        // neither array has a tie\n        n1 = n1 + 1;\n        n2 = n2 + 1;\n        if (aa > 0) {\n          iss = iss + 1;\n        } else {\n          iss = iss - 1;\n        }\n      } else {\n        if (a1) {\n          n1 = n1 + 1;\n        }\n        if (a2) {\n          n2 = n2 + 1;\n        }\n      }\n    }\n  }\n  const tau = iss / Math.sqrt(n1 * n2);\n  const svar = (4.0 * x.length + 10.0) / (9.0 * x.length * (x.length - 1));\n  const z = tau / Math.sqrt(svar);\n  const prob = erfc(Math.abs(z) / 1.4142136);\n  return {test: tau, z: z, prob: prob};\n}\n"]}

package/src/multiple-tests.d.ts

@@ -1,35 +1,35 @@
-/**
- * pvalue correction for false discovery rate
- *
- * @export
- * @param {Float32Array} pvals Set of p-values of the individual tests.
- * @param {number} [alpha=0.05] Family-wise error rate. Defaults to 0.05.
- * @param {string} [method='n'] {'i', 'indep', 'p', 'poscorr', 'n', 'negcorr'}, optional
- * Which method to use for FDR correction.
- * ``{'i', 'indep', 'p', 'poscorr'}`` all refer to ``fdr_bh``
- * (Benjamini/Hochberg for independent or positively
- * correlated tests). ``{'n', 'negcorr'}`` both refer to ``fdr_by``
- * (Benjamini/Yekutieli for general or negatively correlated tests).
- * Defaults to 'n'.
- * @param {boolean} [isSorted=false] If False (default), the p_values will be sorted, but the corrected
- * pvalues are in the original order. If True, then it assumed that the
- * pvalues are already sorted in ascending order.
- * @return {[Array<boolean>, Float32Array]} rejected : ndarray, bool
- * True if a hypothesis is rejected, False if not
- * pvalue-corrected : ndarray
- * pvalues adjusted for multiple hypothesis testing to limit FDR
- * @see
- * If there is prior information on the fraction of true hypothesis, then alpha
- * should be set to ``alpha * m/m_0`` where m is the number of tests,
- * given by the p-values, and m_0 is an estimate of the true hypothesis.
- * (see Benjamini, Krieger and Yekuteli)
- *
- * The two-step method of Benjamini, Krieger and Yekutiel that estimates the number
- * of false hypotheses will be available (soon).
- *
- * Both methods exposed via this function (Benjamini/Hochberg, Benjamini/Yekutieli)
- * are also available in the function ``multipletests``, as ``method="fdr_bh"`` and
- * ``method="fdr_by"``, respectively.
- */
-export declare function fdrcorrection(pvals: Float32Array, alpha?: number, method?: string, isSorted?: boolean): [Array<boolean>, Float32Array];
+/**
+ * pvalue correction for false discovery rate
+ *
+ * @export
+ * @param {Float32Array} pvals Set of p-values of the individual tests.
+ * @param {number} [alpha=0.05] Family-wise error rate. Defaults to 0.05.
+ * @param {string} [method='n'] {'i', 'indep', 'p', 'poscorr', 'n', 'negcorr'}, optional
+ * Which method to use for FDR correction.
+ * ``{'i', 'indep', 'p', 'poscorr'}`` all refer to ``fdr_bh``
+ * (Benjamini/Hochberg for independent or positively
+ * correlated tests). ``{'n', 'negcorr'}`` both refer to ``fdr_by``
+ * (Benjamini/Yekutieli for general or negatively correlated tests).
+ * Defaults to 'n'.
+ * @param {boolean} [isSorted=false] If False (default), the p_values will be sorted, but the corrected
+ * pvalues are in the original order. If True, then it assumed that the
+ * pvalues are already sorted in ascending order.
+ * @return {[Array<boolean>, Float32Array]} rejected : ndarray, bool
+ * True if a hypothesis is rejected, False if not
+ * pvalue-corrected : ndarray
+ * pvalues adjusted for multiple hypothesis testing to limit FDR
+ * @see
+ * If there is prior information on the fraction of true hypothesis, then alpha
+ * should be set to ``alpha * m/m_0`` where m is the number of tests,
+ * given by the p-values, and m_0 is an estimate of the true hypothesis.
+ * (see Benjamini, Krieger and Yekuteli)
+ *
+ * The two-step method of Benjamini, Krieger and Yekutiel that estimates the number
+ * of false hypotheses will be available (soon).
+ *
+ * Both methods exposed via this function (Benjamini/Hochberg, Benjamini/Yekutieli)
+ * are also available in the function ``multipletests``, as ``method="fdr_bh"`` and
+ * ``method="fdr_by"``, respectively.
+ */
+export declare function fdrcorrection(pvals: Float32Array, alpha?: number, method?: string, isSorted?: boolean): [Array<boolean>, Float32Array];
 //# sourceMappingURL=multiple-tests.d.ts.map

package/src/multiple-tests.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"multiple-tests.d.ts","sourceRoot":"","sources":["multiple-tests.ts"],"names":[],"mappings":"AA2IA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,aAAa,CAC3B,KAAK,EAAE,YAAY,EACnB,KAAK,GAAE,MAAa,EACpB,MAAM,GAAE,MAAW,EACnB,QAAQ,GAAE,OAAe,GAAG,CAAC,KAAK,CAAC,OAAO,CAAC,EAAE,YAAY,CAAC,CAyD3D"}
+{"version":3,"file":"multiple-tests.d.ts","sourceRoot":"","sources":["multiple-tests.ts"],"names":[],"mappings":"AAoIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,aAAa,CAC3B,KAAK,EAAE,YAAY,EACnB,KAAK,GAAE,MAAa,EACpB,MAAM,GAAE,MAAW,EACnB,QAAQ,GAAE,OAAe,GAAG,CAAC,KAAK,CAAC,OAAO,CAAC,EAAE,YAAY,CAAC,CAyD3D"}

package/src/multiple-tests.js

@@ -1,206 +1,202 @@
-/** @type {*} A dictionary of basic binary operations. */
-const _operations = {
-    '+': (a, b) => (a + b),
-    '-': (a, b) => (a - b),
-    '*': (a, b) => (a * b),
-    '/': (a, b) => (a / b),
-    'min': (a, b) => (a < b ? a : b),
-    'max': (a, b) => (a > b ? a : b),
-};
-/**
- * Returns the indices that would sort an array.
- *
- * @param {Float32Array} values Array to sort.
- * @return {Int32Array} Array of indices that sort values along the first axis.
- */
-function _argsort(values) {
-    const v = Array.from(values);
-    const argsort = (arr) => arr
-        .map((v, i) => [v, i]) // Decorate with index
-        .sort((a, b) => (a[0] == b[0] ? 0 : (a[0] > b[0] ? 1 : -1)))
-        .map((v, _) => v[1]); // Undecorate
-    const forder = argsort(v);
-    return Int32Array.from(forder);
-}
-/**
- * Take elements from an array.
- *
- * @param {Int32Array} order The indices of the values to extract.
- * @param {Float32Array} values The source array.
- * @return {Float32Array} The returned array has the same type as values.
- */
-function _take(order, values) {
-    // TODO: Implement a general function for TypedArray.
-    return Float32Array.from(values).map((_, i) => values[order[i]]);
-}
-/**
- * Assign elements of an array following the order given (floating-point version).
- *
- * @param {Float32Array} values The source array.
- * @param {Int32Array} order The order given.
- * @return {Float32Array} The returned array has the same type as values.
- */
-function _give(values, order) {
-    const v = Float32Array.from(values);
-    for (let i = 0; i < order.length; ++i) {
-        v[order[i]] = values[i];
-    }
-    return v;
-}
-/**
- * Assign elements of an array following the order given (boolean version).
- *
- * @param {Array<boolean>} values The source array.
- * @param {Int32Array} order The order given.
- * @return {Array<boolean>} The returned array has the same type as values.
- */
-function _giveb(values, order) {
-    const v = Array.from(values);
-    for (let i = 0; i < order.length; ++i) {
-        v[order[i]] = values[i];
-    }
-    return v;
-}
-/**
- * No frills empirical cdf used in fdrcorrection.
- *
- * @param {Float32Array} x The source array to take a dimension from.
- * @return {Float32Array} Empirical cdf.
- */
-function _ecdf(x) {
-    const nobs = x.length;
-    return Float32Array.from(x).map((_, i) => (i + 1) / nobs);
-}
-/**
- * cm = np.sum(1./np.arange(1, len(pvals_sorted)+1))
- *
- * @param {number} n The number given.
- * @return {number} cm value.
- */
-function _cm(n) {
-    let sum = 0;
-    for (let i = 0; i < n; ++i) {
-        sum += 1 / (i + 1);
-    }
-    return sum;
-}
-/**
- * Basic operation under a vector and a scalar.
- *
- * @param {Float32Array} values The source vector.
- * @param {number} scale The scalar.
- * @param {string} [op='*'] The operation to perform.
- * @return {Float32Array} New vector as a result of the operation.
- */
-function _factor(values, scale, op = '*') {
-    return Float32Array.from(values).map((v, _) => _operations[op](v, scale));
-}
-/**
- * Basic operation under two vectors.
- *
- * @param {Float32Array} values The first vector.
- * @param {Float32Array} scale The second vector.
- * @param {string} [op='*'] The operation to perform.
- * @return {Float32Array} New vector as a result of the operation.
- */
-function _vfactor(values, scale, op = '*') {
-    return Float32Array.from(values).map((v, i) => _operations[op](v, scale[i]));
-}
-/**
- * Accumulate the result of applying the min operator to all elements.
- *
- * @param {Float32Array} values The array to act on.
- * @return {Float32Array} The accumulated values.
- */
-function _minimumAccumulate(values) {
-    const nItems = values.length;
-    const r = Float32Array.from(values);
-    for (let i = 0; i < nItems; ++i) {
-        r[i] = values.slice(0, i + 1).reduce((a, b, _, __) => (_operations['min'](a, b)));
-    }
-    return r;
-}
-/**
- * pvalue correction for false discovery rate
- *
- * @export
- * @param {Float32Array} pvals Set of p-values of the individual tests.
- * @param {number} [alpha=0.05] Family-wise error rate. Defaults to 0.05.
- * @param {string} [method='n'] {'i', 'indep', 'p', 'poscorr', 'n', 'negcorr'}, optional
- * Which method to use for FDR correction.
- * ``{'i', 'indep', 'p', 'poscorr'}`` all refer to ``fdr_bh``
- * (Benjamini/Hochberg for independent or positively
- * correlated tests). ``{'n', 'negcorr'}`` both refer to ``fdr_by``
- * (Benjamini/Yekutieli for general or negatively correlated tests).
- * Defaults to 'n'.
- * @param {boolean} [isSorted=false] If False (default), the p_values will be sorted, but the corrected
- * pvalues are in the original order. If True, then it assumed that the
- * pvalues are already sorted in ascending order.
- * @return {[Array<boolean>, Float32Array]} rejected : ndarray, bool
- * True if a hypothesis is rejected, False if not
- * pvalue-corrected : ndarray
- * pvalues adjusted for multiple hypothesis testing to limit FDR
- * @see
- * If there is prior information on the fraction of true hypothesis, then alpha
- * should be set to ``alpha * m/m_0`` where m is the number of tests,
- * given by the p-values, and m_0 is an estimate of the true hypothesis.
- * (see Benjamini, Krieger and Yekuteli)
- *
- * The two-step method of Benjamini, Krieger and Yekutiel that estimates the number
- * of false hypotheses will be available (soon).
- *
- * Both methods exposed via this function (Benjamini/Hochberg, Benjamini/Yekutieli)
- * are also available in the function ``multipletests``, as ``method="fdr_bh"`` and
- * ``method="fdr_by"``, respectively.
- */
-export function fdrcorrection(pvals, alpha = 0.05, method = 'n', isSorted = false) {
-    const nItems = pvals.length;
-    let pvalsSorted;
-    let pvalsSortind;
-    let cm = 0;
-    if (!isSorted) {
-        pvalsSortind = _argsort(pvals);
-        pvalsSorted = _take(pvalsSortind, pvals);
-    }
-    else {
-        pvalsSortind = new Int32Array(nItems).fill(0).map((_, i) => (i));
-        pvalsSorted = pvals; // alias
-    }
-    let ecdffactor = _ecdf(pvalsSorted);
-    if (['i', 'indep', 'p', 'poscorr'].includes(method)) {
-        ;
-    }
-    else if (['n', 'negcorr'].includes(method)) {
-        cm = _cm(nItems);
-        ecdffactor = _factor(ecdffactor, cm, '/');
-    }
-    else {
-        throw new Error('only indep and negcorr implemented');
-    }
-    const reject = new Array(nItems).fill(false);
-    let rejectmax = -1;
-    for (let i = 0; i < nItems; ++i) {
-        if (pvalsSorted[i] <= ecdffactor[i] * alpha) {
-            rejectmax = i;
-        }
-    }
-    if (rejectmax >= 0) {
-        for (let i = 0; i < rejectmax; ++i) {
-            reject[i] = true;
-        }
-    }
-    let pvalsCorrected = _vfactor(pvalsSorted, ecdffactor, '/');
-    pvalsCorrected = _minimumAccumulate(pvalsCorrected.reverse()).reverse();
-    for (let i = 0; i < nItems; ++i) {
-        if (pvalsCorrected[i] > 1) {
-            pvalsCorrected[i] = 1;
-        }
-    }
-    if (!isSorted) {
-        const pvalsCorrected_ = _give(pvalsCorrected, pvalsSortind);
-        const reject_ = _giveb(reject, pvalsSortind);
-        return [reject_, pvalsCorrected_];
-    }
-    return [reject, pvalsCorrected];
-}
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"multiple-tests.js","sourceRoot":"","sources":["multiple-tests.ts"],"names":[],"mappings":"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","sourcesContent":["/** @type {*} A dictionary of basic binary operations. */\r\nconst _operations: {[name: string]: Function} = {\r\n  '+': (a: number, b: number) => (a + b),\r\n  '-': (a: number, b: number) => (a - b),\r\n  '*': (a: number, b: number) => (a * b),\r\n  '/': (a: number, b: number) => (a / b),\r\n  'min': (a: number, b: number) => (a < b ? a : b),\r\n  'max': (a: number, b: number) => (a > b ? a : b),\r\n};\r\n\r\n/**\r\n * Returns the indices that would sort an array.\r\n *\r\n * @param {Float32Array} values Array to sort.\r\n * @return {Int32Array} Array of indices that sort values along the first axis.\r\n */\r\nfunction _argsort(values: Float32Array): Int32Array {\r\n  const v = Array.from(values);\r\n\r\n  const argsort = (arr: number[]) => arr\r\n    .map((v, i) => [v, i]) // Decorate with index\r\n    .sort((a, b) => (a[0] == b[0] ? 0 : (a[0] > b[0] ? 1 : -1)))\r\n    .map((v, _) => v[1]); // Undecorate\r\n\r\n  const forder = argsort(v);\r\n\r\n  return Int32Array.from(forder);\r\n}\r\n\r\n\r\n/**\r\n * Take elements from an array.\r\n *\r\n * @param {Int32Array} order The indices of the values to extract.\r\n * @param {Float32Array} values The source array.\r\n * @return {Float32Array} The returned array has the same type as values.\r\n */\r\nfunction _take(order: Int32Array, values: Float32Array): Float32Array {\r\n  // TODO: Implement a general function for TypedArray.\r\n  return Float32Array.from(values).map((_, i) => values[order[i]]);\r\n}\r\n\r\n/**\r\n * Assign elements of an array following the order given (floating-point version).\r\n *\r\n * @param {Float32Array} values The source array.\r\n * @param {Int32Array} order The order given.\r\n * @return {Float32Array} The returned array has the same type as values.\r\n */\r\nfunction _give(values: Float32Array, order: Int32Array): Float32Array {\r\n  const v = Float32Array.from(values);\r\n\r\n  for (let i = 0; i < order.length; ++i) {\r\n    v[order[i]] = values[i];\r\n  }\r\n  return v;\r\n}\r\n\r\n/**\r\n * Assign elements of an array following the order given (boolean version).\r\n *\r\n * @param {Array<boolean>} values The source array.\r\n * @param {Int32Array} order The order given.\r\n * @return {Array<boolean>} The returned array has the same type as values.\r\n */\r\nfunction _giveb(values: Array<boolean>, order: Int32Array): Array<boolean> {\r\n  const v = Array.from(values);\r\n\r\n  for (let i = 0; i < order.length; ++i) {\r\n    v[order[i]] = values[i];\r\n  }\r\n  return v;\r\n}\r\n\r\n/**\r\n * No frills empirical cdf used in fdrcorrection.\r\n *\r\n * @param {Float32Array} x The source array to take a dimension from.\r\n * @return {Float32Array} Empirical cdf.\r\n */\r\nfunction _ecdf(x: Float32Array): Float32Array {\r\n  const nobs = x.length;\r\n  return Float32Array.from(x).map((_, i) => (i+1)/nobs);\r\n}\r\n\r\n/**\r\n * cm = np.sum(1./np.arange(1, len(pvals_sorted)+1))\r\n *\r\n * @param {number} n The number given.\r\n * @return {number} cm value.\r\n */\r\nfunction _cm(n: number): number {\r\n  let sum = 0;\r\n  for (let i = 0; i < n; ++i) {\r\n    sum += 1 / (i+1);\r\n  }\r\n  return sum;\r\n}\r\n\r\n/**\r\n * Basic operation under a vector and a scalar.\r\n *\r\n * @param {Float32Array} values The source vector.\r\n * @param {number} scale The scalar.\r\n * @param {string} [op='*'] The operation to perform.\r\n * @return {Float32Array} New vector as a result of the operation.\r\n */\r\nfunction _factor(values: Float32Array, scale: number, op = '*'): Float32Array {\r\n  return Float32Array.from(values).map((v, _) => _operations[op](v, scale));\r\n}\r\n\r\n/**\r\n * Basic operation under two vectors.\r\n *\r\n * @param {Float32Array} values The first vector.\r\n * @param {Float32Array} scale The second vector.\r\n * @param {string} [op='*'] The operation to perform.\r\n * @return {Float32Array} New vector as a result of the operation.\r\n */\r\nfunction _vfactor(values: Float32Array, scale: Float32Array, op = '*'): Float32Array {\r\n  return Float32Array.from(values).map((v, i) => _operations[op](v, scale[i]));\r\n}\r\n\r\n/**\r\n * Accumulate the result of applying the min operator to all elements.\r\n *\r\n * @param {Float32Array} values The array to act on.\r\n * @return {Float32Array} The accumulated values.\r\n */\r\nfunction _minimumAccumulate(values: Float32Array): Float32Array {\r\n  const nItems = values.length;\r\n  const r = Float32Array.from(values);\r\n\r\n  for (let i = 0; i < nItems; ++i) {\r\n    r[i] = values.slice(0, i+1).reduce((a, b, _, __) => (_operations['min'](a, b)));\r\n  }\r\n  return r;\r\n}\r\n\r\n/**\r\n * pvalue correction for false discovery rate\r\n *\r\n * @export\r\n * @param {Float32Array} pvals Set of p-values of the individual tests.\r\n * @param {number} [alpha=0.05] Family-wise error rate. Defaults to 0.05.\r\n * @param {string} [method='n'] {'i', 'indep', 'p', 'poscorr', 'n', 'negcorr'}, optional\r\n * Which method to use for FDR correction.\r\n * ``{'i', 'indep', 'p', 'poscorr'}`` all refer to ``fdr_bh``\r\n * (Benjamini/Hochberg for independent or positively\r\n * correlated tests). ``{'n', 'negcorr'}`` both refer to ``fdr_by``\r\n * (Benjamini/Yekutieli for general or negatively correlated tests).\r\n * Defaults to 'n'.\r\n * @param {boolean} [isSorted=false] If False (default), the p_values will be sorted, but the corrected\r\n * pvalues are in the original order. If True, then it assumed that the\r\n * pvalues are already sorted in ascending order.\r\n * @return {[Array<boolean>, Float32Array]} rejected : ndarray, bool\r\n * True if a hypothesis is rejected, False if not\r\n * pvalue-corrected : ndarray\r\n * pvalues adjusted for multiple hypothesis testing to limit FDR\r\n * @see\r\n * If there is prior information on the fraction of true hypothesis, then alpha\r\n * should be set to ``alpha * m/m_0`` where m is the number of tests,\r\n * given by the p-values, and m_0 is an estimate of the true hypothesis.\r\n * (see Benjamini, Krieger and Yekuteli)\r\n *\r\n * The two-step method of Benjamini, Krieger and Yekutiel that estimates the number\r\n * of false hypotheses will be available (soon).\r\n *\r\n * Both methods exposed via this function (Benjamini/Hochberg, Benjamini/Yekutieli)\r\n * are also available in the function ``multipletests``, as ``method=\"fdr_bh\"`` and\r\n * ``method=\"fdr_by\"``, respectively.\r\n */\r\nexport function fdrcorrection(\r\n  pvals: Float32Array,\r\n  alpha: number = 0.05,\r\n  method: string ='n',\r\n  isSorted: boolean = false): [Array<boolean>, Float32Array]\r\n// eslint-disable-next-line brace-style\r\n{\r\n  const nItems = pvals.length;\r\n  let pvalsSorted: Float32Array;\r\n  let pvalsSortind: Int32Array;\r\n  let cm = 0;\r\n\r\n  if (!isSorted) {\r\n    pvalsSortind = _argsort(pvals);\r\n    pvalsSorted = _take(pvalsSortind, pvals);\r\n  } else {\r\n    pvalsSortind = new Int32Array(nItems).fill(0).map((_, i) => (i));\r\n    pvalsSorted = pvals; // alias\r\n  }\r\n\r\n  let ecdffactor = _ecdf(pvalsSorted);\r\n\r\n  if (['i', 'indep', 'p', 'poscorr'].includes(method)) {\r\n    ;\r\n  } else if (['n', 'negcorr'].includes(method)) {\r\n    cm = _cm(nItems);\r\n    ecdffactor = _factor(ecdffactor, cm, '/');\r\n  } else {\r\n    throw new Error('only indep and negcorr implemented');\r\n  }\r\n\r\n  const reject: boolean[] = new Array(nItems).fill(false);\r\n  let rejectmax = -1;\r\n\r\n  for (let i = 0; i < nItems; ++i) {\r\n    if (pvalsSorted[i] <= ecdffactor[i]*alpha) {\r\n      rejectmax = i;\r\n    }\r\n  }\r\n\r\n  if (rejectmax >= 0) {\r\n    for (let i = 0; i < rejectmax; ++i) {\r\n      reject[i] = true;\r\n    }\r\n  }\r\n\r\n  let pvalsCorrected = _vfactor(pvalsSorted, ecdffactor, '/');\r\n  pvalsCorrected = _minimumAccumulate(pvalsCorrected.reverse()).reverse();\r\n\r\n  for (let i = 0; i < nItems; ++i) {\r\n    if (pvalsCorrected[i] > 1) {\r\n      pvalsCorrected[i] = 1;\r\n    }\r\n  }\r\n\r\n  if (!isSorted) {\r\n    const pvalsCorrected_ = _give(pvalsCorrected, pvalsSortind);\r\n    const reject_ = _giveb(reject, pvalsSortind);\r\n    return [reject_, pvalsCorrected_];\r\n  }\r\n  return [reject, pvalsCorrected];\r\n}\r\n"]}
+import { ArrayUtils } from '@datagrok-libraries/utils/src/array-utils';
+/** @type {*} A dictionary of basic binary operations. */
+const _operations = {
+    '+': (a, b) => (a + b),
+    '-': (a, b) => (a - b),
+    '*': (a, b) => (a * b),
+    '/': (a, b) => (a / b),
+    'min': (a, b) => (a < b ? a : b),
+    'max': (a, b) => (a > b ? a : b),
+};
+/**
+ * Returns the indices that would sort an array.
+ *
+ * @param {Float32Array} values Array to sort.
+ * @return {Int32Array} Array of indices that sort values along the first axis.
+ */
+function _argsort(values) {
+    const array = Array.from(values);
+    return Int32Array.from(ArrayUtils.argSort(array));
+}
+/**
+ * Take elements from an array.
+ *
+ * @param {Int32Array} order The indices of the values to extract.
+ * @param {Float32Array} values The source array.
+ * @return {Float32Array} The returned array has the same type as values.
+ */
+function _take(order, values) {
+    // TODO: Implement a general function for TypedArray.
+    return Float32Array.from(values).map((_, i) => values[order[i]]);
+}
+/**
+ * Assign elements of an array following the order given (floating-point version).
+ *
+ * @param {Float32Array} values The source array.
+ * @param {Int32Array} order The order given.
+ * @return {Float32Array} The returned array has the same type as values.
+ */
+function _give(values, order) {
+    const v = Float32Array.from(values);
+    for (let i = 0; i < order.length; ++i) {
+        v[order[i]] = values[i];
+    }
+    return v;
+}
+/**
+ * Assign elements of an array following the order given (boolean version).
+ *
+ * @param {Array<boolean>} values The source array.
+ * @param {Int32Array} order The order given.
+ * @return {Array<boolean>} The returned array has the same type as values.
+ */
+function _giveb(values, order) {
+    const v = Array.from(values);
+    for (let i = 0; i < order.length; ++i) {
+        v[order[i]] = values[i];
+    }
+    return v;
+}
+/**
+ * No frills empirical cdf used in fdrcorrection.
+ *
+ * @param {Float32Array} x The source array to take a dimension from.
+ * @return {Float32Array} Empirical cdf.
+ */
+function _ecdf(x) {
+    const nobs = x.length;
+    return Float32Array.from(x).map((_, i) => (i + 1) / nobs);
+}
+/**
+ * cm = np.sum(1./np.arange(1, len(pvals_sorted)+1))
+ *
+ * @param {number} n The number given.
+ * @return {number} cm value.
+ */
+function _cm(n) {
+    let sum = 0;
+    for (let i = 0; i < n; ++i) {
+        sum += 1 / (i + 1);
+    }
+    return sum;
+}
+/**
+ * Basic operation under a vector and a scalar.
+ *
+ * @param {Float32Array} values The source vector.
+ * @param {number} scale The scalar.
+ * @param {string} [op='*'] The operation to perform.
+ * @return {Float32Array} New vector as a result of the operation.
+ */
+function _factor(values, scale, op = '*') {
+    return Float32Array.from(values).map((v, _) => _operations[op](v, scale));
+}
+/**
+ * Basic operation under two vectors.
+ *
+ * @param {Float32Array} values The first vector.
+ * @param {Float32Array} scale The second vector.
+ * @param {string} [op='*'] The operation to perform.
+ * @return {Float32Array} New vector as a result of the operation.
+ */
+function _vfactor(values, scale, op = '*') {
+    return Float32Array.from(values).map((v, i) => _operations[op](v, scale[i]));
+}
+/**
+ * Accumulate the result of applying the min operator to all elements.
+ *
+ * @param {Float32Array} values The array to act on.
+ * @return {Float32Array} The accumulated values.
+ */
+function _minimumAccumulate(values) {
+    const nItems = values.length;
+    const r = Float32Array.from(values);
+    for (let i = 0; i < nItems; ++i) {
+        r[i] = values.slice(0, i + 1).reduce((a, b, _, __) => (_operations['min'](a, b)));
+    }
+    return r;
+}
+/**
+ * pvalue correction for false discovery rate
+ *
+ * @export
+ * @param {Float32Array} pvals Set of p-values of the individual tests.
+ * @param {number} [alpha=0.05] Family-wise error rate. Defaults to 0.05.
+ * @param {string} [method='n'] {'i', 'indep', 'p', 'poscorr', 'n', 'negcorr'}, optional
+ * Which method to use for FDR correction.
+ * ``{'i', 'indep', 'p', 'poscorr'}`` all refer to ``fdr_bh``
+ * (Benjamini/Hochberg for independent or positively
+ * correlated tests). ``{'n', 'negcorr'}`` both refer to ``fdr_by``
+ * (Benjamini/Yekutieli for general or negatively correlated tests).
+ * Defaults to 'n'.
+ * @param {boolean} [isSorted=false] If False (default), the p_values will be sorted, but the corrected
+ * pvalues are in the original order. If True, then it assumed that the
+ * pvalues are already sorted in ascending order.
+ * @return {[Array<boolean>, Float32Array]} rejected : ndarray, bool
+ * True if a hypothesis is rejected, False if not
+ * pvalue-corrected : ndarray
+ * pvalues adjusted for multiple hypothesis testing to limit FDR
+ * @see
+ * If there is prior information on the fraction of true hypothesis, then alpha
+ * should be set to ``alpha * m/m_0`` where m is the number of tests,
+ * given by the p-values, and m_0 is an estimate of the true hypothesis.
+ * (see Benjamini, Krieger and Yekuteli)
+ *
+ * The two-step method of Benjamini, Krieger and Yekutiel that estimates the number
+ * of false hypotheses will be available (soon).
+ *
+ * Both methods exposed via this function (Benjamini/Hochberg, Benjamini/Yekutieli)
+ * are also available in the function ``multipletests``, as ``method="fdr_bh"`` and
+ * ``method="fdr_by"``, respectively.
+ */
+export function fdrcorrection(pvals, alpha = 0.05, method = 'n', isSorted = false) {
+    const nItems = pvals.length;
+    let pvalsSorted;
+    let pvalsSortind;
+    let cm = 0;
+    if (!isSorted) {
+        pvalsSortind = _argsort(pvals);
+        pvalsSorted = _take(pvalsSortind, pvals);
+    }
+    else {
+        pvalsSortind = new Int32Array(nItems).fill(0).map((_, i) => (i));
+        pvalsSorted = pvals; // alias
+    }
+    let ecdffactor = _ecdf(pvalsSorted);
+    if (['i', 'indep', 'p', 'poscorr'].includes(method)) {
+        ;
+    }
+    else if (['n', 'negcorr'].includes(method)) {
+        cm = _cm(nItems);
+        ecdffactor = _factor(ecdffactor, cm, '/');
+    }
+    else {
+        throw new Error('only indep and negcorr implemented');
+    }
+    const reject = new Array(nItems).fill(false);
+    let rejectmax = -1;
+    for (let i = 0; i < nItems; ++i) {
+        if (pvalsSorted[i] <= ecdffactor[i] * alpha) {
+            rejectmax = i;
+        }
+    }
+    if (rejectmax >= 0) {
+        for (let i = 0; i < rejectmax; ++i) {
+            reject[i] = true;
+        }
+    }
+    let pvalsCorrected = _vfactor(pvalsSorted, ecdffactor, '/');
+    pvalsCorrected = _minimumAccumulate(pvalsCorrected.reverse()).reverse();
+    for (let i = 0; i < nItems; ++i) {
+        if (pvalsCorrected[i] > 1) {
+            pvalsCorrected[i] = 1;
+        }
+    }
+    if (!isSorted) {
+        const pvalsCorrected_ = _give(pvalsCorrected, pvalsSortind);
+        const reject_ = _giveb(reject, pvalsSortind);
+        return [reject_, pvalsCorrected_];
+    }
+    return [reject, pvalsCorrected];
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"multiple-tests.js","sourceRoot":"","sources":["multiple-tests.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,UAAU,EAAC,MAAM,2CAA2C,CAAC;AAErE,yDAAyD;AACzD,MAAM,WAAW,GAA+B;IAC9C,GAAG,EAAE,CAAC,CAAS,EAAE,CAAS,EAAE,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;IACtC,GAAG,EAAE,CAAC,CAAS,EAAE,CAAS,EAAE,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;IACtC,GAAG,EAAE,CAAC,CAAS,EAAE,CAAS,EAAE,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;IACtC,GAAG,EAAE,CAAC,CAAS,EAAE,CAAS,EAAE,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;IACtC,KAAK,EAAE,CAAC,CAAS,EAAE,CAAS,EAAE,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IAChD,KAAK,EAAE,CAAC,CAAS,EAAE,CAAS,EAAE,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;CACjD,CAAC;AAEF;;;;;GAKG;AACH,SAAS,QAAQ,CAAC,MAAoB;IACpC,MAAM,KAAK,GAAG,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IACjC,OAAO,UAAU,CAAC,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC;AACpD,CAAC;AAED;;;;;;GAMG;AACH,SAAS,KAAK,CAAC,KAAiB,EAAE,MAAoB;IACpD,qDAAqD;IACrD,OAAO,YAAY,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AACnE,CAAC;AAED;;;;;;GAMG;AACH,SAAS,KAAK,CAAC,MAAoB,EAAE,KAAiB;IACpD,MAAM,CAAC,GAAG,YAAY,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IAEpC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,EAAE,CAAC,EAAE;QACrC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;KACzB;IACD,OAAO,CAAC,CAAC;AACX,CAAC;AAED;;;;;;GAMG;AACH,SAAS,MAAM,CAAC,MAAsB,EAAE,KAAiB;IACvD,MAAM,CAAC,GAAG,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IAE7B,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,EAAE,CAAC,EAAE;QACrC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;KACzB;IACD,OAAO,CAAC,CAAC;AACX,CAAC;AAED;;;;;GAKG;AACH,SAAS,KAAK,CAAC,CAAe;IAC5B,MAAM,IAAI,GAAG,CAAC,CAAC,MAAM,CAAC;IACtB,OAAO,YAAY,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,GAAC,CAAC,CAAC,GAAC,IAAI,CAAC,CAAC;AACxD,CAAC;AAED;;;;;GAKG;AACH,SAAS,GAAG,CAAC,CAAS;IACpB,IAAI,GAAG,GAAG,CAAC,CAAC;IACZ,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,EAAE,CAAC,EAAE;QAC1B,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,GAAC,CAAC,CAAC,CAAC;KAClB;IACD,OAAO,GAAG,CAAC;AACb,CAAC;AAED;;;;;;;GAOG;AACH,SAAS,OAAO,CAAC,MAAoB,EAAE,KAAa,EAAE,EAAE,GAAG,GAAG;IAC5D,OAAO,YAAY,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,WAAW,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC;AAC5E,CAAC;AAED;;;;;;;GAOG;AACH,SAAS,QAAQ,CAAC,MAAoB,EAAE,KAAmB,EAAE,EAAE,GAAG,GAAG;IACnE,OAAO,YAAY,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,WAAW,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AAC/E,CAAC;AAED;;;;;GAKG;AACH,SAAS,kBAAkB,CAAC,MAAoB;IAC9C,MAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;IAC7B,MAAM,CAAC,GAAG,YAAY,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IAEpC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,EAAE,EAAE,CAAC,EAAE;QAC/B,CAAC,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,GAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;KACjF;IACD,OAAO,CAAC,CAAC;AACX,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,MAAM,UAAU,aAAa,CAC3B,KAAmB,EACnB,QAAgB,IAAI,EACpB,SAAgB,GAAG,EACnB,WAAoB,KAAK;IAGzB,MAAM,MAAM,GAAG,KAAK,CAAC,MAAM,CAAC;IAC5B,IAAI,WAAyB,CAAC;IAC9B,IAAI,YAAwB,CAAC;IAC7B,IAAI,EAAE,GAAG,CAAC,CAAC;IAEX,IAAI,CAAC,QAAQ,EAAE;QACb,YAAY,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAC;QAC/B,WAAW,GAAG,KAAK,CAAC,YAAY,EAAE,KAAK,CAAC,CAAC;KAC1C;SAAM;QACL,YAAY,GAAG,IAAI,UAAU,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QACjE,WAAW,GAAG,KAAK,CAAC,CAAC,QAAQ;KAC9B;IAED,IAAI,UAAU,GAAG,KAAK,CAAC,WAAW,CAAC,CAAC;IAEpC,IAAI,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,SAAS,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAE;QACnD,CAAC;KACF;SAAM,IAAI,CAAC,GAAG,EAAE,SAAS,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAE;QAC5C,EAAE,GAAG,GAAG,CAAC,MAAM,CAAC,CAAC;QACjB,UAAU,GAAG,OAAO,CAAC,UAAU,EAAE,EAAE,EAAE,GAAG,CAAC,CAAC;KAC3C;SAAM;QACL,MAAM,IAAI,KAAK,CAAC,oCAAoC,CAAC,CAAC;KACvD;IAED,MAAM,MAAM,GAAc,IAAI,KAAK,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IACxD,IAAI,SAAS,GAAG,CAAC,CAAC,CAAC;IAEnB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,EAAE,EAAE,CAAC,EAAE;QAC/B,IAAI,WAAW,CAAC,CAAC,CAAC,IAAI,UAAU,CAAC,CAAC,CAAC,GAAC,KAAK,EAAE;YACzC,SAAS,GAAG,CAAC,CAAC;SACf;KACF;IAED,IAAI,SAAS,IAAI,CAAC,EAAE;QAClB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,SAAS,EAAE,EAAE,CAAC,EAAE;YAClC,MAAM,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;SAClB;KACF;IAED,IAAI,cAAc,GAAG,QAAQ,CAAC,WAAW,EAAE,UAAU,EAAE,GAAG,CAAC,CAAC;IAC5D,cAAc,GAAG,kBAAkB,CAAC,cAAc,CAAC,OAAO,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC;IAExE,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,EAAE,EAAE,CAAC,EAAE;QAC/B,IAAI,cAAc,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE;YACzB,cAAc,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;SACvB;KACF;IAED,IAAI,CAAC,QAAQ,EAAE;QACb,MAAM,eAAe,GAAG,KAAK,CAAC,cAAc,EAAE,YAAY,CAAC,CAAC;QAC5D,MAAM,OAAO,GAAG,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;QAC7C,OAAO,CAAC,OAAO,EAAE,eAAe,CAAC,CAAC;KACnC;IACD,OAAO,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;AAClC,CAAC","sourcesContent":["import {ArrayUtils} from '@datagrok-libraries/utils/src/array-utils';\n\n/** @type {*} A dictionary of basic binary operations. */\nconst _operations: {[name: string]: Function} = {\n  '+': (a: number, b: number) => (a + b),\n  '-': (a: number, b: number) => (a - b),\n  '*': (a: number, b: number) => (a * b),\n  '/': (a: number, b: number) => (a / b),\n  'min': (a: number, b: number) => (a < b ? a : b),\n  'max': (a: number, b: number) => (a > b ? a : b),\n};\n\n/**\n * Returns the indices that would sort an array.\n *\n * @param {Float32Array} values Array to sort.\n * @return {Int32Array} Array of indices that sort values along the first axis.\n */\nfunction _argsort(values: Float32Array): Int32Array {\n  const array = Array.from(values);\n  return Int32Array.from(ArrayUtils.argSort(array));\n}\n\n/**\n * Take elements from an array.\n *\n * @param {Int32Array} order The indices of the values to extract.\n * @param {Float32Array} values The source array.\n * @return {Float32Array} The returned array has the same type as values.\n */\nfunction _take(order: Int32Array, values: Float32Array): Float32Array {\n  // TODO: Implement a general function for TypedArray.\n  return Float32Array.from(values).map((_, i) => values[order[i]]);\n}\n\n/**\n * Assign elements of an array following the order given (floating-point version).\n *\n * @param {Float32Array} values The source array.\n * @param {Int32Array} order The order given.\n * @return {Float32Array} The returned array has the same type as values.\n */\nfunction _give(values: Float32Array, order: Int32Array): Float32Array {\n  const v = Float32Array.from(values);\n\n  for (let i = 0; i < order.length; ++i) {\n    v[order[i]] = values[i];\n  }\n  return v;\n}\n\n/**\n * Assign elements of an array following the order given (boolean version).\n *\n * @param {Array<boolean>} values The source array.\n * @param {Int32Array} order The order given.\n * @return {Array<boolean>} The returned array has the same type as values.\n */\nfunction _giveb(values: Array<boolean>, order: Int32Array): Array<boolean> {\n  const v = Array.from(values);\n\n  for (let i = 0; i < order.length; ++i) {\n    v[order[i]] = values[i];\n  }\n  return v;\n}\n\n/**\n * No frills empirical cdf used in fdrcorrection.\n *\n * @param {Float32Array} x The source array to take a dimension from.\n * @return {Float32Array} Empirical cdf.\n */\nfunction _ecdf(x: Float32Array): Float32Array {\n  const nobs = x.length;\n  return Float32Array.from(x).map((_, i) => (i+1)/nobs);\n}\n\n/**\n * cm = np.sum(1./np.arange(1, len(pvals_sorted)+1))\n *\n * @param {number} n The number given.\n * @return {number} cm value.\n */\nfunction _cm(n: number): number {\n  let sum = 0;\n  for (let i = 0; i < n; ++i) {\n    sum += 1 / (i+1);\n  }\n  return sum;\n}\n\n/**\n * Basic operation under a vector and a scalar.\n *\n * @param {Float32Array} values The source vector.\n * @param {number} scale The scalar.\n * @param {string} [op='*'] The operation to perform.\n * @return {Float32Array} New vector as a result of the operation.\n */\nfunction _factor(values: Float32Array, scale: number, op = '*'): Float32Array {\n  return Float32Array.from(values).map((v, _) => _operations[op](v, scale));\n}\n\n/**\n * Basic operation under two vectors.\n *\n * @param {Float32Array} values The first vector.\n * @param {Float32Array} scale The second vector.\n * @param {string} [op='*'] The operation to perform.\n * @return {Float32Array} New vector as a result of the operation.\n */\nfunction _vfactor(values: Float32Array, scale: Float32Array, op = '*'): Float32Array {\n  return Float32Array.from(values).map((v, i) => _operations[op](v, scale[i]));\n}\n\n/**\n * Accumulate the result of applying the min operator to all elements.\n *\n * @param {Float32Array} values The array to act on.\n * @return {Float32Array} The accumulated values.\n */\nfunction _minimumAccumulate(values: Float32Array): Float32Array {\n  const nItems = values.length;\n  const r = Float32Array.from(values);\n\n  for (let i = 0; i < nItems; ++i) {\n    r[i] = values.slice(0, i+1).reduce((a, b, _, __) => (_operations['min'](a, b)));\n  }\n  return r;\n}\n\n/**\n * pvalue correction for false discovery rate\n *\n * @export\n * @param {Float32Array} pvals Set of p-values of the individual tests.\n * @param {number} [alpha=0.05] Family-wise error rate. Defaults to 0.05.\n * @param {string} [method='n'] {'i', 'indep', 'p', 'poscorr', 'n', 'negcorr'}, optional\n * Which method to use for FDR correction.\n * ``{'i', 'indep', 'p', 'poscorr'}`` all refer to ``fdr_bh``\n * (Benjamini/Hochberg for independent or positively\n * correlated tests). ``{'n', 'negcorr'}`` both refer to ``fdr_by``\n * (Benjamini/Yekutieli for general or negatively correlated tests).\n * Defaults to 'n'.\n * @param {boolean} [isSorted=false] If False (default), the p_values will be sorted, but the corrected\n * pvalues are in the original order. If True, then it assumed that the\n * pvalues are already sorted in ascending order.\n * @return {[Array<boolean>, Float32Array]} rejected : ndarray, bool\n * True if a hypothesis is rejected, False if not\n * pvalue-corrected : ndarray\n * pvalues adjusted for multiple hypothesis testing to limit FDR\n * @see\n * If there is prior information on the fraction of true hypothesis, then alpha\n * should be set to ``alpha * m/m_0`` where m is the number of tests,\n * given by the p-values, and m_0 is an estimate of the true hypothesis.\n * (see Benjamini, Krieger and Yekuteli)\n *\n * The two-step method of Benjamini, Krieger and Yekutiel that estimates the number\n * of false hypotheses will be available (soon).\n *\n * Both methods exposed via this function (Benjamini/Hochberg, Benjamini/Yekutieli)\n * are also available in the function ``multipletests``, as ``method=\"fdr_bh\"`` and\n * ``method=\"fdr_by\"``, respectively.\n */\nexport function fdrcorrection(\n  pvals: Float32Array,\n  alpha: number = 0.05,\n  method: string ='n',\n  isSorted: boolean = false): [Array<boolean>, Float32Array]\n// eslint-disable-next-line brace-style\n{\n  const nItems = pvals.length;\n  let pvalsSorted: Float32Array;\n  let pvalsSortind: Int32Array;\n  let cm = 0;\n\n  if (!isSorted) {\n    pvalsSortind = _argsort(pvals);\n    pvalsSorted = _take(pvalsSortind, pvals);\n  } else {\n    pvalsSortind = new Int32Array(nItems).fill(0).map((_, i) => (i));\n    pvalsSorted = pvals; // alias\n  }\n\n  let ecdffactor = _ecdf(pvalsSorted);\n\n  if (['i', 'indep', 'p', 'poscorr'].includes(method)) {\n    ;\n  } else if (['n', 'negcorr'].includes(method)) {\n    cm = _cm(nItems);\n    ecdffactor = _factor(ecdffactor, cm, '/');\n  } else {\n    throw new Error('only indep and negcorr implemented');\n  }\n\n  const reject: boolean[] = new Array(nItems).fill(false);\n  let rejectmax = -1;\n\n  for (let i = 0; i < nItems; ++i) {\n    if (pvalsSorted[i] <= ecdffactor[i]*alpha) {\n      rejectmax = i;\n    }\n  }\n\n  if (rejectmax >= 0) {\n    for (let i = 0; i < rejectmax; ++i) {\n      reject[i] = true;\n    }\n  }\n\n  let pvalsCorrected = _vfactor(pvalsSorted, ecdffactor, '/');\n  pvalsCorrected = _minimumAccumulate(pvalsCorrected.reverse()).reverse();\n\n  for (let i = 0; i < nItems; ++i) {\n    if (pvalsCorrected[i] > 1) {\n      pvalsCorrected[i] = 1;\n    }\n  }\n\n  if (!isSorted) {\n    const pvalsCorrected_ = _give(pvalsCorrected, pvalsSortind);\n    const reject_ = _giveb(reject, pvalsSortind);\n    return [reject_, pvalsCorrected_];\n  }\n  return [reject, pvalsCorrected];\n}\n"]}

package/src/tests.d.ts

@@ -1,11 +1,12 @@
-declare type testStats = {
-    'p-value': number;
-    'Mean difference'?: number;
-    'Median difference'?: number;
-    'p-value more': number;
-    'p-value less': number;
-};
-export declare function tTest(arr1: number[], arr2: number[], devKnown?: boolean, devEqual?: boolean): testStats;
-export declare function uTest(x: number[], y: number[], continuity?: boolean): testStats;
-export {};
+declare type testStats = {
+    'p-value': number;
+    'Mean difference'?: number;
+    'Median difference'?: number;
+    'p-value more': number;
+    'p-value less': number;
+};
+declare type Population = number[] | Float32Array | Int32Array;
+export declare function tTest(arr1: Population, arr2: Population, devKnown?: boolean, devEqual?: boolean): testStats;
+export declare function uTest(x: number[], y: number[], continuity?: boolean): testStats;
+export {};
 //# sourceMappingURL=tests.d.ts.map

package/src/tests.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tests.d.ts","sourceRoot":"","sources":["tests.ts"],"names":[],"mappings":"AAGA,aAAK,SAAS,GAAG;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,cAAc,EAAE,MAAM,CAAC;IACvB,cAAc,EAAE,MAAM,CAAC;CACxB,CAAC;AAEF,wBAAgB,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,QAAQ,UAAM,EAAE,QAAQ,UAAM,GAAG,SAAS,CA8C/F;AAED,wBAAgB,KAAK,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,MAAM,EAAE,EAAE,UAAU,UAAK,GAAG,SAAS,CA+B1E"}
+{"version":3,"file":"tests.d.ts","sourceRoot":"","sources":["tests.ts"],"names":[],"mappings":"AAGA,aAAK,SAAS,GAAG;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,cAAc,EAAE,MAAM,CAAC;IACvB,cAAc,EAAE,MAAM,CAAC;CACxB,CAAC;AAEF,aAAK,UAAU,GAAG,MAAM,EAAE,GAAG,YAAY,GAAG,UAAU,CAAC;AAEvD,wBAAgB,KAAK,CAAC,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,UAAU,EAAE,QAAQ,UAAM,EAAE,QAAQ,UAAM,GAAG,SAAS,CA8CnG;AAED,wBAAgB,KAAK,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,MAAM,EAAE,EAAE,UAAU,UAAK,GAAG,SAAS,CA+B1E"}

package/src/tests.js

@@ -1,77 +1,77 @@
-//@ts-ignore: no types
-import * as jStat from 'jstat';
-export function tTest(arr1, arr2, devKnown = false, devEqual = false) {
-    const m1 = jStat.mean(arr1);
-    const m2 = jStat.mean(arr2);
-    const v1 = jStat.variance(arr1);
-    const v2 = jStat.variance(arr2);
-    const n1 = arr1.length;
-    const n2 = arr2.length;
-    let wv1;
-    let wv2;
-    let wv;
-    let Z;
-    let K;
-    let pMore;
-    let pLess;
-    let pTot;
-    if (!devKnown) {
-        if (!devEqual) {
-            wv1 = v1 / n1;
-            wv2 = v2 / n2;
-            Z = (m1 - m2) / Math.sqrt(wv1 + wv2);
-            K = Math.pow((wv1 + wv2), 2) / (wv1 * wv1 / (n1 - 1) + wv2 * wv2 / (n2 - 1));
-            pLess = jStat.studentt.cdf(Z, K);
-            pMore = 1 - pLess;
-            pTot = 2 * (pLess < pMore ? pLess : pMore);
-        }
-        else {
-            K = n1 + n2 - 2;
-            wv = (v1 * (n1 - 1) + v2 * (n2 - 1)) / K;
-            Z = Math.sqrt(n1 * n2 / (n1 + n2)) * (m1 - m2) / wv;
-            pMore = 1 - jStat.studentt.cdf(Z, K);
-            pLess = jStat.studentt.cdf(Z, K);
-            pTot = 2 * (pLess < pMore ? pLess : pMore);
-        }
-    }
-    else {
-        wv1 = v1 / n1;
-        wv2 = v2 / n2;
-        Z = (m1 - m2) / Math.sqrt(wv1 + wv2);
-        pLess = jStat.normal.pdf(Z, 0, 1);
-        pMore = 1 - pLess;
-        pTot = 2 * (pLess < pMore ? pLess : pMore);
-    }
-    return { 'p-value': pTot, 'Mean difference': m1 - m2, 'p-value more': pMore, 'p-value less': pLess };
-}
-export function uTest(x, y, continuity = true) {
-    const xy = x.concat(y);
-    const n1 = x.length;
-    const n2 = y.length;
-    const med1 = jStat.median(x);
-    const med2 = jStat.median(y);
-    const ranks = jStat.rank(xy);
-    const R1 = jStat.sum(ranks.slice(0, n1));
-    const U1 = R1 - n1 * (n1 + 1) / 2;
-    const U2 = n1 * n2 - U1;
-    const U = U1 > U2 ? U1 : U2;
-    const mu = n1 * n2 / 2;
-    const n = n1 + n2;
-    const tieTerm = _tieTerm(ranks);
-    const s = Math.sqrt(n1 * n2 / 12 * ((n + 1) - tieTerm / (n * (n - 1))));
-    let numerator = U - mu;
-    if (continuity) {
-        numerator -= 0.5;
-    }
-    const z = numerator / s;
-    const p = 2 * (1 - jStat.normal.cdf(z, 0, 1));
-    return { 'p-value': p, 'Median difference': med1 - med2, 'p-value more': p, 'p-value less': p };
-}
-function _tieTerm(ranks) {
-    const ties = {};
-    ranks.forEach((num) => {
-        ties[num] = (ties[num] || 0) + 1;
-    });
-    return jStat.sum(Object.values(ties));
-}
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tests.js","sourceRoot":"","sources":["tests.ts"],"names":[],"mappings":"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","sourcesContent":["//@ts-ignore: no types\r\nimport * as jStat from 'jstat';\r\n\r\ntype testStats = {\r\n  'p-value': number,\r\n  'Mean difference'?: number,\r\n  'Median difference'?: number,\r\n  'p-value more': number,\r\n  'p-value less': number,\r\n};\r\n\r\nexport function tTest(arr1: number[], arr2: number[], devKnown=false, devEqual=false): testStats {\r\n  const m1: number = jStat.mean(arr1);\r\n  const m2: number = jStat.mean(arr2);\r\n  const v1: number = jStat.variance(arr1);\r\n  const v2: number = jStat.variance(arr2);\r\n  const n1 = arr1.length;\r\n  const n2 = arr2.length;\r\n\r\n  let wv1;\r\n  let wv2;\r\n  let wv;\r\n  let Z;\r\n  let K;\r\n  let pMore;\r\n  let pLess;\r\n  let pTot;\r\n\r\n  if (!devKnown) {\r\n    if (!devEqual) {\r\n      wv1 = v1 / n1;\r\n      wv2 = v2 / n2;\r\n      Z = (m1 - m2) / Math.sqrt(wv1 + wv2);\r\n      K = Math.pow((wv1 + wv2), 2) / (wv1 * wv1 / (n1 - 1) + wv2 * wv2 / (n2 - 1));\r\n\r\n      pLess = jStat.studentt.cdf(Z, K);\r\n      pMore = 1 - pLess;\r\n      pTot = 2 * (pLess < pMore ? pLess : pMore);\r\n    } else {\r\n      K = n1 + n2 - 2;\r\n      wv = (v1 * (n1 - 1) + v2 * (n2 - 1)) / K;\r\n      Z = Math.sqrt(n1 * n2 / (n1 + n2)) * (m1 - m2) / wv;\r\n\r\n      pMore = 1 - jStat.studentt.cdf(Z, K);\r\n      pLess = jStat.studentt.cdf(Z, K);\r\n      pTot = 2 * (pLess < pMore ? pLess : pMore);\r\n    }\r\n  } else {\r\n    wv1 = v1 / n1;\r\n    wv2 = v2 / n2;\r\n    Z = (m1 - m2) / Math.sqrt(wv1 + wv2);\r\n\r\n    pLess = jStat.normal.pdf(Z, 0, 1);\r\n    pMore = 1 - pLess;\r\n    pTot = 2 * (pLess < pMore ? pLess : pMore);\r\n  }\r\n  return {'p-value': pTot, 'Mean difference': m1 - m2, 'p-value more': pMore, 'p-value less': pLess};\r\n}\r\n\r\nexport function uTest(x: number[], y: number[], continuity=true): testStats {\r\n  const xy = x.concat(y);\r\n  const n1 = x.length;\r\n  const n2 = y.length;\r\n  const med1 = jStat.median(x);\r\n  const med2 = jStat.median(y);\r\n\r\n  const ranks = jStat.rank(xy);\r\n\r\n  const R1 = jStat.sum(ranks.slice(0, n1));\r\n  const U1 = R1 - n1 * (n1 + 1) / 2;\r\n  const U2 = n1 * n2 - U1;\r\n  const U = U1 > U2 ? U1 : U2;\r\n\r\n  const mu = n1 * n2 / 2;\r\n  const n = n1 + n2;\r\n\r\n  const tieTerm = _tieTerm(ranks);\r\n  const s = Math.sqrt(n1 * n2 / 12 * ((n + 1) - tieTerm / (n* (n - 1))));\r\n\r\n  let numerator = U - mu;\r\n\r\n  if (continuity) {\r\n    numerator -= 0.5;\r\n  }\r\n\r\n  const z = numerator / s;\r\n\r\n  const p = 2 * (1 - jStat.normal.cdf(z, 0, 1));\r\n\r\n  return {'p-value': p, 'Median difference': med1 - med2, 'p-value more': p, 'p-value less': p};\r\n}\r\n\r\nfunction _tieTerm(ranks: number[]): number {\r\n  const ties: {[key: number]: number} = {};\r\n\r\n  ranks.forEach((num) => {\r\n    ties[num] = (ties[num] || 0) + 1;\r\n  });\r\n\r\n  return jStat.sum(Object.values(ties));\r\n}\r\n"]}
+//@ts-ignore: no types
+import * as jStat from 'jstat';
+export function tTest(arr1, arr2, devKnown = false, devEqual = false) {
+    const m1 = jStat.mean(arr1);
+    const m2 = jStat.mean(arr2);
+    const v1 = jStat.variance(arr1);
+    const v2 = jStat.variance(arr2);
+    const n1 = arr1.length;
+    const n2 = arr2.length;
+    let wv1;
+    let wv2;
+    let wv;
+    let Z;
+    let K;
+    let pMore;
+    let pLess;
+    let pTot;
+    if (!devKnown) {
+        if (!devEqual) {
+            wv1 = v1 / n1;
+            wv2 = v2 / n2;
+            Z = (m1 - m2) / Math.sqrt(wv1 + wv2);
+            K = Math.pow((wv1 + wv2), 2) / (wv1 * wv1 / (n1 - 1) + wv2 * wv2 / (n2 - 1));
+            pLess = jStat.studentt.cdf(Z, K);
+            pMore = 1 - pLess;
+            pTot = 2 * (pLess < pMore ? pLess : pMore);
+        }
+        else {
+            K = n1 + n2 - 2;
+            wv = (v1 * (n1 - 1) + v2 * (n2 - 1)) / K;
+            Z = Math.sqrt(n1 * n2 / (n1 + n2)) * (m1 - m2) / wv;
+            pMore = 1 - jStat.studentt.cdf(Z, K);
+            pLess = jStat.studentt.cdf(Z, K);
+            pTot = 2 * (pLess < pMore ? pLess : pMore);
+        }
+    }
+    else {
+        wv1 = v1 / n1;
+        wv2 = v2 / n2;
+        Z = (m1 - m2) / Math.sqrt(wv1 + wv2);
+        pLess = jStat.normal.pdf(Z, 0, 1);
+        pMore = 1 - pLess;
+        pTot = 2 * (pLess < pMore ? pLess : pMore);
+    }
+    return { 'p-value': pTot, 'Mean difference': m1 - m2, 'p-value more': pMore, 'p-value less': pLess };
+}
+export function uTest(x, y, continuity = true) {
+    const xy = x.concat(y);
+    const n1 = x.length;
+    const n2 = y.length;
+    const med1 = jStat.median(x);
+    const med2 = jStat.median(y);
+    const ranks = jStat.rank(xy);
+    const R1 = jStat.sum(ranks.slice(0, n1));
+    const U1 = R1 - n1 * (n1 + 1) / 2;
+    const U2 = n1 * n2 - U1;
+    const U = U1 > U2 ? U1 : U2;
+    const mu = n1 * n2 / 2;
+    const n = n1 + n2;
+    const tieTerm = _tieTerm(ranks);
+    const s = Math.sqrt(n1 * n2 / 12 * ((n + 1) - tieTerm / (n * (n - 1))));
+    let numerator = U - mu;
+    if (continuity) {
+        numerator -= 0.5;
+    }
+    const z = numerator / s;
+    const p = 2 * (1 - jStat.normal.cdf(z, 0, 1));
+    return { 'p-value': p, 'Median difference': med1 - med2, 'p-value more': p, 'p-value less': p };
+}
+function _tieTerm(ranks) {
+    const ties = {};
+    ranks.forEach((num) => {
+        ties[num] = (ties[num] || 0) + 1;
+    });
+    return jStat.sum(Object.values(ties));
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tests.js","sourceRoot":"","sources":["tests.ts"],"names":[],"mappings":"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","sourcesContent":["//@ts-ignore: no types\nimport * as jStat from 'jstat';\n\ntype testStats = {\n  'p-value': number,\n  'Mean difference'?: number,\n  'Median difference'?: number,\n  'p-value more': number,\n  'p-value less': number,\n};\n\ntype Population = number[] | Float32Array | Int32Array;\n\nexport function tTest(arr1: Population, arr2: Population, devKnown=false, devEqual=false): testStats {\n  const m1: number = jStat.mean(arr1);\n  const m2: number = jStat.mean(arr2);\n  const v1: number = jStat.variance(arr1);\n  const v2: number = jStat.variance(arr2);\n  const n1 = arr1.length;\n  const n2 = arr2.length;\n\n  let wv1;\n  let wv2;\n  let wv;\n  let Z;\n  let K;\n  let pMore;\n  let pLess;\n  let pTot;\n\n  if (!devKnown) {\n    if (!devEqual) {\n      wv1 = v1 / n1;\n      wv2 = v2 / n2;\n      Z = (m1 - m2) / Math.sqrt(wv1 + wv2);\n      K = Math.pow((wv1 + wv2), 2) / (wv1 * wv1 / (n1 - 1) + wv2 * wv2 / (n2 - 1));\n\n      pLess = jStat.studentt.cdf(Z, K);\n      pMore = 1 - pLess;\n      pTot = 2 * (pLess < pMore ? pLess : pMore);\n    } else {\n      K = n1 + n2 - 2;\n      wv = (v1 * (n1 - 1) + v2 * (n2 - 1)) / K;\n      Z = Math.sqrt(n1 * n2 / (n1 + n2)) * (m1 - m2) / wv;\n\n      pMore = 1 - jStat.studentt.cdf(Z, K);\n      pLess = jStat.studentt.cdf(Z, K);\n      pTot = 2 * (pLess < pMore ? pLess : pMore);\n    }\n  } else {\n    wv1 = v1 / n1;\n    wv2 = v2 / n2;\n    Z = (m1 - m2) / Math.sqrt(wv1 + wv2);\n\n    pLess = jStat.normal.pdf(Z, 0, 1);\n    pMore = 1 - pLess;\n    pTot = 2 * (pLess < pMore ? pLess : pMore);\n  }\n  return {'p-value': pTot, 'Mean difference': m1 - m2, 'p-value more': pMore, 'p-value less': pLess};\n}\n\nexport function uTest(x: number[], y: number[], continuity=true): testStats {\n  const xy = x.concat(y);\n  const n1 = x.length;\n  const n2 = y.length;\n  const med1 = jStat.median(x);\n  const med2 = jStat.median(y);\n\n  const ranks = jStat.rank(xy);\n\n  const R1 = jStat.sum(ranks.slice(0, n1));\n  const U1 = R1 - n1 * (n1 + 1) / 2;\n  const U2 = n1 * n2 - U1;\n  const U = U1 > U2 ? U1 : U2;\n\n  const mu = n1 * n2 / 2;\n  const n = n1 + n2;\n\n  const tieTerm = _tieTerm(ranks);\n  const s = Math.sqrt(n1 * n2 / 12 * ((n + 1) - tieTerm / (n* (n - 1))));\n\n  let numerator = U - mu;\n\n  if (continuity) {\n    numerator -= 0.5;\n  }\n\n  const z = numerator / s;\n\n  const p = 2 * (1 - jStat.normal.cdf(z, 0, 1));\n\n  return {'p-value': p, 'Median difference': med1 - med2, 'p-value more': p, 'p-value less': p};\n}\n\nfunction _tieTerm(ranks: number[]): number {\n  const ties: {[key: number]: number} = {};\n\n  ranks.forEach((num) => {\n    ties[num] = (ties[num] || 0) + 1;\n  });\n\n  return jStat.sum(Object.values(ties));\n}\n"]}

package/tsconfig.json

@@ -1,71 +1,71 @@
-{
-  "compilerOptions": {
-    /* Visit https://aka.ms/tsconfig.json to read more about this file */
-
-    /* Basic Options */
-    // "incremental": true,                         /* Enable incremental compilation */
-    "target": "es2018",                                /* Specify ECMAScript target version: 'ES3' (default), 'ES5', 'ES2015', 'ES2016', 'ES2017', 'ES2018', 'ES2019', 'ES2020', or 'ESNEXT'. */
-    "module": "es2020",                             /* Specify module code generation: 'none', 'commonjs', 'amd', 'system', 'umd', 'es2015', 'es2020', or 'ESNext'. */
-    "lib": ["es2020", "dom"],                       /* Specify library files to be included in the compilation. */
-    // "allowJs": true,                             /* Allow javascript files to be compiled. */
-    // "checkJs": true,                             /* Report errors in .js files. */
-    // "jsx": "preserve",                           /* Specify JSX code generation: 'preserve', 'react-native', 'react', 'react-jsx' or 'react-jsxdev'. */
-    "declaration": true,                         /* Generates corresponding '.d.ts' file. */
-    "declarationMap": true,                      /* Generates a sourcemap for each corresponding '.d.ts' file. */
-    // "sourceMap": true,                           /* Generates corresponding '.map' file. */
-    // "outFile": "./",                             /* Concatenate and emit output to single file. */
-    // "outDir": "./",                              /* Redirect output structure to the directory. */
-    // "rootDir": "./",                             /* Specify the root directory of input files. Use to control the output directory structure with --outDir. */
-    // "composite": true,                           /* Enable project compilation */
-    // "tsBuildInfoFile": "./",                     /* Specify file to store incremental compilation information */
-    // "removeComments": true,                      /* Do not emit comments to output. */
-    // "noEmit": true,                              /* Do not emit outputs. */
-    // "importHelpers": true,                       /* Import emit helpers from 'tslib'. */
-    // "downlevelIteration": true,                  /* Provide full support for iterables in 'for-of', spread, and destructuring when targeting 'ES5' or 'ES3'. */
-    // "isolatedModules": true,                     /* Transpile each file as a separate module (similar to 'ts.transpileModule'). */
-
-    /* Strict Type-Checking Options */
-    "strict": true,                                 /* Enable all strict type-checking options. */
-    // "noImplicitAny": true,                       /* Raise error on expressions and declarations with an implied 'any' type. */
-    // "strictNullChecks": true,                    /* Enable strict null checks. */
-    // "strictFunctionTypes": true,                 /* Enable strict checking of function types. */
-    // "strictBindCallApply": true,                 /* Enable strict 'bind', 'call', and 'apply' methods on functions. */
-    // "strictPropertyInitialization": true,        /* Enable strict checking of property initialization in classes. */
-    // "noImplicitThis": true,                      /* Raise error on 'this' expressions with an implied 'any' type. */
-    // "alwaysStrict": true,                        /* Parse in strict mode and emit "use strict" for each source file. */
-
-    /* Additional Checks */
-    // "noUnusedLocals": true,                      /* Report errors on unused locals. */
-    // "noUnusedParameters": true,                  /* Report errors on unused parameters. */
-    // "noImplicitReturns": true,                   /* Report error when not all code paths in function return a value. */
-    // "noFallthroughCasesInSwitch": true,          /* Report errors for fallthrough cases in switch statement. */
-    // "noUncheckedIndexedAccess": true,            /* Include 'undefined' in index signature results */
-    // "noPropertyAccessFromIndexSignature": true,  /* Require undeclared properties from index signatures to use element accesses. */
-
-    /* Module Resolution Options */
-    "moduleResolution": "node",                     /* Specify module resolution strategy: 'node' (Node.js) or 'classic' (TypeScript pre-1.6). */
-    // "baseUrl": "./",                             /* Base directory to resolve non-absolute module names. */
-    // "paths": {},                                 /* A series of entries which re-map imports to lookup locations relative to the 'baseUrl'. */
-    // "rootDirs": [],                              /* List of root folders whose combined content represents the structure of the project at runtime. */
-    // "typeRoots": [],                             /* List of folders to include type definitions from. */
-    // "types": [],                                 /* Type declaration files to be included in compilation. */
-    // "allowSyntheticDefaultImports": true,        /* Allow default imports from modules with no default export. This does not affect code emit, just typechecking. */
-    "esModuleInterop": true,                        /* Enables emit interoperability between CommonJS and ES Modules via creation of namespace objects for all imports. Implies 'allowSyntheticDefaultImports'. */
-    // "preserveSymlinks": true,                    /* Do not resolve the real path of symlinks. */
-    // "allowUmdGlobalAccess": true,                /* Allow accessing UMD globals from modules. */
-
-    /* Source Map Options */
-    "sourceRoot": "",                            /* Specify the location where debugger should locate TypeScript files instead of source locations. */
-    "mapRoot": "",                               /* Specify the location where debugger should locate map files instead of generated locations. */
-    "inlineSourceMap": true,                     /* Emit a single file with source maps instead of having a separate file. */
-    "inlineSources": true,                       /* Emit the source alongside the sourcemaps within a single file; requires '--inlineSourceMap' or '--sourceMap' to be set. */
-
-    /* Experimental Options */
-    // "experimentalDecorators": true,              /* Enables experimental support for ES7 decorators. */
-    // "emitDecoratorMetadata": true,               /* Enables experimental support for emitting type metadata for decorators. */
-
-    /* Advanced Options */
-    "skipLibCheck": true,                          /* Skip type checking of declaration files. */
-    "forceConsistentCasingInFileNames": true        /* Disallow inconsistently-cased references to the same file. */
-  }
-}
+{
+  "compilerOptions": {
+    /* Visit https://aka.ms/tsconfig.json to read more about this file */
+
+    /* Basic Options */
+    // "incremental": true,                         /* Enable incremental compilation */
+    "target": "es2018",                                /* Specify ECMAScript target version: 'ES3' (default), 'ES5', 'ES2015', 'ES2016', 'ES2017', 'ES2018', 'ES2019', 'ES2020', or 'ESNEXT'. */
+    "module": "es2020",                             /* Specify module code generation: 'none', 'commonjs', 'amd', 'system', 'umd', 'es2015', 'es2020', or 'ESNext'. */
+    "lib": ["es2020", "dom"],                       /* Specify library files to be included in the compilation. */
+    // "allowJs": true,                             /* Allow javascript files to be compiled. */
+    // "checkJs": true,                             /* Report errors in .js files. */
+    // "jsx": "preserve",                           /* Specify JSX code generation: 'preserve', 'react-native', 'react', 'react-jsx' or 'react-jsxdev'. */
+    "declaration": true,                         /* Generates corresponding '.d.ts' file. */
+    "declarationMap": true,                      /* Generates a sourcemap for each corresponding '.d.ts' file. */
+    // "sourceMap": true,                           /* Generates corresponding '.map' file. */
+    // "outFile": "./",                             /* Concatenate and emit output to single file. */
+    // "outDir": "./",                              /* Redirect output structure to the directory. */
+    // "rootDir": "./",                             /* Specify the root directory of input files. Use to control the output directory structure with --outDir. */
+    // "composite": true,                           /* Enable project compilation */
+    // "tsBuildInfoFile": "./",                     /* Specify file to store incremental compilation information */
+    // "removeComments": true,                      /* Do not emit comments to output. */
+    // "noEmit": true,                              /* Do not emit outputs. */
+    // "importHelpers": true,                       /* Import emit helpers from 'tslib'. */
+    // "downlevelIteration": true,                  /* Provide full support for iterables in 'for-of', spread, and destructuring when targeting 'ES5' or 'ES3'. */
+    // "isolatedModules": true,                     /* Transpile each file as a separate module (similar to 'ts.transpileModule'). */
+
+    /* Strict Type-Checking Options */
+    "strict": true,                                 /* Enable all strict type-checking options. */
+    // "noImplicitAny": true,                       /* Raise error on expressions and declarations with an implied 'any' type. */
+    // "strictNullChecks": true,                    /* Enable strict null checks. */
+    // "strictFunctionTypes": true,                 /* Enable strict checking of function types. */
+    // "strictBindCallApply": true,                 /* Enable strict 'bind', 'call', and 'apply' methods on functions. */
+    // "strictPropertyInitialization": true,        /* Enable strict checking of property initialization in classes. */
+    // "noImplicitThis": true,                      /* Raise error on 'this' expressions with an implied 'any' type. */
+    // "alwaysStrict": true,                        /* Parse in strict mode and emit "use strict" for each source file. */
+
+    /* Additional Checks */
+    // "noUnusedLocals": true,                      /* Report errors on unused locals. */
+    // "noUnusedParameters": true,                  /* Report errors on unused parameters. */
+    // "noImplicitReturns": true,                   /* Report error when not all code paths in function return a value. */
+    // "noFallthroughCasesInSwitch": true,          /* Report errors for fallthrough cases in switch statement. */
+    // "noUncheckedIndexedAccess": true,            /* Include 'undefined' in index signature results */
+    // "noPropertyAccessFromIndexSignature": true,  /* Require undeclared properties from index signatures to use element accesses. */
+
+    /* Module Resolution Options */
+    "moduleResolution": "node",                     /* Specify module resolution strategy: 'node' (Node.js) or 'classic' (TypeScript pre-1.6). */
+    // "baseUrl": "./",                             /* Base directory to resolve non-absolute module names. */
+    // "paths": {},                                 /* A series of entries which re-map imports to lookup locations relative to the 'baseUrl'. */
+    // "rootDirs": [],                              /* List of root folders whose combined content represents the structure of the project at runtime. */
+    // "typeRoots": [],                             /* List of folders to include type definitions from. */
+    // "types": [],                                 /* Type declaration files to be included in compilation. */
+    // "allowSyntheticDefaultImports": true,        /* Allow default imports from modules with no default export. This does not affect code emit, just typechecking. */
+    "esModuleInterop": true,                        /* Enables emit interoperability between CommonJS and ES Modules via creation of namespace objects for all imports. Implies 'allowSyntheticDefaultImports'. */
+    // "preserveSymlinks": true,                    /* Do not resolve the real path of symlinks. */
+    // "allowUmdGlobalAccess": true,                /* Allow accessing UMD globals from modules. */
+
+    /* Source Map Options */
+    "sourceRoot": "",                            /* Specify the location where debugger should locate TypeScript files instead of source locations. */
+    "mapRoot": "",                               /* Specify the location where debugger should locate map files instead of generated locations. */
+    "inlineSourceMap": true,                     /* Emit a single file with source maps instead of having a separate file. */
+    "inlineSources": true,                       /* Emit the source alongside the sourcemaps within a single file; requires '--inlineSourceMap' or '--sourceMap' to be set. */
+
+    /* Experimental Options */
+    // "experimentalDecorators": true,              /* Enables experimental support for ES7 decorators. */
+    // "emitDecoratorMetadata": true,               /* Enables experimental support for emitting type metadata for decorators. */
+
+    /* Advanced Options */
+    "skipLibCheck": true,                          /* Skip type checking of declaration files. */
+    "forceConsistentCasingInFileNames": true        /* Disallow inconsistently-cased references to the same file. */
+  }
+}