@datagrok-libraries/statistics 0.1.0 → 0.1.1

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,35 +1,32 @@
-{
-	"name": "@datagrok-libraries/statistics",
-	"beta": true,
-	"publishConfig": {
-		"access": "public"
-	},
-	"friendlyName": "statistics",
-	"version": "0.1.0",
-	"description": "",
-	"dependencies": {
-		"datagrok-api": ">0.95.4",
-		"cash-dom": "latest",
-		"dayjs": "latest",
-		"ts-loader": "latest",
-		"typescript": "^4.2.3",
-		"jstat": "latest"
-	},
-	"devDependencies": {
-		"webpack": "latest",
-		"webpack-cli": "latest",
-		"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.1",
+	"description": "",
+	"dependencies": {
+		"datagrok-api": ">0.95.4",
+		"cash-dom": "latest",
+		"dayjs": "latest",
+		"ts-loader": "latest",
+		"typescript": "^4.2.3",
+		"jstat": "latest"
+	},
+	"devDependencies": {
+		"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"
+	}
+}

package/src/multiple-tests.ts

@@ -1,234 +1,234 @@
-/** @type {*} A dictionary of basic binary operations. */
-const _operations: {[name: string]: Function} = {
-  '+': (a: number, b: number) => (a + b),
-  '-': (a: number, b: number) => (a - b),
-  '*': (a: number, b: number) => (a * b),
-  '/': (a: number, b: number) => (a / b),
-  'min': (a: number, b: number) => (a < b ? a : b),
-  'max': (a: number, b: number) => (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: Float32Array): Int32Array {
-  const v = Array.from(values);
-
-  const argsort = (arr: number[]) => 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: Int32Array, values: Float32Array): Float32Array {
-  // 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: Float32Array, order: Int32Array): Float32Array {
-  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: Array<boolean>, order: Int32Array): Array<boolean> {
-  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: Float32Array): Float32Array {
-  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: number): number {
-  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: Float32Array, scale: number, op = '*'): Float32Array {
-  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: Float32Array, scale: Float32Array, op = '*'): Float32Array {
-  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: Float32Array): Float32Array {
-  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: Float32Array,
-  alpha: number = 0.05,
-  method: string ='n',
-  isSorted: boolean = false): [Array<boolean>, Float32Array]
-// eslint-disable-next-line brace-style
-{
-  const nItems = pvals.length;
-  let pvalsSorted: Float32Array;
-  let pvalsSortind: Int32Array;
-  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: boolean[] = 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];
-}
+/** @type {*} A dictionary of basic binary operations. */
+const _operations: {[name: string]: Function} = {
+  '+': (a: number, b: number) => (a + b),
+  '-': (a: number, b: number) => (a - b),
+  '*': (a: number, b: number) => (a * b),
+  '/': (a: number, b: number) => (a / b),
+  'min': (a: number, b: number) => (a < b ? a : b),
+  'max': (a: number, b: number) => (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: Float32Array): Int32Array {
+  const v = Array.from(values);
+
+  const argsort = (arr: number[]) => 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: Int32Array, values: Float32Array): Float32Array {
+  // 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: Float32Array, order: Int32Array): Float32Array {
+  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: Array<boolean>, order: Int32Array): Array<boolean> {
+  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: Float32Array): Float32Array {
+  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: number): number {
+  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: Float32Array, scale: number, op = '*'): Float32Array {
+  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: Float32Array, scale: Float32Array, op = '*'): Float32Array {
+  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: Float32Array): Float32Array {
+  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: Float32Array,
+  alpha: number = 0.05,
+  method: string ='n',
+  isSorted: boolean = false): [Array<boolean>, Float32Array]
+// eslint-disable-next-line brace-style
+{
+  const nItems = pvals.length;
+  let pvalsSorted: Float32Array;
+  let pvalsSortind: Int32Array;
+  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: boolean[] = 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];
+}

package/src/tests.ts

@@ -1,101 +1,101 @@
-//@ts-ignore: no types
-import * as jStat from 'jstat';
-
-type testStats = {
-  'p-value': number,
-  'Mean difference'?: number,
-  'Median difference'?: number,
-  'p-value more': number,
-  'p-value less': number,
-};
-
-export function tTest(arr1: number[], arr2: number[], devKnown=false, devEqual=false): testStats {
-  const m1: number = jStat.mean(arr1);
-  const m2: number = jStat.mean(arr2);
-  const v1: number = jStat.variance(arr1);
-  const v2: number = 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: number[], y: number[], continuity=true): testStats {
-  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: number[]): number {
-  const ties: {[key: number]: number} = {};
-
-  ranks.forEach((num) => {
-    ties[num] = (ties[num] || 0) + 1;
-  });
-
-  return jStat.sum(Object.values(ties));
-}
+//@ts-ignore: no types
+import * as jStat from 'jstat';
+
+type testStats = {
+  'p-value': number,
+  'Mean difference'?: number,
+  'Median difference'?: number,
+  'p-value more': number,
+  'p-value less': number,
+};
+
+export function tTest(arr1: number[], arr2: number[], devKnown=false, devEqual=false): testStats {
+  const m1: number = jStat.mean(arr1);
+  const m2: number = jStat.mean(arr2);
+  const v1: number = jStat.variance(arr1);
+  const v2: number = 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: number[], y: number[], continuity=true): testStats {
+  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: number[]): number {
+  const ties: {[key: number]: number} = {};
+
+  ranks.forEach((num) => {
+    ties[num] = (ties[num] || 0) + 1;
+  });
+
+  return jStat.sum(Object.values(ties));
+}

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": "es6",                                /* 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": false,                          /* 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. */
+  }
+}

package/detectors.js

@@ -1,9 +0,0 @@
-/**
- * The class contains semantic type detectors.
- * Detectors are functions tagged with `DG.FUNC_TYPES.SEM_TYPE_DETECTOR`.
- * See also: https://datagrok.ai/help/develop/how-to/define-semantic-type-detectors
- * The class name is comprised of <PackageName> and the `PackageDetectors` suffix.
- * Follow this naming convention to ensure that your detectors are properly loaded.
- */
-class StatisticsPackageDetectors extends DG.Package {
-}

package/webpack.config.js

@@ -1,33 +0,0 @@
-const path = require('path');
-
-module.exports = {
-  mode: 'development',
-  entry: {
-    package: './src/tests.ts'
-  },
-  resolve: {
-    extensions: ['.wasm', '.mjs', '.js', '.json', '.ts', '.tsx'],
-  },
-  module: {
-    rules: [
-      { test: /\.tsx?$/, loader: 'ts-loader' }
-    ],
-  },
-  devtool: 'inline-source-map',
-  externals: {
-    'datagrok-api/dg': 'DG',
-    'datagrok-api/grok': 'grok',
-    'datagrok-api/ui': 'ui',
-    'openchemlib/full.js': 'OCL',
-    'rxjs': 'rxjs',
-    'rxjs/operators': 'rxjs.operators',
-    'cash-dom': '$',
-    'dayjs': 'dayjs',
-  },
-  output: {
-    filename: '[name].js',
-    library: 'statistics',
-    libraryTarget: 'var',
-    path: path.resolve(__dirname, 'dist'),
-  },
-};