@datagrok/peptides 0.0.1 → 0.2.0

package/src/{stacked-barchart → viewers}/stacked-barchart-viewer.ts

@@ -2,13 +2,14 @@ import * as DG from 'datagrok-api/dg';
 import * as ui from 'datagrok-api/ui';
 import {scaleBand, scaleLinear} from 'd3';
 import {ChemPalette} from '../utils/chem-palette';
-//@ts-ignore: I should be able to install it somehow
 import * as rxjs from 'rxjs';
 const cp = new ChemPalette('grok');
 
+//TODO: the function should not accept promise. Await the parameters where it is used
 export function addViewerToHeader(grid: DG.Grid, viewer: Promise<DG.Widget>) {
   viewer.then((viewer) => {
-    const barchart = viewer as StackedBarChart;
+    const barchart = viewer as StackedBarChart; //TODO: accept specifically StackedBarChart object
+    // The following event makes the barchart interactive
     rxjs.fromEvent(grid.overlay, 'mousemove').subscribe((mm:any) => {
       mm = mm as MouseEvent;
       const cell = grid.hitTest(mm.offsetX, mm.offsetY);
@@ -73,9 +74,9 @@ export function addViewerToHeader(grid: DG.Grid, viewer: Promise<DG.Widget>) {
 export class StackedBarChart extends DG.JsViewer {
     public dataEmptyAA: string;
     public initialized: boolean;
-    highlighted:{'colName':string, 'aaName':string}|null = null;
+    highlighted: {'colName' : string, 'aaName' : string} | null = null;
     private ord: { [Key: string]: number; } = {};
-    private margin: { top: number; left: number; bottom: number; right: number } = {
+    private margin: {top: number; left: number; bottom: number; right: number} = {
       top: 10,
       right: 10,
       bottom: 50,
@@ -83,18 +84,17 @@ export class StackedBarChart extends DG.JsViewer {
     };
     private yScale: any;
     private xScale: any;
-    private data: { 'name': string, 'data': { 'name': string, 'count': number, 'selectedCount': number }[] }[] = [];
+    private data: {'name': string, 'data': {'name': string, 'count': number, 'selectedCount': number}[]}[] = [];
     private selectionMode: boolean = false;
     public aminoColumnNames: string[] = [];
-    // @ts-ignore
 
-    private aminoColumnIndices: { [Key: string]: number; } = {};
-    private aggregatedTables: { [Key: string]: DG.DataFrame; } = {};
-    private aggregatedTablesUnselected: { [Key: string]: DG.DataFrame; } = {};
+    private aminoColumnIndices: {[Key: string]: number} = {};
+    private aggregatedTables: {[Key: string]: DG.DataFrame} = {};
+    private aggregatedTablesUnselected: {[Key: string]: DG.DataFrame} = {};
     private max = 0;
-    private barStats: { [Key: string]: { 'name': string, 'count': number, 'selectedCount': number }[] } = {};
+    private barStats: {[Key: string]: {'name': string, 'count': number, 'selectedCount': number}[]} = {};
     tableCanvas: HTMLCanvasElement | undefined;
-    private registered: { [Key: string]: DG.GridCell } = {};
+    private registered: {[Key: string]: DG.GridCell} = {};
 
     constructor() {
       super();
@@ -103,22 +103,22 @@ export class StackedBarChart extends DG.JsViewer {
     }
 
     init() {
-      const groups: [string[], string][] = [
-        [['C', 'U'], 'yellow'],
-        [['G', 'P'], 'red'],
-        [['A', 'V', 'I', 'L', 'M', 'F', 'Y', 'W'], 'all_green'],
-        [['R', 'H', 'K'], 'light_blue'],
-        [['D', 'E'], 'dark_blue'],
-        [['S', 'T', 'N', 'Q'], 'orange']];
+      const groups: {[key: string]: string[]} = {
+        'yellow': ['C', 'U'],
+        'red': ['G', 'P'],
+        'all_green': ['A', 'V', 'I', 'L', 'M', 'F', 'Y', 'W'],
+        'light_blue': ['R', 'H', 'K'],
+        'dark_blue': ['D', 'E'],
+        'orange': ['S', 'T', 'N', 'Q'],
+      };
 
       let i = 0;
-      groups.forEach((item) => {
+      for (const value of Object.values(groups)) {
         i++;
-        // eslint-disable-next-line guard-for-in
-        for (const obj in item[0]) {
-          this.ord[item[0][obj]] = i;
+        for (const obj in value) {
+          this.ord[value[obj]] = i;
         }
-      });
+      }
       this.yScale = scaleLinear();
       this.xScale = scaleBand();
       this.data = [];
@@ -152,8 +152,8 @@ export class StackedBarChart extends DG.JsViewer {
         {
           // @ts-ignore
           if (df.getCol(name).semType === 'aminoAcids' &&
-                    !df.getCol(name).categories.includes('COOH') &&
-                    !df.getCol(name).categories.includes('NH2')) {
+              !df.getCol(name).categories.includes('COOH') &&
+              !df.getCol(name).categories.includes('NH2')) {
             this.aminoColumnIndices[name] = this.aminoColumnNames.length + 1;
             this.aminoColumnNames.push(name);
           }
@@ -170,7 +170,7 @@ export class StackedBarChart extends DG.JsViewer {
         resbuf[i] = buf1[i] & buf2[i];
       }
 
-
+      //TODO: optimize it, why store so many tables?
       const mask = DG.BitSet.fromBytes(resbuf.buffer, df.rowCount);
       if (mask.trueCount !== df.filter.trueCount) {
         this.selectionMode = true;
@@ -214,10 +214,9 @@ export class StackedBarChart extends DG.JsViewer {
       this.barStats = {};
       for (const [name, df] of Object.entries(this.aggregatedTables)) {
         const colObj: {
-                'name': string, 'data':
-                    { 'name': string, 'count': number, 'selectedCount': number }[]
-            } =
-                {'name': name, 'data': []};
+          'name': string,
+          'data': { 'name': string, 'count': number, 'selectedCount': number }[],
+        } = {'name': name, 'data': []};
         this.barStats[colObj['name']] = colObj['data'];
         this.data.push(colObj);
         for (let i = 0; i < df.rowCount; i++) {
@@ -263,7 +262,6 @@ export class StackedBarChart extends DG.JsViewer {
       g.fillStyle = 'black';
       g.textBaseline = 'top';
       g.font = `${h * margin / 2}px`;
-      // eslint-disable-next-line no-unused-vars
 
       const name = cell.tableColumn!.name;
       const colNameSize = g.measureText(name).width;

package/src/widgets/analyze-peptides.ts

@@ -0,0 +1,113 @@
+import * as grok from 'datagrok-api/grok';
+import * as ui from 'datagrok-api/ui';
+import * as DG from 'datagrok-api/dg';
+import {createPeptideSimilaritySpaceViewer} from '../utils/peptide-similarity-space';
+import {addViewerToHeader} from '../viewers/stacked-barchart-viewer';
+import {model} from '../viewers/model';
+
+export async function analyzePeptidesWidget(
+  col: DG.Column, view: DG.TableView, tableGrid: DG.Grid, currentDf: DG.DataFrame,
+): Promise<DG.Widget> {
+  let tempCol = null;
+  for (const column of currentDf.columns.numerical) {
+    tempCol = column.type === DG.TYPE.FLOAT ? column : null;
+  }
+  const defaultColumn: DG.Column = currentDf.col('activity') || currentDf.col('IC50') || tempCol;
+  const histogramHost = ui.div([]);
+
+  let hist: DG.Viewer;
+
+  const activityScalingMethod = ui.choiceInput(
+    'Activity scaling',
+    'none',
+    ['none', 'lg', '-lg'],
+    async (currentMethod: string) => {
+      const currentActivityCol = activityColumnChoice.value.name;
+      const tempDf = currentDf.clone(currentDf.filter, [currentActivityCol]);
+      switch (currentMethod) {
+      case 'lg':
+        await tempDf.columns.addNewCalculated('scaledActivity', 'Log10(${' + currentActivityCol + '})');
+        break;
+      case '-lg':
+        await tempDf.columns.addNewCalculated('scaledActivity', '-1*Log10(${' + currentActivityCol + '})');
+        break;
+      default:
+        await tempDf.columns.addNewCalculated('scaledActivity', '${' + currentActivityCol + '}');
+        break;
+      }
+      hist = tempDf.plot.histogram({
+        filteringEnabled: false,
+        valueColumnName: 'scaledActivity',
+        legendVisibility: 'Never',
+        showXAxis: true,
+        showColumnSelector: false,
+        showRangeSlider: false,
+      // bins: b,
+      });
+      histogramHost.lastChild?.remove();
+      histogramHost.appendChild(hist.root);
+    });
+  activityScalingMethod.setTooltip('Function to apply for each value in activity column');
+
+  const activityScalingMethodState = function(_: any) {
+    activityScalingMethod.enabled =
+      activityColumnChoice.value && DG.Stats.fromColumn(activityColumnChoice.value, currentDf.filter).min > 0;
+    activityScalingMethod.fireChanged();
+  };
+  const activityColumnChoice = ui.columnInput(
+    'Activity column',
+    currentDf,
+    defaultColumn,
+    activityScalingMethodState,
+  );
+  activityColumnChoice.fireChanged();
+  activityScalingMethod.fireChanged();
+
+  const startBtn = ui.button('Launch SAR', async () => {
+    const progress = DG.TaskBarProgressIndicator.create('Loading SAR...');
+    if (activityColumnChoice.value.type === DG.TYPE.FLOAT) {
+      const options: {[key: string]: string} = {
+        'activityColumnColumnName': activityColumnChoice.value.name,
+        'activityScalingMethod': activityScalingMethod.value,
+      };
+      for (let i = 0; i < tableGrid.columns.length; i++) {
+        const col = tableGrid.columns.byIndex(i);
+        if (col &&
+            col.name &&
+            col.column?.semType != 'aminoAcids'
+        ) {
+          //@ts-ignore
+          tableGrid.columns.byIndex(i)?.visible = false;
+        }
+      }
+
+      const sarViewer = view.addViewer('peptide-sar-viewer', options);
+      const sarViewerVertical = view.addViewer('peptide-sar-viewer-vertical');
+      const peptideSpaceViewer = await createPeptideSimilaritySpaceViewer(
+        currentDf,
+        col,
+        't-SNE',
+        'Levenshtein',
+        100,
+        `${activityColumnChoice}Scaled`,
+      );
+      let refNode = view.dockManager.dock(peptideSpaceViewer, 'down');
+      refNode = view.dockManager.dock(sarViewer, 'right', refNode);
+      view.dockManager.dock(sarViewerVertical, 'right', refNode);
+
+      const StackedBarchartProm = currentDf.plot.fromType('StackedBarChartAA');
+      addViewerToHeader(tableGrid, StackedBarchartProm);
+      
+      // currentDf.onValuesChanged.subscribe(async () => await model.updateDefault());
+    } else {
+      grok.shell.error('The activity column must be of floating point number type!');
+    }
+    progress.close();
+  });
+
+  const viewer = await currentDf.plot.fromType('peptide-logo-viewer');
+
+  return new DG.Widget(
+    ui.divV([viewer.root, ui.inputs([activityColumnChoice, activityScalingMethod]), startBtn, histogramHost]),
+  );
+}

package/src/widgets/manual-alignment.ts

@@ -0,0 +1,35 @@
+import * as ui from 'datagrok-api/ui';
+import * as DG from 'datagrok-api/dg';
+
+import $ from 'cash-dom';
+import { model } from '../viewers/model';
+import { splitAlignedPeptides } from '../utils/split-aligned';
+
+export function manualAlignmentWidget(alignedSequenceCol: DG.Column, currentDf: DG.DataFrame) {
+  const sequenceInput = ui.textInput('', alignedSequenceCol.get(currentDf.currentRowIdx));
+  (sequenceInput.input as HTMLElement).style.height = '50px';
+  (sequenceInput.input as HTMLElement).style.overflow = 'hidden';
+
+  const applyChangesBtn = ui.button('Apply', async () => {
+    const newSequence = sequenceInput.value;
+    const affectedRowIndex = currentDf.currentRowIdx;
+    const [splitSequence,] = splitAlignedPeptides(DG.Column.fromStrings('splitSequence', [newSequence]), false);
+
+    alignedSequenceCol.set(affectedRowIndex, newSequence);
+    for (const part of splitSequence.columns) {
+      if (currentDf.col(part.name) !== null)
+        currentDf.set(part.name, affectedRowIndex, part.get(0));
+    }
+
+    await model.updateDefault();
+  });
+
+  const resetBtn = ui.button(
+    ui.iconFA('redo'),
+    () => sequenceInput.value = alignedSequenceCol.get(currentDf.currentRowIdx),
+    'Reset',
+  );
+  $(resetBtn).addClass('dt-snippet-editor-icon dt-reset-icon');
+
+  return new DG.Widget(ui.divV([resetBtn, sequenceInput.root, applyChangesBtn], 'dt-textarea-box'));
+}

package/src/widgets/peptide-molecule.ts

@@ -0,0 +1,42 @@
+import * as grok from 'datagrok-api/grok';
+import * as ui from 'datagrok-api/ui';
+import * as DG from 'datagrok-api/dg';
+import {ChemPalette} from '../utils/chem-palette';
+
+export async function peptideMoleculeWidget(pep: string): Promise<DG.Widget> {
+  const pi = DG.TaskBarProgressIndicator.create('Creating NGL view');
+
+  const split = pep.split('-');
+  const mols = [];
+  for (let i = 1; i < split.length - 1; i++) {
+    if (split[i] in ChemPalette.AASmiles) {
+      const aar = ChemPalette.AASmiles[split[i]];
+      mols[i] = aar.substr(0, aar.length - 1);
+    } else if (!split[i] || split[i] == '-') {
+      mols[i] = '';
+    } else {
+      return new DG.Widget(ui.divH([]));
+    }
+  }
+  const smiles = mols.join('') + 'O';
+  let molfileStr = (await grok.functions.call('Peptides:SmiTo3D', {smiles}));
+
+  molfileStr = molfileStr.replaceAll('\\n', '\n'); ;
+  const stringBlob = new Blob([molfileStr], {type: 'text/plain'});
+  const nglHost = ui.div([], {classes: 'd4-ngl-viewer', id: 'ngl-3d-host'});
+
+  //@ts-ignore
+  const stage = new NGL.Stage(nglHost, {backgroundColor: 'white'});
+  //@ts-ignore
+  stage.loadFile(stringBlob, {ext: 'sdf'}).then(function(comp: NGL.StructureComponent) {
+    stage.setSize(300, 300);
+    comp.addRepresentation('ball+stick');
+    comp.autoView();
+  });
+  const sketch = grok.chem.svgMol(smiles);
+  const panel = ui.divH([sketch]);
+
+  pi.close();
+
+  return new DG.Widget(ui.div([panel, nglHost]));
+}

package/src/workers/dimensionality-reducer.ts

@@ -0,0 +1,29 @@
+import {DimensionalityReducer} from '@datagrok-libraries/utils/src/reduce-dimensionality';
+import {Coordinates} from '@datagrok-libraries/utils/src/type_declarations';
+
+/**
+ * Worker thread receiving data function.
+ *
+ * @param {any[]} columnData Samples to process.
+ * @param {string} method Embedding method.
+ * @param {string} measure Distance metric.
+ * @param {number} cyclesCount Number of cycles to repeat.
+ * @return {Coordinates} Embedding.
+ */
+function onMessage(columnData: [], method: string, measure: string, cyclesCount: number): Coordinates {
+  const reducer = new DimensionalityReducer(
+    columnData,
+    method,
+    measure,
+    {cycles: cyclesCount},
+  );
+  return reducer.transform(true);
+}
+
+self.onmessage = ({data: {columnData, method, measure, cyclesCount}}) => {
+  const embedding = onMessage(columnData, method, measure, cyclesCount);
+  self.postMessage({
+    embedding: embedding,
+  });
+};
+

package/tsconfig.json

@@ -4,17 +4,17 @@
 
     /* Basic Options */
     // "incremental": true,                         /* Enable incremental compilation */
-    "target": "es2017",                                /* Specify ECMAScript target version: 'ES3' (default), 'ES5', 'ES2015', 'ES2016', 'ES2017', 'ES2018', 'ES2019', 'ES2020', 'ES2021', or 'ESNEXT'. */
-    "module": "es2020",                           /* Specify module code generation: 'none', 'commonjs', 'amd', 'system', 'umd', 'es2015', 'es2020', or 'ESNext'. */
-    // "lib": [],                                   /* Specify library files to be included in the compilation. */
-    "allowJs": true,                             /* Allow javascript files to be compiled. */
+    "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": "./dist",                              /* Redirect output structure to the directory. */
+    // "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 */
@@ -26,7 +26,7 @@
 
     /* 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. */
+    // "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. */
@@ -40,11 +40,10 @@
     // "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 */
-    // "noImplicitOverride": true,                  /* Ensure overriding members in derived classes are marked with an 'override' modifier. */
     // "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). */
+    "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. */
@@ -56,17 +55,17 @@
     // "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. */
+    "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. */
+    "skipLibCheck": true,                          /* Skip type checking of declaration files. */
     "forceConsistentCasingInFileNames": true        /* Disallow inconsistently-cased references to the same file. */
   }
 }

package/webpack.config.js

@@ -3,19 +3,19 @@ const path = require('path');
 module.exports = {
   mode: 'development',
   entry: {
-    package: './src/package.ts'
+    package: './src/package.ts',
   },
   module: {
     rules: [
       {
-        test: /\.tsx?$/,
+        test: /\.ts?$/,
         use: 'ts-loader',
         exclude: /node_modules/,
       },
     ],
   },
   resolve: {
-    extensions: ['.tsx', '.ts', '.js'],
+    extensions: ['.tsx', '.js', '.ts'],
   },
   devtool: 'inline-source-map',
   externals: {
@@ -24,7 +24,7 @@ module.exports = {
     'datagrok-api/ui': 'ui',
     'openchemlib/full.js': 'OCL',
     'rxjs': 'rxjs',
-    'rxjs/operators': 'rxjs.operators'
+    'rxjs/operators': 'rxjs.operators',
   },
   output: {
     filename: '[name].js',

package/.eslintrc.json

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

package/src/split-aligned.ts

@@ -1,42 +0,0 @@
-import * as DG from 'datagrok-api/dg';
-
-export function splitAlignedPeptides(peptideColumn: DG.Column) {
-  let splitPeptidesArray: string[][] = [];
-  let isFirstRun = true;
-  let splitted: string[];
-
-  for (const peptideStr of peptideColumn.toList()) {
-    splitted = peptideStr.split('-');
-
-    if (isFirstRun) {
-      for (let i = 0; i < splitted.length; i++) {
-        splitPeptidesArray.push([]);
-      }
-      isFirstRun = false;
-    }
-
-    splitted.forEach((value, index) => {
-      splitPeptidesArray[index].push(value === '' ? '-' : value);
-    });
-  }
-
-  //create column names list
-  let columnNames = ['N'];
-  columnNames = columnNames.concat(splitPeptidesArray.map((_, index) => `${index + 1 < 10 ? 0 : ''}${index +1 }`));
-  columnNames.push('C');
-
-  // filter out the columns with the same values
-  splitPeptidesArray = splitPeptidesArray.filter((positionArray, index) => {
-    const isRetained = new Set(positionArray).size > 1;
-    if (!isRetained) {
-      columnNames.splice(index, 1);
-    }
-    return isRetained;
-  });
-
-  const columnsArray = splitPeptidesArray.map((positionArray, index) => {
-    return DG.Column.fromList('string', columnNames[index], positionArray);
-  });
-
-  return DG.DataFrame.fromColumns(columnsArray);
-}

package/src/utils/misc.ts

@@ -1,101 +0,0 @@
-//@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[], alpha=0.05, 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));
-}