@datagrok-libraries/utils 0.0.7 → 0.0.11

package/src/operations.ts

@@ -1,160 +0,0 @@
-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.ts

@@ -1,278 +0,0 @@
-import * as umj from 'umap-js';
-import {TSNE} from '@keckelt/tsne';
-
-import {Options, DistanceMetric, Coordinates, Vector, Vectors, Matrix} 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
- */
-abstract class Reducer {
-  protected data: Vectors;
-
-  /**
-   * Creates an instance of Reducer.
-   * @param {Options} options Options to pass to the constructor.
-   * @memberof Reducer
-   */
-  constructor(options: Options) {
-    this.data = options.data;
-  }
-
-  /**
-   * Is to embed the data given into the two-dimensional space.
-   *
-   * @abstract
-   * @return {Coordinates} Cartesian coordinate of this embedding.
-   * @memberof Reducer
-   */
-  abstract transform(): Coordinates;
-}
-
-/**
- * Implements t-SNE dimensionality reduction.
- *
- * @class TSNEReducer
- * @extends {Reducer}
- */
-class TSNEReducer extends Reducer {
-  protected reducer: TSNE;
-  protected iterations: number;
-  protected distance: DistanceMetric;
-
-  /**
-   * Creates an instance of TSNEReducer.
-   * @param {Options} options Options to pass to the constructor.
-   * @memberof TSNEReducer
-   */
-  constructor(options: Options) {
-    super(options);
-    this.reducer = new TSNE(options);
-    this.iterations = options?.iterations ?? 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.
-   */
-  public transform(): Coordinates {
-    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 {
-  protected reducer: umj.UMAP;
-  protected encoder: AlignedSequenceEncoder;
-  protected distanceFn: Function;
-  protected vectors: number[][];
-
-  /**
-   * Creates an instance of UMAPReducer.
-   * @param {Options} options Options to pass to the constructor.
-   * @memberof UMAPReducer
-   */
-  constructor(options: 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
-   */
-  protected _encodedDistance(a: number[], b: number[]): number {
-    return this.distanceFn(this.data[a[0]], this.data[b[0]]);
-  }
-
-  /**
-   * Encodes the input data as a vector of indices.
-   *
-   * @protected
-   * @memberof UMAPReducer
-   */
-  protected _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.
-   */
-  public transform(): Coordinates {
-    this._encode();
-
-    const embedding = this.reducer.fit(this.vectors);
-
-    function arrayCast2Coordinates(data: number[][]): Coordinates {
-      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 {
-  protected reducer: SPEBase;
-
-  /**
-   * Creates an instance of SPEReducer.
-   * @param {Options} options Options to pass to the constructor.
-   * @memberof SPEReducer
-   */
-  constructor(options: 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.
-   */
-  public transform(): Coordinates {
-    return this.reducer.embed(this.data);
-  }
-}
-
-/**
- * Implements modified SPE dimensionality reduction.
- *
- * @class PSPEReducer
- * @extends {Reducer}
- */
-class PSPEReducer extends Reducer {
-  protected reducer: PSPEBase;
-
-  /**
-   * Creates an instance of PSPEReducer.
-   * @param {Options} options Options to pass to the constructor.
-   * @memberof PSPEReducer
-   */
-  constructor(options: 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.
-   */
-  public transform(): Coordinates {
-    return this.reducer.embed(this.data);
-  }
-}
-
-/**
- * Unified class implementing different dimensionality reduction methods.
- *
- * @export
- * @class DimensionalityReducer
- */
-export class DimensionalityReducer {
-  private reducer: Reducer | undefined;
-  public static methods: string[] = ['UMAP', 't-SNE', 'SPE', 'pSPE'];
-  private measurer: Measurer;
-
-  /**
-   * 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: any[], method: string, metric: string, options?: Options) {
-    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?.cycles},
-        ...options
-      });
-    } else if (method == 't-SNE') {
-      this.reducer = new TSNEReducer({
-        ...{data: data},
-        ...{distance: measure},
-        ...{iterations: options?.cycles ?? 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
-   */
-  public transform(transpose: boolean = false): Coordinates {
-    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;
-  }
-}

package/src/sequence-encoder.ts

@@ -1,132 +0,0 @@
-import {assert} from './operations';
-
-/**
- * Class to categorial encode/decode aligned amino acid residues sequence.
- *
- * @export
- * @class AlignedSequenceEncoder
- */
-export class AlignedSequenceEncoder {
-    protected aa2num: {[name: string]: number};
-    protected num2aa: {[code: number]: string};
-
-    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: string): string {
-        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: string): string {
-        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: string): string {
-        return AlignedSequenceEncoder._dropDefises(AlignedSequenceEncoder._truncateSequence(sequence));
-    }
-
-    /**
-     * Categorial encode of the sequence provided.
-     *
-     * @param {string} sequence The sequence.
-     * @return {number[]} Encoded vector.
-     * @memberof AlignedSequenceEncoder
-     */
-    public encode(sequence: string): number[] {
-        const seq = AlignedSequenceEncoder.clean(sequence);
-        const nItems = seq.length;
-        let values = new Array(nItems).fill(0);
-    
-        for (let i = 0; i < nItems; ++i) {
-            let char = seq[i];
-    
-            assert(char in this.aa2num, `Unknown char '${char}' found in sequence '${seq}'`);
-    
-            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
-     */
-    public decode(value: number[]): string {
-        let s: string = '';
-    
-        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;
-    }
-}