@datagrok-libraries/utils 0.0.9 → 0.0.15

package/src/operations.d.ts

@@ -1,66 +1,77 @@
-import { Matrix, Vector, 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 declare function assert(condition?: boolean, message?: string): void;
-/**
- * Generates single random integer from 0 to range.
- *
- * @export
- * @param {number} range Max generating value.
- * @return {number} A random integer generated.
- */
-export declare function randomInt(range: number): number;
-/**
- * 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 declare function transposeMatrix(matrix: Matrix): Matrix;
-/**
- * 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 declare function vectorAdd(p: Vector, q: Vector, multiplier?: number): Vector;
-/**
- * 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 declare function fillRandomMatrix(dimension1: number, dimension2: number, scale?: number): 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 declare function calculateEuclideanDistance(p: Vector, q: Vector): number;
-/**
- * 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 declare function calcDistanceMatrix(data: Vectors, distance: DistanceMetric): Matrix;
+import { Matrix, Vector, 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 declare function assert(condition?: boolean, message?: string): void;
+/**
+ * Generates single random integer from 0 to range.
+ *
+ * @export
+ * @param {number} range Max generating value.
+ * @return {number} A random integer generated.
+ */
+export declare function randomInt(range: number): number;
+/**
+ * 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 declare function transposeMatrix(matrix: Matrix): Matrix;
+/**
+ * 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 declare function vectorAdd(p: Vector, q: Vector, multiplier?: number): Vector;
+/**
+ * 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 declare function fillRandomMatrix(dimension1: number, dimension2: number, scale?: number): 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 declare function calculateEuclideanDistance(p: Vector, q: Vector): number;
+/**
+ * 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 declare function calcDistanceMatrix(data: Vectors, distance: DistanceMetric): Matrix;
+/** Generates array from a range [begin; end]. */
+export declare function genRange(begin: number, end: number): Int32Array;
+/**
+ * Returns order of values as if they are sorted.
+ *
+ * @export
+ * @param {any[]} values Input array.
+ * @param {boolean} [reverse=false] Whether to return reversed order.
+ * @return {number[]} The order computed.
+ */
+export declare function argSort(values: any[], reverse?: boolean): number[];
 //# sourceMappingURL=operations.d.ts.map

package/src/operations.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"operations.d.ts","sourceRoot":"","sources":["operations.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,MAAM,EAAE,MAAM,EAAe,OAAO,EAAE,cAAc,EAAC,MAAM,qBAAqB,CAAC;AAEzF;;;;;;;GAOG;AACH,wBAAgB,MAAM,CAAC,SAAS,GAAE,OAAe,EAAE,OAAO,GAAE,MAA2B,QAItF;AAED;;;;;;GAMG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAE/C;AAeD;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAEtD;AAED;;;;;;;;GAQG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,UAAU,GAAE,MAAU,GAAG,MAAM,CAW9E;AAiCD;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAAC,UAAU,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,KAAK,GAAE,MAAW,GAAG,MAAM,CASnG;AAED;;;;;;;GAOG;AACH,wBAAgB,0BAA0B,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAKvE;AAED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,OAAO,EAAE,QAAQ,EAAE,cAAc,GAAG,MAAM,CAWlF"}
+{"version":3,"file":"operations.d.ts","sourceRoot":"","sources":["operations.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,MAAM,EAAE,MAAM,EAAe,OAAO,EAAE,cAAc,EAAC,MAAM,qBAAqB,CAAC;AAEzF;;;;;;;GAOG;AACH,wBAAgB,MAAM,CAAC,SAAS,GAAE,OAAe,EAAE,OAAO,GAAE,MAA2B,QAItF;AAED;;;;;;GAMG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAE/C;AAeD;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAEtD;AAED;;;;;;;;GAQG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,UAAU,GAAE,MAAU,GAAG,MAAM,CAW9E;AAiCD;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAAC,UAAU,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,KAAK,GAAE,MAAW,GAAG,MAAM,CASnG;AAED;;;;;;;GAOG;AACH,wBAAgB,0BAA0B,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAKvE;AAED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,OAAO,EAAE,QAAQ,EAAE,cAAc,GAAG,MAAM,CAWlF;AAED,iDAAiD;AACjD,wBAAgB,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,UAAU,CAQ/D;AAED;;;;;;;GAOG;AACH,wBAAgB,OAAO,CAAC,MAAM,EAAE,GAAG,EAAE,EAAE,OAAO,UAAQ,GAAG,MAAM,EAAE,CAMhE"}

package/src/operations.js

@@ -1,144 +1,168 @@
-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"]}
+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;
+}
+/** Generates array from a range [begin; end]. */
+export function genRange(begin, end) {
+    const nItems = end - begin;
+    const series = new Int32Array(nItems);
+    for (let i = 0; i < nItems + 1; ++i) {
+        series[i] = begin + i;
+    }
+    return series;
+}
+/**
+ * Returns order of values as if they are sorted.
+ *
+ * @export
+ * @param {any[]} values Input array.
+ * @param {boolean} [reverse=false] Whether to return reversed order.
+ * @return {number[]} The order computed.
+ */
+export function argSort(values, reverse = false) {
+    const sortfn = reverse ? (a, b) => (b[0] - a[0]) : (a, b) => (a[0] - b[0]);
+    const decor = (v, i) => [v, i]; // set index to value
+    const undecor = (a) => a[1]; // leave only index
+    const _argsort = (arr) => arr.map(decor).sort(sortfn).map(undecor);
+    return _argsort(values);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"operations.js","sourceRoot":"","sources":["operations.ts"],"names":[],"mappings":"AAAA,OAAO,EAAS,MAAM,EAAuC,MAAM,qBAAqB,CAAC;AAEzF;;;;;;;GAOG;AACH,MAAM,UAAU,MAAM,CAAC,YAAqB,KAAK,EAAE,UAAkB,kBAAkB;IACrF,IAAI,CAAC,SAAS,EAAE;QACd,MAAM,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC;KAC1B;AACH,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,SAAS,CAAC,KAAa;IACrC,OAAO,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,KAAK,CAAC,CAAC;AAC3C,CAAC;AAED;;;;;;;;GAQG;AACH,SAAS,eAAe,CAAC,UAAkB,EAAE,UAAkB,EAAE,OAAe,CAAC;IAC/E,OAAO,IAAI,KAAK,CAAC,UAAU,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,CAAC,IAAI,MAAM,CAAC,UAAU,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;AACzF,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,eAAe,CAAC,MAAc;IAC5C,OAAO,IAAI,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,IAAI,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AAC9H,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,SAAS,CAAC,CAAS,EAAE,CAAS,EAAE,aAAqB,CAAC;IACpE,MAAM,MAAM,GAAG,CAAC,CAAC,MAAM,CAAC;IAExB,MAAM,CAAC,MAAM,IAAI,CAAC,CAAC,MAAM,EAAE,8BAA8B,CAAC,CAAA;IAE1D,IAAI,KAAK,GAAG,IAAI,MAAM,CAAC,MAAM,CAAC,CAAC;IAE/B,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,EAAE;QACjC,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAC,UAAU,GAAC,CAAC,CAAC,CAAC,CAAC,CAAC;KACjC;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;;;;GAKG;AACH,SAAS,QAAQ,CAAC,CAAS;IACzB,IAAI,KAAK,GAAG,CAAC,CAAC;IAEd,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,EAAE;QACjC,KAAK,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;KACf;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;;;;GAKG;AACH,SAAS,YAAY,CAAC,CAAS;IAC7B,MAAM,MAAM,GAAG,CAAC,CAAC,MAAM,CAAC;IACxB,IAAI,KAAK,GAAG,IAAI,MAAM,CAAC,MAAM,CAAC,CAAC;IAE/B,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,EAAE;QACjC,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAC,CAAC,CAAC,CAAC,CAAC,CAAC;KACtB;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,gBAAgB,CAAC,UAAkB,EAAE,UAAkB,EAAE,QAAgB,EAAE;IACzF,IAAI,MAAM,GAAG,eAAe,CAAC,UAAU,EAAE,UAAU,CAAC,CAAC;IAErD,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,UAAU,EAAE,EAAE,CAAC,EAAE;QACnC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,UAAU,EAAE,EAAE,CAAC,EAAE;YACnC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,MAAM,EAAE,GAAG,KAAK,CAAC;SACtC;KACF;IACD,OAAO,MAAM,CAAC;AAChB,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,0BAA0B,CAAC,CAAS,EAAE,CAAS;IAC7D,MAAM,IAAI,GAAG,SAAS,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;IACjC,MAAM,MAAM,GAAG,YAAY,CAAC,IAAI,CAAC,CAAC;IAClC,MAAM,UAAU,GAAG,QAAQ,CAAC,MAAM,CAAC,CAAC;IACpC,OAAO,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;AAC/B,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,kBAAkB,CAAC,IAAa,EAAE,QAAwB;IACxE,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC;IAC3B,IAAI,MAAM,GAAG,eAAe,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC,CAAC;IAEhD,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,EAAE,EAAE,CAAC,EAAE;QAC/B,KAAK,IAAI,CAAC,GAAG,CAAC,GAAC,CAAC,EAAE,CAAC,GAAG,MAAM,EAAE,EAAE,CAAC,EAAE;YACjC,MAAM,CAAC,GAAW,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;YAC1F,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;SACjC;KACF;IACD,OAAO,MAAM,CAAC;AAChB,CAAC;AAED,iDAAiD;AACjD,MAAM,UAAU,QAAQ,CAAC,KAAa,EAAE,GAAW;IACjD,MAAM,MAAM,GAAG,GAAG,GAAG,KAAK,CAAC;IAC3B,MAAM,MAAM,GAAG,IAAI,UAAU,CAAC,MAAM,CAAC,CAAC;IAEtC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,GAAG,CAAC,EAAE,EAAE,CAAC,EAAE;QACnC,MAAM,CAAC,CAAC,CAAC,GAAG,KAAK,GAAG,CAAC,CAAC;KACvB;IACD,OAAO,MAAM,CAAC;AAChB,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,OAAO,CAAC,MAAa,EAAE,OAAO,GAAG,KAAK;IACpD,MAAM,MAAM,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC,CAAQ,EAAE,CAAQ,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAQ,EAAE,CAAQ,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IACvG,MAAM,KAAK,GAAG,CAAC,CAAM,EAAE,CAAS,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,qBAAqB;IAClE,MAAM,OAAO,GAAG,CAAC,CAAQ,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,mBAAmB;IACvD,MAAM,QAAQ,GAAG,CAAC,GAAU,EAAE,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;IAC1E,OAAO,QAAQ,CAAC,MAAM,CAAC,CAAC;AAC1B,CAAC","sourcesContent":["import {Matrix, Vector, Coordinates, Vectors, DistanceMetric} from './type-declarations';\n\n/**\n * Asserts a condition by throwing an Error.\n *\n * @export\n * @param {boolean} [condition=false] Condition to assert.\n * @param {string} [message='Assertion error.'] Message to output.\n * @throws {Error}\n */\nexport function assert(condition: boolean = false, message: string = 'Assertion error.') {\n  if (!condition) {\n    throw new Error(message);\n  }\n}\n\n/**\n * Generates single random integer from 0 to range.\n *\n * @export\n * @param {number} range Max generating value.\n * @return {number} A random integer generated.\n */\nexport function randomInt(range: number): number {\n  return Math.floor(Math.random() * range);\n}\n\n/**\n * Creates new two-dimensional array and fills it with the value given.\n *\n * @param {number} dimension1 The first dimension of the coordinates (number of rows).\n * @param {number} dimension2 The second dimension of the coordinates (number of columns).\n * @param {number} [fill=0] A value to fill the coordinates with.\n * @return {Coordinates} A two-dimensional filled with the value given.\n * @todo Might be slow since used Array.map. Probably needs performance revision.\n */\nfunction initCoordinates(dimension1: number, dimension2: number, fill: number = 0): Coordinates {\n  return new Array(dimension1).fill(fill).map(() => (new Vector(dimension2).fill(fill)));\n}\n\n/**\n * Transpose matrix.\n *\n * @export\n * @param {Matrix} matrix The matrix to be transposed.\n * @return {Matrix} Transposed matrix.\n * @todo Might be slow since used Array.map. Probably needs performance revision.\n */\nexport function transposeMatrix(matrix: Matrix): Matrix {\n  return new Array(matrix[0].length).fill(0).map((_, i) => (new Vector(matrix.length).fill(0).map((_, j) => (matrix[j][i]))));\n}\n\n/**\n * Adds two vectors with the second one to be multiplied by the given ratio.\n *\n * @export\n * @param {Vector} p The first vector to add.\n * @param {Vector} q The second vector to add.\n * @param {number} [multiplier=1] A multiplier to be used before the second vector is added.\n * @return {Vector} New vector contained the result of operation p+multiplier*q.\n */\nexport function vectorAdd(p: Vector, q: Vector, multiplier: number = 1): Vector {\n  const nItems = p.length;\n\n  assert(nItems == q.length, 'Vector lengths do not match.')\n\n  let total = new Vector(nItems);\n\n  for (let i = 0; i < p.length; ++i) {\n    total[i] = p[i]+multiplier*q[i];\n  }\n  return total;\n}\n\n/**\n * Sums the vector's items.\n *\n * @param {Vector} v The vector to be summed.\n * @return {number} The vector's items sum.\n */\nfunction itemsSum(v: Vector): number {\n  let total = 0;\n\n  for (let i = 0; i < v.length; ++i) {\n    total += v[i];\n  }\n  return total;\n}\n\n/**\n * Suqares the vector's items.\n *\n * @param {Vector} v The vector to square.\n * @return {Vector} A new vector containing the original's items squared.\n */\nfunction vectorSquare(v: Vector): Vector {\n  const nItems = v.length;\n  let total = new Vector(nItems);\n\n  for (let i = 0; i < v.length; ++i) {\n    total[i] = v[i]*v[i];\n  }\n  return total;\n}\n\n/**\n * Creates a matrix filled with random floating point values.\n *\n * @export\n * @param {number} dimension1 The first dimension of the matrix.\n * @param {number} dimension2 The second dimension of the matrix.\n * @param {number} [scale=1.] Max value given by random generator.\n * @return {Matrix} A new matrix filled with random floating point  values.\n */\nexport function fillRandomMatrix(dimension1: number, dimension2: number, scale: number = 1.): Matrix {\n  let matrix = initCoordinates(dimension1, dimension2);\n\n  for (let i = 0; i < dimension1; ++i) {\n    for (let j = 0; j < dimension2; ++j) {\n      matrix[i][j] = Math.random() * scale;\n    }\n  }\n  return matrix;\n}\n\n/**\n * Calculates Euclidean distance between two vectors.\n *\n * @export\n * @param {Vector} p The first vector.\n * @param {Vector} q The second vector.\n * @return {number} Euclidean distance between the given vectors.\n */\nexport function calculateEuclideanDistance(p: Vector, q: Vector): number {\n  const diff = vectorAdd(p, q, -1);\n  const sqdiff = vectorSquare(diff);\n  const sqdiffSumm = itemsSum(sqdiff);\n  return Math.sqrt(sqdiffSumm);\n}\n\n/**\n * Creates a distance matrix using a custom distance function.\n *\n * @export\n * @param {Vectors} data Input vectors to calculate distances.\n * @param {DistanceMetric} distance Custom distance function.\n * @return {Matrix} Calculated custom distance matrix.\n */\nexport function calcDistanceMatrix(data: Vectors, distance: DistanceMetric): Matrix {\n  const nItems = data.length;\n  let matrix = initCoordinates(nItems, nItems, 0);\n\n  for (let i = 0; i < nItems; ++i) {\n    for (let j = i+1; j < nItems; ++j) {\n      const d: number = (data[i] == null) || (data[j] == null) ? 0 : distance(data[i], data[j]);\n      matrix[i][j] = matrix[j][i] = d;\n    }\n  }\n  return matrix;\n}\n\n/** Generates array from a range [begin; end]. */\nexport function genRange(begin: number, end: number): Int32Array {\n  const nItems = end - begin;\n  const series = new Int32Array(nItems);\n\n  for (let i = 0; i < nItems + 1; ++i) {\n    series[i] = begin + i;\n  }\n  return series;\n}\n\n/**  \n * Returns order of values as if they are sorted.\n *\n * @export\n * @param {any[]} values Input array.\n * @param {boolean} [reverse=false] Whether to return reversed order.\n * @return {number[]} The order computed.\n */\nexport function argSort(values: any[], reverse = false): number[] {\n  const sortfn = reverse ? (a: any[], b: any[]) => (b[0] - a[0]) : (a: any[], b: any[]) => (a[0] - b[0]);\n  const decor = (v: any, i: number) => [v, i]; // set index to value\n  const undecor = (a: any[]) => a[1]; // leave only index\n  const _argsort = (arr: any[]) => arr.map(decor).sort(sortfn).map(undecor);\n  return _argsort(values);\n}\n"]}

package/src/string-utils.d.ts

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

package/src/string-utils.js

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

package/src/table-validation.d.ts

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