@datagrok-libraries/utils 0.0.3 → 0.0.7

package/src/operations.js

@@ -0,0 +1,144 @@
+import { Vector } from './type_declarations';
+/**
+ * Asserts a condition by throwing an Error.
+ *
+ * @export
+ * @param {boolean} [condition=false] Condition to assert.
+ * @param {string} [message='Assertion error.'] Message to output.
+ * @throws {Error}
+ */
+export function assert(condition = false, message = 'Assertion error.') {
+    if (!condition) {
+        throw new Error(message);
+    }
+}
+/**
+ * Generates single random integer from 0 to range.
+ *
+ * @export
+ * @param {number} range Max generating value.
+ * @return {number} A random integer generated.
+ */
+export function randomInt(range) {
+    return Math.floor(Math.random() * range);
+}
+/**
+ * Creates new two-dimensional array and fills it with the value given.
+ *
+ * @param {number} dimension1 The first dimension of the coordinates (number of rows).
+ * @param {number} dimension2 The second dimension of the coordinates (number of columns).
+ * @param {number} [fill=0] A value to fill the coordinates with.
+ * @return {Coordinates} A two-dimensional filled with the value given.
+ * @todo Might be slow since used Array.map. Probably needs performance revision.
+ */
+function initCoordinates(dimension1, dimension2, fill = 0) {
+    return new Array(dimension1).fill(fill).map(() => (new Vector(dimension2).fill(fill)));
+}
+/**
+ * Transpose matrix.
+ *
+ * @export
+ * @param {Matrix} matrix The matrix to be transposed.
+ * @return {Matrix} Transposed matrix.
+ * @todo Might be slow since used Array.map. Probably needs performance revision.
+ */
+export function transposeMatrix(matrix) {
+    return new Array(matrix[0].length).fill(0).map((_, i) => (new Vector(matrix.length).fill(0).map((_, j) => (matrix[j][i]))));
+}
+/**
+ * Adds two vectors with the second one to be multiplied by the given ratio.
+ *
+ * @export
+ * @param {Vector} p The first vector to add.
+ * @param {Vector} q The second vector to add.
+ * @param {number} [multiplier=1] A multiplier to be used before the second vector is added.
+ * @return {Vector} New vector contained the result of operation p+multiplier*q.
+ */
+export function vectorAdd(p, q, multiplier = 1) {
+    const nItems = p.length;
+    assert(nItems == q.length, 'Vector lengths do not match.');
+    let total = new Vector(nItems);
+    for (let i = 0; i < p.length; ++i) {
+        total[i] = p[i] + multiplier * q[i];
+    }
+    return total;
+}
+/**
+ * Sums the vector's items.
+ *
+ * @param {Vector} v The vector to be summed.
+ * @return {number} The vector's items sum.
+ */
+function itemsSum(v) {
+    let total = 0;
+    for (let i = 0; i < v.length; ++i) {
+        total += v[i];
+    }
+    return total;
+}
+/**
+ * Suqares the vector's items.
+ *
+ * @param {Vector} v The vector to square.
+ * @return {Vector} A new vector containing the original's items squared.
+ */
+function vectorSquare(v) {
+    const nItems = v.length;
+    let total = new Vector(nItems);
+    for (let i = 0; i < v.length; ++i) {
+        total[i] = v[i] * v[i];
+    }
+    return total;
+}
+/**
+ * Creates a matrix filled with random floating point values.
+ *
+ * @export
+ * @param {number} dimension1 The first dimension of the matrix.
+ * @param {number} dimension2 The second dimension of the matrix.
+ * @param {number} [scale=1.] Max value given by random generator.
+ * @return {Matrix} A new matrix filled with random floating point  values.
+ */
+export function fillRandomMatrix(dimension1, dimension2, scale = 1.) {
+    let matrix = initCoordinates(dimension1, dimension2);
+    for (let i = 0; i < dimension1; ++i) {
+        for (let j = 0; j < dimension2; ++j) {
+            matrix[i][j] = Math.random() * scale;
+        }
+    }
+    return matrix;
+}
+/**
+ * Calculates Euclidean distance between two vectors.
+ *
+ * @export
+ * @param {Vector} p The first vector.
+ * @param {Vector} q The second vector.
+ * @return {number} Euclidean distance between the given vectors.
+ */
+export function calculateEuclideanDistance(p, q) {
+    const diff = vectorAdd(p, q, -1);
+    const sqdiff = vectorSquare(diff);
+    const sqdiffSumm = itemsSum(sqdiff);
+    return Math.sqrt(sqdiffSumm);
+}
+/**
+ * Creates a distance matrix using a custom distance function.
+ *
+ * @export
+ * @param {Vectors} data Input vectors to calculate distances.
+ * @param {DistanceMetric} distance Custom distance function.
+ * @return {Matrix} Calculated custom distance matrix.
+ */
+export function calcDistanceMatrix(data, distance) {
+    const nItems = data.length;
+    let matrix = initCoordinates(nItems, nItems, 0);
+    for (let i = 0; i < nItems; ++i) {
+        for (let j = i + 1; j < nItems; ++j) {
+            const d = (data[i] == null) || (data[j] == null) ? 0 : distance(data[i], data[j]);
+            matrix[i][j] = matrix[j][i] = d;
+        }
+    }
+    return matrix;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"operations.js","sourceRoot":"","sources":["operations.ts"],"names":[],"mappings":"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","sourcesContent":["import {Matrix, Vector, Coordinates, Vectors, DistanceMetric} from './type_declarations';\r\n\r\n/**\r\n * Asserts a condition by throwing an Error.\r\n *\r\n * @export\r\n * @param {boolean} [condition=false] Condition to assert.\r\n * @param {string} [message='Assertion error.'] Message to output.\r\n * @throws {Error}\r\n */\r\nexport function assert(condition: boolean = false, message: string = 'Assertion error.') {\r\n  if (!condition) {\r\n    throw new Error(message);\r\n  }\r\n}\r\n\r\n/**\r\n * Generates single random integer from 0 to range.\r\n *\r\n * @export\r\n * @param {number} range Max generating value.\r\n * @return {number} A random integer generated.\r\n */\r\nexport function randomInt(range: number): number {\r\n  return Math.floor(Math.random() * range);\r\n}\r\n\r\n/**\r\n * Creates new two-dimensional array and fills it with the value given.\r\n *\r\n * @param {number} dimension1 The first dimension of the coordinates (number of rows).\r\n * @param {number} dimension2 The second dimension of the coordinates (number of columns).\r\n * @param {number} [fill=0] A value to fill the coordinates with.\r\n * @return {Coordinates} A two-dimensional filled with the value given.\r\n * @todo Might be slow since used Array.map. Probably needs performance revision.\r\n */\r\nfunction initCoordinates(dimension1: number, dimension2: number, fill: number = 0): Coordinates {\r\n  return new Array(dimension1).fill(fill).map(() => (new Vector(dimension2).fill(fill)));\r\n}\r\n\r\n/**\r\n * Transpose matrix.\r\n *\r\n * @export\r\n * @param {Matrix} matrix The matrix to be transposed.\r\n * @return {Matrix} Transposed matrix.\r\n * @todo Might be slow since used Array.map. Probably needs performance revision.\r\n */\r\nexport function transposeMatrix(matrix: Matrix): Matrix {\r\n  return new Array(matrix[0].length).fill(0).map((_, i) => (new Vector(matrix.length).fill(0).map((_, j) => (matrix[j][i]))));\r\n}\r\n\r\n/**\r\n * Adds two vectors with the second one to be multiplied by the given ratio.\r\n *\r\n * @export\r\n * @param {Vector} p The first vector to add.\r\n * @param {Vector} q The second vector to add.\r\n * @param {number} [multiplier=1] A multiplier to be used before the second vector is added.\r\n * @return {Vector} New vector contained the result of operation p+multiplier*q.\r\n */\r\nexport function vectorAdd(p: Vector, q: Vector, multiplier: number = 1): Vector {\r\n  const nItems = p.length;\r\n\r\n  assert(nItems == q.length, 'Vector lengths do not match.')\r\n\r\n  let total = new Vector(nItems);\r\n\r\n  for (let i = 0; i < p.length; ++i) {\r\n    total[i] = p[i]+multiplier*q[i];\r\n  }\r\n  return total;\r\n}\r\n\r\n/**\r\n * Sums the vector's items.\r\n *\r\n * @param {Vector} v The vector to be summed.\r\n * @return {number} The vector's items sum.\r\n */\r\nfunction itemsSum(v: Vector): number {\r\n  let total = 0;\r\n\r\n  for (let i = 0; i < v.length; ++i) {\r\n    total += v[i];\r\n  }\r\n  return total;\r\n}\r\n\r\n/**\r\n * Suqares the vector's items.\r\n *\r\n * @param {Vector} v The vector to square.\r\n * @return {Vector} A new vector containing the original's items squared.\r\n */\r\nfunction vectorSquare(v: Vector): Vector {\r\n  const nItems = v.length;\r\n  let total = new Vector(nItems);\r\n\r\n  for (let i = 0; i < v.length; ++i) {\r\n    total[i] = v[i]*v[i];\r\n  }\r\n  return total;\r\n}\r\n\r\n/**\r\n * Creates a matrix filled with random floating point values.\r\n *\r\n * @export\r\n * @param {number} dimension1 The first dimension of the matrix.\r\n * @param {number} dimension2 The second dimension of the matrix.\r\n * @param {number} [scale=1.] Max value given by random generator.\r\n * @return {Matrix} A new matrix filled with random floating point  values.\r\n */\r\nexport function fillRandomMatrix(dimension1: number, dimension2: number, scale: number = 1.): Matrix {\r\n  let matrix = initCoordinates(dimension1, dimension2);\r\n\r\n  for (let i = 0; i < dimension1; ++i) {\r\n    for (let j = 0; j < dimension2; ++j) {\r\n      matrix[i][j] = Math.random() * scale;\r\n    }\r\n  }\r\n  return matrix;\r\n}\r\n\r\n/**\r\n * Calculates Euclidean distance between two vectors.\r\n *\r\n * @export\r\n * @param {Vector} p The first vector.\r\n * @param {Vector} q The second vector.\r\n * @return {number} Euclidean distance between the given vectors.\r\n */\r\nexport function calculateEuclideanDistance(p: Vector, q: Vector): number {\r\n  const diff = vectorAdd(p, q, -1);\r\n  const sqdiff = vectorSquare(diff);\r\n  const sqdiffSumm = itemsSum(sqdiff);\r\n  return Math.sqrt(sqdiffSumm);\r\n}\r\n\r\n/**\r\n * Creates a distance matrix using a custom distance function.\r\n *\r\n * @export\r\n * @param {Vectors} data Input vectors to calculate distances.\r\n * @param {DistanceMetric} distance Custom distance function.\r\n * @return {Matrix} Calculated custom distance matrix.\r\n */\r\nexport function calcDistanceMatrix(data: Vectors, distance: DistanceMetric): Matrix {\r\n  const nItems = data.length;\r\n  let matrix = initCoordinates(nItems, nItems, 0);\r\n\r\n  for (let i = 0; i < nItems; ++i) {\r\n    for (let j = i+1; j < nItems; ++j) {\r\n      const d: number = (data[i] == null) || (data[j] == null) ? 0 : distance(data[i], data[j]);\r\n      matrix[i][j] = matrix[j][i] = d;\r\n    }\r\n  }\r\n  return matrix;\r\n}\r\n"]}

package/src/operations.ts

@@ -0,0 +1,160 @@
+import {Matrix, Vector, Coordinates, Vectors, DistanceMetric} from './type_declarations';
+
+/**
+ * Asserts a condition by throwing an Error.
+ *
+ * @export
+ * @param {boolean} [condition=false] Condition to assert.
+ * @param {string} [message='Assertion error.'] Message to output.
+ * @throws {Error}
+ */
+export function assert(condition: boolean = false, message: string = 'Assertion error.') {
+  if (!condition) {
+    throw new Error(message);
+  }
+}
+
+/**
+ * Generates single random integer from 0 to range.
+ *
+ * @export
+ * @param {number} range Max generating value.
+ * @return {number} A random integer generated.
+ */
+export function randomInt(range: number): number {
+  return Math.floor(Math.random() * range);
+}
+
+/**
+ * Creates new two-dimensional array and fills it with the value given.
+ *
+ * @param {number} dimension1 The first dimension of the coordinates (number of rows).
+ * @param {number} dimension2 The second dimension of the coordinates (number of columns).
+ * @param {number} [fill=0] A value to fill the coordinates with.
+ * @return {Coordinates} A two-dimensional filled with the value given.
+ * @todo Might be slow since used Array.map. Probably needs performance revision.
+ */
+function initCoordinates(dimension1: number, dimension2: number, fill: number = 0): Coordinates {
+  return new Array(dimension1).fill(fill).map(() => (new Vector(dimension2).fill(fill)));
+}
+
+/**
+ * Transpose matrix.
+ *
+ * @export
+ * @param {Matrix} matrix The matrix to be transposed.
+ * @return {Matrix} Transposed matrix.
+ * @todo Might be slow since used Array.map. Probably needs performance revision.
+ */
+export function transposeMatrix(matrix: Matrix): Matrix {
+  return new Array(matrix[0].length).fill(0).map((_, i) => (new Vector(matrix.length).fill(0).map((_, j) => (matrix[j][i]))));
+}
+
+/**
+ * Adds two vectors with the second one to be multiplied by the given ratio.
+ *
+ * @export
+ * @param {Vector} p The first vector to add.
+ * @param {Vector} q The second vector to add.
+ * @param {number} [multiplier=1] A multiplier to be used before the second vector is added.
+ * @return {Vector} New vector contained the result of operation p+multiplier*q.
+ */
+export function vectorAdd(p: Vector, q: Vector, multiplier: number = 1): Vector {
+  const nItems = p.length;
+
+  assert(nItems == q.length, 'Vector lengths do not match.')
+
+  let total = new Vector(nItems);
+
+  for (let i = 0; i < p.length; ++i) {
+    total[i] = p[i]+multiplier*q[i];
+  }
+  return total;
+}
+
+/**
+ * Sums the vector's items.
+ *
+ * @param {Vector} v The vector to be summed.
+ * @return {number} The vector's items sum.
+ */
+function itemsSum(v: Vector): number {
+  let total = 0;
+
+  for (let i = 0; i < v.length; ++i) {
+    total += v[i];
+  }
+  return total;
+}
+
+/**
+ * Suqares the vector's items.
+ *
+ * @param {Vector} v The vector to square.
+ * @return {Vector} A new vector containing the original's items squared.
+ */
+function vectorSquare(v: Vector): Vector {
+  const nItems = v.length;
+  let total = new Vector(nItems);
+
+  for (let i = 0; i < v.length; ++i) {
+    total[i] = v[i]*v[i];
+  }
+  return total;
+}
+
+/**
+ * Creates a matrix filled with random floating point values.
+ *
+ * @export
+ * @param {number} dimension1 The first dimension of the matrix.
+ * @param {number} dimension2 The second dimension of the matrix.
+ * @param {number} [scale=1.] Max value given by random generator.
+ * @return {Matrix} A new matrix filled with random floating point  values.
+ */
+export function fillRandomMatrix(dimension1: number, dimension2: number, scale: number = 1.): Matrix {
+  let matrix = initCoordinates(dimension1, dimension2);
+
+  for (let i = 0; i < dimension1; ++i) {
+    for (let j = 0; j < dimension2; ++j) {
+      matrix[i][j] = Math.random() * scale;
+    }
+  }
+  return matrix;
+}
+
+/**
+ * Calculates Euclidean distance between two vectors.
+ *
+ * @export
+ * @param {Vector} p The first vector.
+ * @param {Vector} q The second vector.
+ * @return {number} Euclidean distance between the given vectors.
+ */
+export function calculateEuclideanDistance(p: Vector, q: Vector): number {
+  const diff = vectorAdd(p, q, -1);
+  const sqdiff = vectorSquare(diff);
+  const sqdiffSumm = itemsSum(sqdiff);
+  return Math.sqrt(sqdiffSumm);
+}
+
+/**
+ * Creates a distance matrix using a custom distance function.
+ *
+ * @export
+ * @param {Vectors} data Input vectors to calculate distances.
+ * @param {DistanceMetric} distance Custom distance function.
+ * @return {Matrix} Calculated custom distance matrix.
+ */
+export function calcDistanceMatrix(data: Vectors, distance: DistanceMetric): Matrix {
+  const nItems = data.length;
+  let matrix = initCoordinates(nItems, nItems, 0);
+
+  for (let i = 0; i < nItems; ++i) {
+    for (let j = i+1; j < nItems; ++j) {
+      const d: number = (data[i] == null) || (data[j] == null) ? 0 : distance(data[i], data[j]);
+      matrix[i][j] = matrix[j][i] = d;
+    }
+  }
+  return matrix;
+}

package/src/reduce-dimensionality.js

@@ -0,0 +1,233 @@
+import * as umj from 'umap-js';
+import { TSNE } from '@keckelt/tsne';
+import { Vector } from './type_declarations';
+import { calcDistanceMatrix, transposeMatrix } from './operations';
+import { SPEBase, PSPEBase } from './spe';
+import { Measurer } from './string-measure';
+import { AlignedSequenceEncoder } from './sequence-encoder';
+import { assert } from './operations';
+/**
+ * Abstract dimensionality reducer.
+ *
+ * @abstract
+ * @class Reducer
+ */
+class Reducer {
+    /**
+     * Creates an instance of Reducer.
+     * @param {Options} options Options to pass to the constructor.
+     * @memberof Reducer
+     */
+    constructor(options) {
+        this.data = options.data;
+    }
+}
+/**
+ * Implements t-SNE dimensionality reduction.
+ *
+ * @class TSNEReducer
+ * @extends {Reducer}
+ */
+class TSNEReducer extends Reducer {
+    /**
+     * Creates an instance of TSNEReducer.
+     * @param {Options} options Options to pass to the constructor.
+     * @memberof TSNEReducer
+     */
+    constructor(options) {
+        var _a;
+        super(options);
+        this.reducer = new TSNE(options);
+        this.iterations = (_a = options === null || options === void 0 ? void 0 : options.iterations) !== null && _a !== void 0 ? _a : 100;
+        this.distance = options.distance;
+    }
+    /**
+     * Embeds the data given into the two-dimensional space using t-SNE method.
+     * @return {Coordinates} Cartesian coordinate of this embedding.
+     */
+    transform() {
+        this.reducer.initDataDist(calcDistanceMatrix(this.data, this.distance));
+        for (let i = 0; i < this.iterations; ++i) {
+            this.reducer.step(); // every time you call this, solution gets better
+        }
+        return this.reducer.getSolution();
+    }
+}
+/**
+ * Implements UMAP dimensionality reduction.
+ *
+ * @class UMAPReducer
+ * @extends {Reducer}
+ */
+class UMAPReducer extends Reducer {
+    /**
+     * Creates an instance of UMAPReducer.
+     * @param {Options} options Options to pass to the constructor.
+     * @memberof UMAPReducer
+     */
+    constructor(options) {
+        super(options);
+        assert('distanceFn' in options);
+        this.encoder = new AlignedSequenceEncoder();
+        this.distanceFn = options.distanceFn;
+        this.vectors = [];
+        options.distanceFn = this._encodedDistance.bind(this);
+        this.reducer = new umj.UMAP(options);
+    }
+    /**
+     * Custom distance wrapper to have numeric inputs instead of string ones.
+     *
+     * @protected
+     * @param {number[]} a The first item.
+     * @param {number[]} b The first item.
+     * @return {number} Distance metric.
+     * @memberof UMAPReducer
+     */
+    _encodedDistance(a, b) {
+        return this.distanceFn(this.data[a[0]], this.data[b[0]]);
+    }
+    /**
+     * Encodes the input data as a vector of indices.
+     *
+     * @protected
+     * @memberof UMAPReducer
+     */
+    _encode() {
+        for (let i = 0; i < this.data.length; ++i) {
+            this.vectors.push([i]);
+        }
+    }
+    /**
+     * Embeds the data given into the two-dimensional space using UMAP method.
+     * @return {Coordinates} Cartesian coordinate of this embedding.
+     */
+    transform() {
+        this._encode();
+        const embedding = this.reducer.fit(this.vectors);
+        function arrayCast2Coordinates(data) {
+            return new Array(data.length).fill(0).map((_, i) => (Vector.from(data[i])));
+        }
+        return arrayCast2Coordinates(embedding);
+    }
+}
+/**
+ * Implements original SPE dimensionality reduction.
+ *
+ * @class SPEReducer
+ * @extends {Reducer}
+ */
+class SPEReducer extends Reducer {
+    /**
+     * Creates an instance of SPEReducer.
+     * @param {Options} options Options to pass to the constructor.
+     * @memberof SPEReducer
+     */
+    constructor(options) {
+        super(options);
+        this.reducer = new SPEBase(options);
+    }
+    /**
+     * Embeds the data given into the two-dimensional space using the original SPE method.
+     * @return {Coordinates} Cartesian coordinate of this embedding.
+     */
+    transform() {
+        return this.reducer.embed(this.data);
+    }
+}
+/**
+ * Implements modified SPE dimensionality reduction.
+ *
+ * @class PSPEReducer
+ * @extends {Reducer}
+ */
+class PSPEReducer extends Reducer {
+    /**
+     * Creates an instance of PSPEReducer.
+     * @param {Options} options Options to pass to the constructor.
+     * @memberof PSPEReducer
+     */
+    constructor(options) {
+        super(options);
+        this.reducer = new PSPEBase(options);
+    }
+    /**
+     * Embeds the data given into the two-dimensional space using the modified SPE method.
+     * @return {Coordinates} Cartesian coordinate of this embedding.
+     */
+    transform() {
+        return this.reducer.embed(this.data);
+    }
+}
+/**
+ * Unified class implementing different dimensionality reduction methods.
+ *
+ * @export
+ * @class DimensionalityReducer
+ */
+export class DimensionalityReducer {
+    /**
+     * Creates an instance of DimensionalityReducer.
+     * @param {any[]} data Vectors to embed.
+     * @param {string} method Embedding method to be applied
+     * @param {string} metric Distance metric to be computed between each of the vectors.
+     * @param {Options} [options] Options to pass to the implementing embedders.
+     * @memberof DimensionalityReducer
+     */
+    constructor(data, method, metric, options) {
+        var _a;
+        assert(DimensionalityReducer.availableMethods.includes(method), `The method '${method}' is not supported`);
+        this.measurer = new Measurer(metric);
+        const measure = this.measurer.getMeasure();
+        if (method == 'UMAP') {
+            this.reducer = new UMAPReducer({
+                ...{ data: data },
+                ...{ distanceFn: measure },
+                ...{ nEpochs: options === null || options === void 0 ? void 0 : options.cycles },
+                ...options
+            });
+        }
+        else if (method == 't-SNE') {
+            this.reducer = new TSNEReducer({
+                ...{ data: data },
+                ...{ distance: measure },
+                ...{ iterations: (_a = options === null || options === void 0 ? void 0 : options.cycles) !== null && _a !== void 0 ? _a : undefined },
+                ...options,
+            });
+        }
+        else if (method == 'SPE') {
+            this.reducer = new SPEReducer({ ...{ data: data }, ...{ distance: measure }, ...options });
+        }
+        else {
+            this.reducer = new PSPEReducer({ ...{ data: data }, ...{ distance: measure }, ...options });
+        }
+    }
+    /**
+     * Embeds the data given into the two-dimensional space using the chosen method.
+     *
+     * @param {boolean} transpose Whether to transform coordinates to have columns-first orientation.
+     * @throws {Error} If the embedding method was not found.
+     * @return {Coordinates} Cartesian coordinate of this embedding.
+     * @memberof DimensionalityReducer
+     */
+    transform(transpose = false) {
+        if (this.reducer == undefined) {
+            throw new Error('Reducer was not defined.');
+        }
+        let embedding = this.reducer.transform();
+        if (transpose) {
+            embedding = transposeMatrix(embedding);
+        }
+        return embedding;
+    }
+    /**
+     * Returns dimensionality reduction methods available.
+     *
+     * @readonly
+     * @memberof DimensionalityReducer
+     */
+    static get availableMethods() {
+        return DimensionalityReducer.methods;
+    }
+}
+DimensionalityReducer.methods = ['UMAP', 't-SNE', 'SPE', 'pSPE'];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"reduce-dimensionality.js","sourceRoot":"","sources":["reduce-dimensionality.ts"],"names":[],"mappings":"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","sourcesContent":["import * as umj from 'umap-js';\r\nimport {TSNE} from '@keckelt/tsne';\r\n\r\nimport {Options, DistanceMetric, Coordinates, Vector, Vectors, Matrix} from './type_declarations';\r\nimport {calcDistanceMatrix, transposeMatrix} from './operations';\r\nimport {SPEBase, PSPEBase} from './spe';\r\nimport {Measurer} from './string-measure';\r\nimport {AlignedSequenceEncoder} from './sequence-encoder';\r\nimport {assert} from './operations';\r\n\r\n/**\r\n * Abstract dimensionality reducer.\r\n *\r\n * @abstract\r\n * @class Reducer\r\n */\r\nabstract class Reducer {\r\n  protected data: Vectors;\r\n\r\n  /**\r\n   * Creates an instance of Reducer.\r\n   * @param {Options} options Options to pass to the constructor.\r\n   * @memberof Reducer\r\n   */\r\n  constructor(options: Options) {\r\n    this.data = options.data;\r\n  }\r\n\r\n  /**\r\n   * Is to embed the data given into the two-dimensional space.\r\n   *\r\n   * @abstract\r\n   * @return {Coordinates} Cartesian coordinate of this embedding.\r\n   * @memberof Reducer\r\n   */\r\n  abstract transform(): Coordinates;\r\n}\r\n\r\n/**\r\n * Implements t-SNE dimensionality reduction.\r\n *\r\n * @class TSNEReducer\r\n * @extends {Reducer}\r\n */\r\nclass TSNEReducer extends Reducer {\r\n  protected reducer: TSNE;\r\n  protected iterations: number;\r\n  protected distance: DistanceMetric;\r\n\r\n  /**\r\n   * Creates an instance of TSNEReducer.\r\n   * @param {Options} options Options to pass to the constructor.\r\n   * @memberof TSNEReducer\r\n   */\r\n  constructor(options: Options) {\r\n    super(options);\r\n    this.reducer = new TSNE(options);\r\n    this.iterations = options?.iterations ?? 100;\r\n    this.distance = options.distance;\r\n  }\r\n\r\n  /**\r\n   * Embeds the data given into the two-dimensional space using t-SNE method.\r\n   * @return {Coordinates} Cartesian coordinate of this embedding.\r\n   */\r\n  public transform(): Coordinates {\r\n    this.reducer.initDataDist(calcDistanceMatrix(this.data, this.distance));\r\n\r\n    for (let i = 0; i < this.iterations; ++i) {\r\n      this.reducer.step(); // every time you call this, solution gets better\r\n    }\r\n    return this.reducer.getSolution();\r\n  }\r\n}\r\n\r\n/**\r\n * Implements UMAP dimensionality reduction.\r\n *\r\n * @class UMAPReducer\r\n * @extends {Reducer}\r\n */\r\nclass UMAPReducer extends Reducer {\r\n  protected reducer: umj.UMAP;\r\n  protected encoder: AlignedSequenceEncoder;\r\n  protected distanceFn: Function;\r\n  protected vectors: number[][];\r\n\r\n  /**\r\n   * Creates an instance of UMAPReducer.\r\n   * @param {Options} options Options to pass to the constructor.\r\n   * @memberof UMAPReducer\r\n   */\r\n  constructor(options: Options) {\r\n    super(options);\r\n\r\n    assert('distanceFn' in options);\r\n\r\n    this.encoder = new AlignedSequenceEncoder();\r\n    this.distanceFn = options.distanceFn;\r\n    this.vectors = [];\r\n    options.distanceFn = this._encodedDistance.bind(this);\r\n    this.reducer = new umj.UMAP(options);\r\n  }\r\n\r\n  /**\r\n   * Custom distance wrapper to have numeric inputs instead of string ones.\r\n   *\r\n   * @protected\r\n   * @param {number[]} a The first item.\r\n   * @param {number[]} b The first item.\r\n   * @return {number} Distance metric.\r\n   * @memberof UMAPReducer\r\n   */\r\n  protected _encodedDistance(a: number[], b: number[]): number {\r\n    return this.distanceFn(this.data[a[0]], this.data[b[0]]);\r\n  }\r\n\r\n  /**\r\n   * Encodes the input data as a vector of indices.\r\n   *\r\n   * @protected\r\n   * @memberof UMAPReducer\r\n   */\r\n  protected _encode() {\r\n    for (let i = 0; i < this.data.length; ++i) {\r\n      this.vectors.push([i]);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Embeds the data given into the two-dimensional space using UMAP method.\r\n   * @return {Coordinates} Cartesian coordinate of this embedding.\r\n   */\r\n  public transform(): Coordinates {\r\n    this._encode();\r\n\r\n    const embedding = this.reducer.fit(this.vectors);\r\n\r\n    function arrayCast2Coordinates(data: number[][]): Coordinates {\r\n      return new Array(data.length).fill(0).map((_, i) => (Vector.from(data[i])));\r\n    }\r\n\r\n    return arrayCast2Coordinates(embedding);\r\n  }\r\n}\r\n\r\n/**\r\n * Implements original SPE dimensionality reduction.\r\n *\r\n * @class SPEReducer\r\n * @extends {Reducer}\r\n */\r\nclass SPEReducer extends Reducer {\r\n  protected reducer: SPEBase;\r\n\r\n  /**\r\n   * Creates an instance of SPEReducer.\r\n   * @param {Options} options Options to pass to the constructor.\r\n   * @memberof SPEReducer\r\n   */\r\n  constructor(options: Options) {\r\n    super(options);\r\n    this.reducer = new SPEBase(options);\r\n  }\r\n\r\n  /**\r\n   * Embeds the data given into the two-dimensional space using the original SPE method.\r\n   * @return {Coordinates} Cartesian coordinate of this embedding.\r\n   */\r\n  public transform(): Coordinates {\r\n    return this.reducer.embed(this.data);\r\n  }\r\n}\r\n\r\n/**\r\n * Implements modified SPE dimensionality reduction.\r\n *\r\n * @class PSPEReducer\r\n * @extends {Reducer}\r\n */\r\nclass PSPEReducer extends Reducer {\r\n  protected reducer: PSPEBase;\r\n\r\n  /**\r\n   * Creates an instance of PSPEReducer.\r\n   * @param {Options} options Options to pass to the constructor.\r\n   * @memberof PSPEReducer\r\n   */\r\n  constructor(options: Options) {\r\n    super(options);\r\n    this.reducer = new PSPEBase(options);\r\n  }\r\n\r\n  /**\r\n   * Embeds the data given into the two-dimensional space using the modified SPE method.\r\n   * @return {Coordinates} Cartesian coordinate of this embedding.\r\n   */\r\n  public transform(): Coordinates {\r\n    return this.reducer.embed(this.data);\r\n  }\r\n}\r\n\r\n/**\r\n * Unified class implementing different dimensionality reduction methods.\r\n *\r\n * @export\r\n * @class DimensionalityReducer\r\n */\r\nexport class DimensionalityReducer {\r\n  private reducer: Reducer | undefined;\r\n  public static methods: string[] = ['UMAP', 't-SNE', 'SPE', 'pSPE'];\r\n  private measurer: Measurer;\r\n\r\n  /**\r\n   * Creates an instance of DimensionalityReducer.\r\n   * @param {any[]} data Vectors to embed.\r\n   * @param {string} method Embedding method to be applied\r\n   * @param {string} metric Distance metric to be computed between each of the vectors.\r\n   * @param {Options} [options] Options to pass to the implementing embedders.\r\n   * @memberof DimensionalityReducer\r\n   */\r\n  constructor(data: any[], method: string, metric: string, options?: Options) {\r\n    assert(DimensionalityReducer.availableMethods.includes(method), `The method '${method}' is not supported`);\r\n\r\n    this.measurer = new Measurer(metric);\r\n    const measure = this.measurer.getMeasure()\r\n\r\n    if (method == 'UMAP') {\r\n      this.reducer = new UMAPReducer({\r\n        ...{data: data}, \r\n        ...{distanceFn: measure}, \r\n        ...{nEpochs: options?.cycles},\r\n        ...options\r\n      });\r\n    } else if (method == 't-SNE') {\r\n      this.reducer = new TSNEReducer({\r\n        ...{data: data},\r\n        ...{distance: measure},\r\n        ...{iterations: options?.cycles ?? undefined},\r\n        ...options,\r\n      });\r\n    } else if (method == 'SPE') {\r\n      this.reducer = new SPEReducer({...{data: data}, ...{distance: measure}, ...options});\r\n    } else {\r\n      this.reducer = new PSPEReducer({...{data: data}, ...{distance: measure}, ...options});\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Embeds the data given into the two-dimensional space using the chosen method.\r\n   *\r\n   * @param {boolean} transpose Whether to transform coordinates to have columns-first orientation.\r\n   * @throws {Error} If the embedding method was not found.\r\n   * @return {Coordinates} Cartesian coordinate of this embedding.\r\n   * @memberof DimensionalityReducer\r\n   */\r\n  public transform(transpose: boolean = false): Coordinates {\r\n    if (this.reducer == undefined) {\r\n      throw new Error('Reducer was not defined.');\r\n    }\r\n    let embedding = this.reducer.transform();\r\n\r\n    if (transpose) {\r\n      embedding = transposeMatrix(embedding);\r\n    }\r\n    return embedding;\r\n  }\r\n\r\n  /**\r\n   * Returns dimensionality reduction methods available.\r\n   *\r\n   * @readonly\r\n   * @memberof DimensionalityReducer\r\n   */\r\n  static get availableMethods() {\r\n    return DimensionalityReducer.methods;\r\n  }\r\n}\r\n"]}