@datagrok-libraries/statistics 0.1.3 → 0.1.6

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":"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","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"}