@datagrok-libraries/utils 0.0.6 → 0.0.10

package/src/sequence-encoder.js

@@ -0,0 +1,116 @@
+import { assert } from './operations';
+/**
+ * Class to categorial encode/decode aligned amino acid residues sequence.
+ *
+ * @export
+ * @class AlignedSequenceEncoder
+ */
+export class AlignedSequenceEncoder {
+    constructor() {
+        this.aa2num = {
+            '-': 0,
+            'A': 1,
+            'C': 2,
+            'D': 3,
+            'E': 4,
+            'F': 5,
+            'G': 6,
+            'H': 7,
+            'I': 8,
+            'K': 9,
+            'L': 10,
+            'M': 11,
+            'N': 12,
+            'P': 13,
+            'Q': 14,
+            'R': 15,
+            'S': 16,
+            'T': 17,
+            'V': 18,
+            'W': 19,
+            'Y': 20,
+        };
+        this.num2aa = {};
+        Object.entries(this.aa2num).forEach(([k, v]) => (this.num2aa[v] = k));
+    }
+    /**
+     * Truncate NH2 and -COOH terminals of the given sequence.
+     *
+     * @static
+     * @param {string} seq The sequence provided.
+     * @return {string} Truncated sequence.
+     * @memberof AlignedSequenceEncoder
+     */
+    static _truncateSequence(seq) {
+        let start = 0;
+        let end = seq.length;
+        const termina = ['NH2', 'COOH'];
+        if (seq.startsWith(termina[0])) {
+            const l = termina[0].length; // Cut only 'NH2' without following '-'.
+            assert(seq[l] == '-', `Wrong sequence format: ${termina[0]} without following '-' in '${seq}'.`);
+            start = l;
+        }
+        if (seq.endsWith(termina[1])) {
+            const l = termina[1].length + 1; // Cut both 'COOH' and precending '-'.
+            assert(seq[end - l] == '-', `Wrong sequence format: ${termina[1]} without '-' precending in '${seq}'.`);
+            end -= l;
+        }
+        return seq.substring(start, end);
+    }
+    /**
+     * Cuts auxiliary defises before a residue.
+     *
+     * @static
+     * @param {string} seq The sequence to process.
+     * @return {string} Processed sequence.
+     * @memberof AlignedSequenceEncoder
+     */
+    static _dropDefises(seq) {
+        return seq.replace(/(-)([^-]+)/g, '$2');
+    }
+    /**
+     * Performs truncation and cutting auxiliary defises.
+     *
+     * @static
+     * @param {string} sequence The sequence work under process.
+     * @return {string} Result of cleaning.
+     * @memberof AlignedSequenceEncoder
+     */
+    static clean(sequence) {
+        return AlignedSequenceEncoder._dropDefises(AlignedSequenceEncoder._truncateSequence(sequence));
+    }
+    /**
+     * Categorial encode of the sequence provided.
+     *
+     * @param {string} sequence The sequence.
+     * @return {number[]} Encoded vector.
+     * @memberof AlignedSequenceEncoder
+     */
+    encode(sequence) {
+        const nItems = sequence.length;
+        let values = new Array(nItems).fill(0);
+        for (let i = 0; i < nItems; ++i) {
+            let char = sequence[i];
+            assert(char in this.aa2num, `Unknown char '${char}' found in sequence '${sequence}'`);
+            values[i] = this.aa2num[char];
+        }
+        return values;
+    }
+    /**
+     * Decode the encoded vector into the sequence back.
+     *
+     * @param {number[]} value The vector encoded.
+     * @return {string} Decoded sequence.
+     * @memberof AlignedSequenceEncoder
+     */
+    decode(value) {
+        let s = '';
+        for (let i = 0; i < value.length; ++i) {
+            let code = value[i];
+            assert(code in this.num2aa, `Unknown code '${code}' found in vector '${value}'`);
+            s += this.num2aa[code];
+        }
+        return s;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sequence-encoder.js","sourceRoot":"","sources":["sequence-encoder.ts"],"names":[],"mappings":"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","sourcesContent":["import {assert} from './operations';\n\n/**\n * Class to categorial encode/decode aligned amino acid residues sequence.\n *\n * @export\n * @class AlignedSequenceEncoder\n */\nexport class AlignedSequenceEncoder {\n    protected aa2num: {[name: string]: number};\n    protected num2aa: {[code: number]: string};\n\n    constructor () {\n        this.aa2num = {\n            '-': 0,\n            'A': 1,\n            'C': 2,\n            'D': 3,\n            'E': 4,\n            'F': 5,\n            'G': 6,\n            'H': 7,\n            'I': 8,\n            'K': 9,\n            'L': 10,\n            'M': 11,\n            'N': 12,\n            'P': 13,\n            'Q': 14,\n            'R': 15,\n            'S': 16,\n            'T': 17,\n            'V': 18,\n            'W': 19,\n            'Y': 20,\n        };\n        this.num2aa = {};\n        Object.entries(this.aa2num).forEach(([k, v]) => (this.num2aa[v] = k));\n    }\n\n    /**\n     * Truncate NH2 and -COOH terminals of the given sequence.\n     *\n     * @static\n     * @param {string} seq The sequence provided.\n     * @return {string} Truncated sequence.\n     * @memberof AlignedSequenceEncoder\n     */\n    static _truncateSequence(seq: string): string {\n        let start = 0;\n        let end = seq.length;\n        const termina = ['NH2', 'COOH'];\n    \n        if (seq.startsWith(termina[0])) {\n            const l = termina[0].length; // Cut only 'NH2' without following '-'.\n            assert(seq[l] == '-', `Wrong sequence format: ${termina[0]} without following '-' in '${seq}'.`)\n            start = l;\n        }\n        if (seq.endsWith(termina[1])) {\n            const l = termina[1].length+1; // Cut both 'COOH' and precending '-'.\n            assert(seq[end-l] == '-', `Wrong sequence format: ${termina[1]} without '-' precending in '${seq}'.`)\n            end -= l;\n        }\n        return seq.substring(start, end);\n    }\n\n    /**\n     * Cuts auxiliary defises before a residue.\n     *\n     * @static\n     * @param {string} seq The sequence to process.\n     * @return {string} Processed sequence.\n     * @memberof AlignedSequenceEncoder\n     */\n    static _dropDefises(seq: string): string {\n        return seq.replace(/(-)([^-]+)/g, '$2')\n    }\n\n    /**\n     * Performs truncation and cutting auxiliary defises.\n     *\n     * @static\n     * @param {string} sequence The sequence work under process.\n     * @return {string} Result of cleaning.\n     * @memberof AlignedSequenceEncoder\n     */\n    static clean(sequence: string): string {\n        return AlignedSequenceEncoder._dropDefises(AlignedSequenceEncoder._truncateSequence(sequence));\n    }\n\n    /**\n     * Categorial encode of the sequence provided.\n     *\n     * @param {string} sequence The sequence.\n     * @return {number[]} Encoded vector.\n     * @memberof AlignedSequenceEncoder\n     */\n    public encode(sequence: string): number[] {\n        const nItems = sequence.length;\n        let values = new Array(nItems).fill(0);\n    \n        for (let i = 0; i < nItems; ++i) {\n            let char = sequence[i];\n    \n            assert(char in this.aa2num, `Unknown char '${char}' found in sequence '${sequence}'`);\n    \n            values[i] = this.aa2num[char];\n        }\n        return values;\n    }\n\n    /**\n     * Decode the encoded vector into the sequence back.\n     *\n     * @param {number[]} value The vector encoded.\n     * @return {string} Decoded sequence.\n     * @memberof AlignedSequenceEncoder\n     */\n    public decode(value: number[]): string {\n        let s: string = '';\n    \n        for (let i = 0; i < value.length; ++i) {\n            let code = value[i];\n\n            assert(code in this.num2aa, `Unknown code '${code}' found in vector '${value}'`);\n\n            s += this.num2aa[code];\n        }\n        return s;\n    }\n}\n"]}

package/src/spe.d.ts

@@ -0,0 +1,68 @@
+import { Options, Coordinates, Vectors, DistanceMetric } from './type_declarations';
+/**
+ * Implements stochastic proximity embedding.
+ *
+ * @export
+ * @class SPEBase
+ * @link doi:10.1016/S1093-3263(03)00155-4
+ */
+export declare class SPEBase {
+    protected static dimension: number;
+    protected steps: number;
+    protected cycles: number;
+    protected cutoff: number;
+    protected lambda: number;
+    protected dlambda: number;
+    protected lambda2: number;
+    protected dlambda2: number;
+    protected epsilon: number;
+    protected distanceFunction: DistanceMetric;
+    protected distance: Coordinates;
+    /**
+     * Creates an instance of SPEBase.
+     * @param {Options} [options] Options to pass to the constructor.
+     * @memberof SPEBase
+     */
+    constructor(options?: Options);
+    /**
+     * Initializes distance matrix.
+     *
+     * @protected
+     * @param {Vectors} vectors Input vectors to calculate distance between.
+     * @memberof SPEBase
+     */
+    protected initDistance(vectors: Vectors): void;
+    /**
+     * Calculates distance between the two vectors given.
+     *
+     * @param {Vectors} vectors Set of vectors to calculate distances between.
+     * @param {number} index1 Index of the first vector of the pair.
+     * @param {number} index2 Index of the second vector of the pair.
+     * @return {number} Distance between these two vectors.
+     */
+    protected calcDistance(vectors: Vectors, index1: number, index2: number): number;
+    /**
+     * Embeds the vectors given into a two-dimensional space.
+     *
+     * @param {Vectors} vectors D-dimensional coordinates.
+     * @return {Coordinates} SPE coordinates in D space.
+     */
+    embed(vectors: Vectors): Coordinates;
+}
+/**
+ * Implements modified stochastic proximity embedding.
+ *
+ * @export
+ * @class PSPEBase
+ * @link doi:10.1016/S1093-3263(03)00155-4
+ */
+export declare class PSPEBase extends SPEBase {
+    /**
+     * Embeds the vectors given into a two-dimensional space using a modified update rule.
+     *
+     * @param {Vectors} vectors D-dimensional coordinates.
+     * @return {Coordinates} SPE coordinates in D space.
+     */
+    embed(vectors: Vectors): Coordinates;
+}
+//# sourceMappingURL=spe.d.ts.map

package/src/spe.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spe.d.ts","sourceRoot":"","sources":["spe.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,OAAO,EAAE,WAAW,EAAE,OAAO,EAAE,cAAc,EAAC,MAAM,qBAAqB,CAAC;AAGlF;;;;;;GAMG;AACH,qBAAa,OAAO;IAClB,SAAS,CAAC,MAAM,CAAC,SAAS,SAAK;IAC/B,SAAS,CAAC,KAAK,EAAE,MAAM,CAAC;IACxB,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC;IACzB,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC;IACzB,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC;IACzB,SAAS,CAAC,OAAO,EAAE,MAAM,CAAC;IAC1B,SAAS,CAAC,OAAO,EAAE,MAAM,CAAC;IAC1B,SAAS,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC3B,SAAS,CAAC,OAAO,EAAE,MAAM,CAAC;IAC1B,SAAS,CAAC,gBAAgB,EAAE,cAAc,CAAC;IAC3C,SAAS,CAAC,QAAQ,EAAE,WAAW,CAAC;IAEhC;;;;OAIG;gBACS,OAAO,CAAC,EAAE,OAAO;IAgB7B;;;;;;OAMG;IACH,SAAS,CAAC,YAAY,CAAC,OAAO,EAAE,OAAO;IAIvC;;;;;;;OAOG;IACH,SAAS,CAAC,YAAY,CAAC,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM;IAIhF;;;;;OAKG;IACI,KAAK,CAAC,OAAO,EAAE,OAAO,GAAG,WAAW;CA4C5C;AAED;;;;;;GAMG;AACF,qBAAa,QAAS,SAAQ,OAAO;IACpC;;;;;OAKG;IACI,KAAK,CAAC,OAAO,EAAE,OAAO,GAAG,WAAW;CAsC5C"}

package/src/spe.js

@@ -0,0 +1,151 @@
+import { calculateEuclideanDistance, calcDistanceMatrix, fillRandomMatrix, vectorAdd, randomInt } from './operations';
+/**
+ * Implements stochastic proximity embedding.
+ *
+ * @export
+ * @class SPEBase
+ * @link doi:10.1016/S1093-3263(03)00155-4
+ */
+export class SPEBase {
+    /**
+     * Creates an instance of SPEBase.
+     * @param {Options} [options] Options to pass to the constructor.
+     * @memberof SPEBase
+     */
+    constructor(options) {
+        var _a, _b, _c, _d, _e, _f, _g;
+        this.steps = (_a = options === null || options === void 0 ? void 0 : options.steps) !== null && _a !== void 0 ? _a : 0;
+        this.cycles = (_b = options === null || options === void 0 ? void 0 : options.cycles) !== null && _b !== void 0 ? _b : 1e6;
+        // Select a cutoff distance {cutoff} and ...
+        this.cutoff = (_c = options === null || options === void 0 ? void 0 : options.cutoff) !== null && _c !== void 0 ? _c : 0;
+        // ... an initial learning rate {lambda} > 0
+        this.lambda = (_d = options === null || options === void 0 ? void 0 : options.lambda) !== null && _d !== void 0 ? _d : 2.0;
+        this.dlambda = (_e = options === null || options === void 0 ? void 0 : options.dlambda) !== null && _e !== void 0 ? _e : 0.01;
+        this.lambda2 = this.lambda / 2.;
+        this.dlambda2 = this.dlambda / 2.;
+        this.epsilon = (_f = options === null || options === void 0 ? void 0 : options.epsilon) !== null && _f !== void 0 ? _f : 1e-10;
+        // eslint-disable-next-line brace-style
+        this.distanceFunction = (_g = options === null || options === void 0 ? void 0 : options.distance) !== null && _g !== void 0 ? _g : calculateEuclideanDistance;
+        this.distance = [];
+    }
+    /**
+     * Initializes distance matrix.
+     *
+     * @protected
+     * @param {Vectors} vectors Input vectors to calculate distance between.
+     * @memberof SPEBase
+     */
+    initDistance(vectors) {
+        this.distance = calcDistanceMatrix(vectors, this.distanceFunction);
+    }
+    /**
+     * Calculates distance between the two vectors given.
+     *
+     * @param {Vectors} vectors Set of vectors to calculate distances between.
+     * @param {number} index1 Index of the first vector of the pair.
+     * @param {number} index2 Index of the second vector of the pair.
+     * @return {number} Distance between these two vectors.
+     */
+    calcDistance(vectors, index1, index2) {
+        return this.distance[index1][index2];
+    }
+    /**
+     * Embeds the vectors given into a two-dimensional space.
+     *
+     * @param {Vectors} vectors D-dimensional coordinates.
+     * @return {Coordinates} SPE coordinates in D space.
+     */
+    embed(vectors) {
+        const nItems = vectors.length;
+        const areaWidth = 40;
+        // Initialize the D-dimensional coordinates of the N points.
+        const coordinates = fillRandomMatrix(nItems, SPEBase.dimension, areaWidth);
+        let lambda2 = this.lambda2;
+        if (this.steps == 0) {
+            this.steps = vectors.length - 1;
+        }
+        this.initDistance(vectors);
+        for (let cycle = 0; cycle < this.cycles; ++cycle) {
+            for (let step = 0; step < this.steps; ++step) {
+                // Select two points, i and j, at random, ...
+                const i = randomInt(nItems);
+                let j = randomInt(nItems);
+                while (i == j)
+                    j = randomInt(nItems);
+                const rowi = coordinates[i];
+                const rowj = coordinates[j];
+                // ... retrieve (or evaluate) their proximity in the input space, rij and ...
+                const r = this.calcDistance(vectors, i, j);
+                // ... compute their Euclidean distance on the D-dimensional map, dij.
+                const d = calculateEuclideanDistance(rowi, rowj);
+                // If rij <= rc, or if rij > rc and dij < rij ...
+                if ((this.cutoff == 0) || (r <= this.cutoff) || (d < r)) {
+                    const multiplier = lambda2 * (r - d) / (d + this.epsilon);
+                    // ... update the coordinates xi and xj.
+                    const diffIJ = vectorAdd(rowi, rowj, -1);
+                    coordinates[i] = vectorAdd(rowi, diffIJ, multiplier);
+                    coordinates[j] = vectorAdd(rowj, diffIJ, -multiplier);
+                }
+            }
+            // Decrease the learning rate {lambda} by a prescribed {dlambda}.
+            lambda2 -= this.dlambda2;
+            if (lambda2 <= 0.) {
+                break;
+            }
+        }
+        return coordinates;
+    }
+}
+SPEBase.dimension = 2;
+/**
+ * Implements modified stochastic proximity embedding.
+ *
+ * @export
+ * @class PSPEBase
+ * @link doi:10.1016/S1093-3263(03)00155-4
+ */
+export class PSPEBase extends SPEBase {
+    /**
+     * Embeds the vectors given into a two-dimensional space using a modified update rule.
+     *
+     * @param {Vectors} vectors D-dimensional coordinates.
+     * @return {Coordinates} SPE coordinates in D space.
+     */
+    embed(vectors) {
+        const nItems = vectors.length;
+        const areaWidth = 40;
+        //  Initialize the D-dimensional coordinates of the N points.
+        const coordinates = fillRandomMatrix(nItems, PSPEBase.dimension, areaWidth);
+        let lambda = this.lambda;
+        this.initDistance(vectors);
+        for (let cycle = 0; cycle < this.cycles; ++cycle) {
+            // Select a point, i, at random (pivot).
+            const i = randomInt(nItems);
+            const rowi = coordinates[i];
+            // For every point j != i ...
+            for (let j = 0; j < nItems; ++j) {
+                if (i == j)
+                    continue;
+                const rowj = coordinates[j];
+                // ... retrieve (or evaluate) its proximity to i in the input space, rij ...
+                const r = this.calcDistance(vectors, i, j);
+                // ... and compute their Euclidean distance on the D-dimensional map, dij.
+                const d = calculateEuclideanDistance(rowi, rowj);
+                // If rij <= rc, or if rij > rc and dij < rij ...
+                if ((this.cutoff == 0) || (r <= this.cutoff) || (d < r)) {
+                    const multiplier = lambda * (r - d) / (d + this.epsilon);
+                    const diffIJ = vectorAdd(rowi, rowj, -1);
+                    // ... update the coordinates xj.
+                    coordinates[j] = vectorAdd(rowj, diffIJ, -multiplier);
+                }
+            }
+            // Decrease the learning rate {lambda} by a prescribed {dlambda}.
+            lambda -= this.dlambda;
+            if (lambda <= 0.) {
+                break;
+            }
+        }
+        return coordinates;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"spe.js","sourceRoot":"","sources":["spe.ts"],"names":[],"mappings":"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","sourcesContent":["import {Options, Coordinates, Vectors, DistanceMetric} from './type_declarations';\nimport {calculateEuclideanDistance, calcDistanceMatrix, fillRandomMatrix, vectorAdd, randomInt} from './operations';\n\n/**\n * Implements stochastic proximity embedding.\n *\n * @export\n * @class SPEBase\n * @link doi:10.1016/S1093-3263(03)00155-4\n */\nexport class SPEBase {\n  protected static dimension = 2;\n  protected steps: number;\n  protected cycles: number;\n  protected cutoff: number;\n  protected lambda: number;\n  protected dlambda: number;\n  protected lambda2: number;\n  protected dlambda2: number;\n  protected epsilon: number;\n  protected distanceFunction: DistanceMetric;\n  protected distance: Coordinates;\n\n  /**\n   * Creates an instance of SPEBase.\n   * @param {Options} [options] Options to pass to the constructor.\n   * @memberof SPEBase\n   */\n  constructor(options?: Options) {\n    this.steps = options?.steps ?? 0;\n    this.cycles = options?.cycles ?? 1e6;\n    // Select a cutoff distance {cutoff} and ...\n    this.cutoff = options?.cutoff ?? 0;\n    // ... an initial learning rate {lambda} > 0\n    this.lambda = options?.lambda ?? 2.0;\n    this.dlambda = options?.dlambda ?? 0.01;\n    this.lambda2 = this.lambda/2.;\n    this.dlambda2 = this.dlambda/2.;\n    this.epsilon = options?.epsilon ?? 1e-10;\n    // eslint-disable-next-line brace-style\n    this.distanceFunction = options?.distance ?? calculateEuclideanDistance;\n    this.distance = [];\n  }\n\n  /**\n   * Initializes distance matrix.\n   *\n   * @protected\n   * @param {Vectors} vectors Input vectors to calculate distance between.\n   * @memberof SPEBase\n   */\n  protected initDistance(vectors: Vectors) {\n    this.distance = calcDistanceMatrix(vectors, this.distanceFunction);\n  }\n\n  /**\n   * Calculates distance between the two vectors given.\n   * \n   * @param {Vectors} vectors Set of vectors to calculate distances between.\n   * @param {number} index1 Index of the first vector of the pair.\n   * @param {number} index2 Index of the second vector of the pair.\n   * @return {number} Distance between these two vectors.\n   */\n  protected calcDistance(vectors: Vectors, index1: number, index2: number): number {\n    return this.distance[index1][index2];\n  }\n\n  /**\n   * Embeds the vectors given into a two-dimensional space.\n   * \n   * @param {Vectors} vectors D-dimensional coordinates.\n   * @return {Coordinates} SPE coordinates in D space.\n   */\n  public embed(vectors: Vectors): Coordinates {\n    const nItems = vectors.length;\n    const areaWidth = 40;\n    // Initialize the D-dimensional coordinates of the N points.\n    const coordinates = fillRandomMatrix(nItems, SPEBase.dimension, areaWidth);\n\n    let lambda2 = this.lambda2;\n\n    if (this.steps == 0) {\n      this.steps = vectors.length-1;\n    }\n\n    this.initDistance(vectors);\n\n    for (let cycle = 0; cycle < this.cycles; ++cycle) {\n      for (let step = 0; step < this.steps; ++step) {\n        // Select two points, i and j, at random, ...\n        const i = randomInt(nItems); let j = randomInt(nItems);\n        while (i == j) j = randomInt(nItems);\n\n        const rowi = coordinates[i]; const rowj = coordinates[j];\n\n        // ... retrieve (or evaluate) their proximity in the input space, rij and ...\n        const r = this.calcDistance(vectors, i, j);\n        // ... compute their Euclidean distance on the D-dimensional map, dij.\n        const d = calculateEuclideanDistance(rowi, rowj);\n\n        // If rij <= rc, or if rij > rc and dij < rij ...\n        if ((this.cutoff == 0) || (r <= this.cutoff) || (d < r)) {\n          const multiplier = lambda2*(r-d)/(d+this.epsilon);\n          // ... update the coordinates xi and xj.\n          const diffIJ = vectorAdd(rowi, rowj, -1);\n          coordinates[i] = vectorAdd(rowi, diffIJ, multiplier);\n          coordinates[j] = vectorAdd(rowj, diffIJ, -multiplier);\n        }\n      }\n      // Decrease the learning rate {lambda} by a prescribed {dlambda}.\n      lambda2 -= this.dlambda2;\n      if (lambda2 <= 0.) {\n        break;\n      }\n    }\n    return coordinates;\n  }\n}\n\n/**\n * Implements modified stochastic proximity embedding.\n *\n * @export\n * @class PSPEBase\n * @link doi:10.1016/S1093-3263(03)00155-4\n */\n export class PSPEBase extends SPEBase {\n  /**\n   * Embeds the vectors given into a two-dimensional space using a modified update rule.\n   * \n   * @param {Vectors} vectors D-dimensional coordinates.\n   * @return {Coordinates} SPE coordinates in D space.\n   */\n  public embed(vectors: Vectors): Coordinates {\n    const nItems = vectors.length;\n    const areaWidth = 40;\n    //  Initialize the D-dimensional coordinates of the N points.\n    const coordinates = fillRandomMatrix(nItems, PSPEBase.dimension, areaWidth);\n    let lambda = this.lambda;\n\n    this.initDistance(vectors);\n\n    for (let cycle = 0; cycle < this.cycles; ++cycle) {\n      // Select a point, i, at random (pivot).\n      const i: number = randomInt(nItems);\n      const rowi = coordinates[i];\n\n      // For every point j != i ...\n      for (let j = 0; j < nItems; ++j) {\n        if (i == j) continue;\n        const rowj = coordinates[j];\n        // ... retrieve (or evaluate) its proximity to i in the input space, rij ...\n        const r = this.calcDistance(vectors, i, j);\n        // ... and compute their Euclidean distance on the D-dimensional map, dij.\n        const d = calculateEuclideanDistance(rowi, rowj);\n        // If rij <= rc, or if rij > rc and dij < rij ...\n        if ((this.cutoff == 0) || (r <= this.cutoff) || (d < r)) {\n          const multiplier = lambda*(r-d)/(d+this.epsilon);\n          const diffIJ = vectorAdd(rowi, rowj, -1);\n          // ... update the coordinates xj.\n          coordinates[j] = vectorAdd(rowj, diffIJ, -multiplier);\n        }\n      }\n      // Decrease the learning rate {lambda} by a prescribed {dlambda}.\n      lambda -= this.dlambda;\n      if (lambda <= 0.) {\n        break;\n      }\n    }\n    return coordinates;\n  }\n}\n"]}

package/src/string-measure.d.ts

@@ -0,0 +1,33 @@
+import { DistanceMetric } from './type_declarations';
+/**
+ * Unified class implementing the different string measures.
+ *
+ * @export
+ * @class Measurer
+ */
+export declare class Measurer {
+    protected method: string;
+    static receipt: {
+        [name: string]: DistanceMetric;
+    };
+    /**
+     * Creates an instance of Measurer.
+     * @param {string} method Method to calculate distance between strings.
+     * @memberof Measurer
+     */
+    constructor(method: string);
+    /**
+     * Returns custom string distance function specified.
+     * @return {DistanceMetric} Callback of the measure chosen.
+     */
+    getMeasure(): DistanceMetric;
+    /**
+     * Returns available string distance metrics.
+     *
+     * @readonly
+     * @type {string[]}
+     * @memberof Measurer
+     */
+    static get availableMeasures(): string[];
+}
+//# sourceMappingURL=string-measure.d.ts.map

package/src/string-measure.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"string-measure.d.ts","sourceRoot":"","sources":["string-measure.ts"],"names":[],"mappings":"AAGA,OAAO,EAAC,cAAc,EAAC,MAAM,qBAAqB,CAAC;AAGnD;;;;;GAKG;AACH,qBAAa,QAAQ;IACjB,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC;IACzB,OAAc,OAAO,EAAE;QAAC,CAAC,IAAI,EAAE,MAAM,GAAG,cAAc,CAAA;KAAC,CAGrD;IAEF;;;;OAIG;gBACS,MAAM,EAAE,MAAM;IAK1B;;;OAGG;IACI,UAAU,IAAI,cAAc;IAInC;;;;;;OAMG;IACH,WAAkB,iBAAiB,IAAK,MAAM,EAAE,CAO/C;CAEJ"}

package/src/string-measure.js

@@ -0,0 +1,46 @@
+import * as fl from 'fastest-levenshtein';
+import { jaroWinkler } from 'jaro-winkler-typescript';
+import { assert } from './operations';
+/**
+ * Unified class implementing the different string measures.
+ *
+ * @export
+ * @class Measurer
+ */
+export class Measurer {
+    /**
+     * Creates an instance of Measurer.
+     * @param {string} method Method to calculate distance between strings.
+     * @memberof Measurer
+     */
+    constructor(method) {
+        assert(Measurer.availableMeasures.includes(method), 'The ${method} was not found.');
+        this.method = method;
+    }
+    /**
+     * Returns custom string distance function specified.
+     * @return {DistanceMetric} Callback of the measure chosen.
+     */
+    getMeasure() {
+        return Measurer.receipt[this.method];
+    }
+    /**
+     * Returns available string distance metrics.
+     *
+     * @readonly
+     * @type {string[]}
+     * @memberof Measurer
+     */
+    static get availableMeasures() {
+        let keys = [];
+        for (let key in Measurer.receipt) {
+            keys.push(key);
+        }
+        return keys;
+    }
+}
+Measurer.receipt = {
+    'Levenshtein': fl.distance,
+    'Jaro-Winkler': jaroWinkler,
+};
+//# sourceMappingURL=data:application/json;base64,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

package/src/string-utils.d.ts

@@ -0,0 +1,2 @@
+export declare function tryParseJson(s: string): any;
+//# sourceMappingURL=string-utils.d.ts.map

package/src/string-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"string-utils.d.ts","sourceRoot":"","sources":["string-utils.ts"],"names":[],"mappings":"AAAA,wBAAgB,YAAY,CAAC,CAAC,EAAE,MAAM,GAAI,GAAG,CAO5C"}

package/src/string-utils.js

@@ -0,0 +1,9 @@
+export function tryParseJson(s) {
+    try {
+        return JSON.parse(s);
+    }
+    catch (_) {
+        return null;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RyaW5nLXV0aWxzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsic3RyaW5nLXV0aWxzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sVUFBVSxZQUFZLENBQUMsQ0FBUztJQUNsQyxJQUFJO1FBQ0EsT0FBTyxJQUFJLENBQUMsS0FBSyxDQUFDLENBQUMsQ0FBQyxDQUFDO0tBQ3hCO0lBQ0QsT0FBTyxDQUFDLEVBQUU7UUFDTixPQUFPLElBQUksQ0FBQztLQUNmO0FBQ0wsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBmdW5jdGlvbiB0cnlQYXJzZUpzb24oczogc3RyaW5nKSA6IGFueSB7XG4gICAgdHJ5IHtcbiAgICAgICAgcmV0dXJuIEpTT04ucGFyc2Uocyk7XG4gICAgfVxuICAgIGNhdGNoIChfKSB7XG4gICAgICAgIHJldHVybiBudWxsO1xuICAgIH1cbn0iXX0=

package/src/table-validation.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=table-validation.d.ts.map

package/src/table-validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"table-validation.d.ts","sourceRoot":"","sources":["table-validation.ts"],"names":[],"mappings":""}

package/src/table-validation.js

@@ -0,0 +1,47 @@
+import * as DG from "datagrok-api/dg";
+// @ts-ignore
+let ruleSet = {
+    name: 'SDTM DM rules',
+    rules: [
+        {
+            column: 'age',
+            type: 'int',
+            pattern: '18-90'
+        },
+        {
+            column: 'height',
+            type: 'numerical',
+            pattern: '18-90'
+        },
+        {
+            column: 'sex',
+            type: 'string',
+            pattern: 'in (F, M)'
+        },
+        {
+            column: 'started',
+            type: 'datetime',
+            pattern: '> 1/1/1900'
+        }
+    ]
+};
+/** Returns error message, or null if valid. */
+function validateCell(cell, ruleset) {
+    var _a;
+    let name = cell.column.name.toLowerCase();
+    for (let rule of ruleset.rules)
+        if (rule.column == name) {
+            rule.matcher = (_a = rule.matcher) !== null && _a !== void 0 ? _a : DG.ValueMatcher.forColumn(cell.column, rule.pattern);
+            let error = rule.matcher.validate(cell.value);
+            if (error !== null)
+                return error;
+        }
+    return null;
+}
+function main() {
+    console.log('foo');
+}
+let cell = { column: { name: 'age' }, value: 999 };
+validateCell(cell, ruleSet);
+console.log('ddd');
+//# sourceMappingURL=data:application/json;base64,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

package/src/test-utils.d.ts

@@ -0,0 +1,11 @@
+export declare function getToken(url: string, key: string): Promise<any>;
+export declare function getWebUrl(url: string, token: string): Promise<any>;
+export declare function getDevKey(hostKey: string): {
+    url: string;
+    key: string;
+};
+export declare function getBrowserPage(puppeteer: any): Promise<{
+    browser: any;
+    page: any;
+}>;
+//# sourceMappingURL=test-utils.d.ts.map

package/src/test-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-utils.d.ts","sourceRoot":"","sources":["test-utils.ts"],"names":[],"mappings":"AAOA,wBAAsB,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,gBAOtD;AAED,wBAAsB,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,gBAIzD;AAaD,wBAAgB,SAAS,CAAC,OAAO,EAAE,MAAM,GAAG;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAC,CAkBrE;AAED,wBAAsB,cAAc,CAAC,SAAS,EAAE,GAAG,GAAG,OAAO,CAAC;IAAC,OAAO,EAAE,GAAG,CAAC;IAAC,IAAI,EAAE,GAAG,CAAA;CAAC,CAAC,CA8BvF"}