@datagrok-libraries/utils 0.1.0 → 0.2.7

package/src/vector-operations.js

@@ -0,0 +1,217 @@
+import { Vector } from './type-declarations';
+import { randomFloat, randomInt } from './random';
+/**
+ * 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);
+}
+/**
+ * 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.');
+    const 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;
+    const 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.) {
+    const matrix = initCoordinates(dimension1, dimension2);
+    for (let i = 0; i < dimension1; ++i) {
+        for (let j = 0; j < dimension2; ++j)
+            matrix[i][j] = randomFloat(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;
+    const 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] or [begin; end) if endExclusive. */
+export function genRange(begin, end, endExclusive = false) {
+    const nItems = end - begin + (endExclusive ? 0 : 1);
+    const series = new Int32Array(nItems);
+    for (let i = 0; i < nItems; ++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);
+}
+/**
+ * Returns the indexes of the most diverse objects according to the dist function
+ * @param {number} length total number of objects
+ * @param {number} n number of diverse elements to find
+ * @param {(i1: number, i2: number) => number} dist a function which calculates distance between two objects using their indexes
+ * @returns {number[]} The indexes of the most diverse objects
+ */
+export function getDiverseSubset(length, n, dist) {
+    function maxBy(values, orderBy) {
+        let maxValue = null;
+        let maxOrderBy = null;
+        for (const element of values) {
+            const elementOrderBy = orderBy(element);
+            if (maxOrderBy == null || elementOrderBy > maxOrderBy) {
+                maxValue = element;
+                maxOrderBy = elementOrderBy;
+            }
+        }
+        return maxValue;
+    }
+    const subset = [randomInt(length - 1)];
+    const complement = new Set();
+    for (let i = 0; i < length; ++i) {
+        if (!subset.includes(i))
+            complement.add(i);
+    }
+    while (subset.length < n) {
+        const idx = maxBy(complement.values(), (i) => Math.min.apply(Math, subset.map(function (val, index) {
+            return dist(i, val);
+        })));
+        if (idx) {
+            subset.push(idx);
+            complement.delete(idx);
+        }
+    }
+    return subset;
+}
+/**
+ * Returns normalized vector
+ * @param data numerical array
+ */
+export function normalize(data) {
+    let mean = 0;
+    let std = 0;
+    for (let i = 0; i < data.length; ++i)
+        mean += data[i];
+    mean /= data.length;
+    for (let i = 0; i < data.length; ++i)
+        std += (data[i] - mean) * (data[i] - mean);
+    std = Math.sqrt(std / data.length);
+    for (let i = 0; i < data.length; ++i)
+        data[i] = (data[i] - mean) / std;
+    return data;
+}
+/**
+ * Finds set difference between two lists.
+ * @param {any[]} a The first list.
+ * @param {any[]} b The second list.
+ */
+export function setDifference(a, b) {
+    const bSet = new Set(b);
+    return Array.from(new Set(a.filter((x) => !bSet.has(x))).values());
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"vector-operations.js","sourceRoot":"","sources":["vector-operations.ts"],"names":[],"mappings":"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","sourcesContent":["import {Matrix, Vector, Coordinates, Vectors, DistanceMetric} from './type-declarations';\nimport {randomFloat, randomInt} from './random';\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 * 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)\n    .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  const 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  const 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  const 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] = randomFloat(scale);\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  const 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] or [begin; end) if endExclusive. */\nexport function genRange(begin: number, end: number, endExclusive = false): Int32Array {\n  const nItems = end - begin + (endExclusive ? 0 : 1);\n  const series = new Int32Array(nItems);\n\n  for (let i = 0; i < nItems; ++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\n/**\n * Returns the indexes of the most diverse objects according to the dist function\n * @param {number} length total number of objects\n * @param {number} n number of diverse elements to find\n * @param {(i1: number, i2: number) => number} dist a function which calculates distance between two objects using their indexes\n * @returns {number[]} The indexes of the most diverse objects\n */\nexport function getDiverseSubset(length: number, n: number, dist: (i1: number, i2: number) => number): number[] {\n  function maxBy(values: IterableIterator<number>, orderBy: (i: number) => number) {\n    let maxValue = null;\n    let maxOrderBy = null;\n\n    for (const element of values) {\n      const elementOrderBy = orderBy(element);\n      if (maxOrderBy == null || elementOrderBy > maxOrderBy) {\n        maxValue = element;\n        maxOrderBy = elementOrderBy;\n      }\n    }\n    return maxValue;\n  }\n\n  const subset = [randomInt(length - 1)];\n  const complement = new Set();\n\n  for (let i = 0; i < length; ++i) {\n    if (!subset.includes(i))\n      complement.add(i);\n  }\n\n  while (subset.length < n) {\n    const idx = maxBy(\n      complement.values() as IterableIterator<number>,\n      (i) => Math.min.apply(Math, subset.map(function (val, index) {\n        return dist(i, val);\n      })));\n    if (idx) {\n      subset.push(idx);\n      complement.delete(idx);\n    }\n  }\n  return subset;\n}\n\n/**\n * Returns normalized vector\n * @param data numerical array\n */\nexport function normalize(data: Vector): Vector {\n  let mean = 0;\n  let std = 0;\n\n  for (let i = 0; i < data.length; ++i)\n    mean += data[i];\n\n  mean /= data.length;\n\n  for (let i = 0; i < data.length; ++i)\n    std += (data[i] - mean) * (data[i] - mean);\n\n  std = Math.sqrt(std / data.length);\n\n  for (let i = 0; i < data.length; ++i)\n    data[i] = (data[i] - mean) / std;\n\n  return data;\n}\n\n/**\n * Finds set difference between two lists.\n * @param {any[]} a The first list.\n * @param {any[]} b The second list.\n */\nexport function setDifference(a: any[], b: any[]): any[] {\n  const bSet = new Set(b);\n  return Array.from(new Set(a.filter((x) => !bSet.has(x))).values());\n}\n"]}

package/src/operations.d.ts.map

@@ -1 +0,0 @@
-{"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,iFAAiF;AACjF,wBAAgB,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,YAAY,UAAQ,GAAG,UAAU,CAQrF;AAED;;;;;;;GAOG;AACH,wBAAgB,OAAO,CAAC,MAAM,EAAE,GAAG,EAAE,EAAE,OAAO,UAAQ,GAAG,MAAM,EAAE,CAMhE;AAED;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,KAAK,MAAM,GAAG,MAAM,EAAE,CAoC9G;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAkB9C"}

package/src/operations.js

@@ -1,227 +0,0 @@
-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] or [begin; end) if endExclusive. */
-export function genRange(begin, end, endExclusive = false) {
-    const nItems = end - begin + (endExclusive ? 0 : 1);
-    const series = new Int32Array(nItems);
-    for (let i = 0; i < nItems; ++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);
-}
-/**
- * Returns the indexes of the most diverse objects according to the dist function
- *
- * @param {number} length total number of objects
- * @param {number} n number of diverse elements to find
- * @param {(i1: number, i2: number) => number} dist a function which calculates distance between two objects using their indexes
- * @returns {number[]} The indexes of the most diverse objects
- */
-export function getDiverseSubset(length, n, dist) {
-    function maxBy(values, orderBy) {
-        let maxValue = null;
-        let maxOrderBy = null;
-        for (const element of values) {
-            let elementOrderBy = orderBy(element);
-            if (maxOrderBy == null || elementOrderBy > maxOrderBy) {
-                maxValue = element;
-                maxOrderBy = elementOrderBy;
-            }
-        }
-        return maxValue;
-    }
-    let subset = [randomInt(length - 1)];
-    let complement = new Set();
-    for (let i = 0; i < length; ++i) {
-        if (!subset.includes(i))
-            complement.add(i);
-    }
-    while (subset.length < n) {
-        let idx = maxBy(complement.values(), (i) => Math.min.apply(Math, subset.map(function (val, index) {
-            return dist(i, val);
-        })));
-        if (idx) {
-            subset.push(idx);
-            complement.delete(idx);
-        }
-    }
-    return subset;
-}
-/**
- * Returns normalized vector
- *
- * @param data numerical array
- */
-export function normalize(data) {
-    let mean = 0;
-    let std = 0;
-    for (let i = 0; i < data.length; ++i) {
-        mean += data[i];
-    }
-    mean /= data.length;
-    for (let i = 0; i < data.length; ++i) {
-        std += (data[i] - mean) * (data[i] - mean);
-    }
-    std = Math.sqrt(std / data.length);
-    for (let i = 0; i < data.length; ++i) {
-        data[i] = (data[i] - mean) / std;
-    }
-    return data;
-}
-//# 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';\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] or [begin; end) if endExclusive. */\nexport function genRange(begin: number, end: number, endExclusive = false): Int32Array {\n  const nItems = end - begin + (endExclusive ? 0 : 1);\n  const series = new Int32Array(nItems);\n\n  for (let i = 0; i < nItems; ++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\n/**\n * Returns the indexes of the most diverse objects according to the dist function\n * \n * @param {number} length total number of objects\n * @param {number} n number of diverse elements to find \n * @param {(i1: number, i2: number) => number} dist a function which calculates distance between two objects using their indexes\n * @returns {number[]} The indexes of the most diverse objects\n */\nexport function getDiverseSubset(length: number, n: number, dist: (i1: number, i2: number) => number): number[] {\n\n  function maxBy(values: IterableIterator<number>, orderBy: (i: number) => number) {\n    let maxValue = null;\n    let maxOrderBy = null;\n\n    for (const element of values) {\n      let elementOrderBy = orderBy(element);\n      if (maxOrderBy == null || elementOrderBy > maxOrderBy) {\n        maxValue = element;\n        maxOrderBy = elementOrderBy;\n      }\n    }\n    return maxValue;  \n  }\n\n  let subset = [randomInt(length - 1)];\n  let complement = new Set();\n\n  for (let i = 0; i < length; ++i) {\n    if (!subset.includes(i))\n      complement.add(i);\n  }\n\n  while (subset.length < n) {\n    let idx = maxBy(\n      complement.values() as IterableIterator<number>,\n      (i) => Math.min.apply(Math, subset.map(function (val, index) {\n        return dist(i, val); \n      })));\n    if (idx) {\n      subset.push(idx);\n      complement.delete(idx);\n    }\n  }\n  return subset;\n}\n\n/**\n * Returns normalized vector\n * \n * @param data numerical array\n */\nexport function normalize(data: Vector): Vector {\n  let mean = 0;\n  let std = 0;\n\n  for (let i = 0; i < data.length; ++i) {\n    mean += data[i];\n  }\n  mean /= data.length;\n\n  for (let i = 0; i < data.length; ++i) {\n    std += (data[i] - mean) * (data[i] - mean);\n  }\n  std = Math.sqrt(std / data.length);\n\n  for (let i = 0; i < data.length; ++i) {\n    data[i] = (data[i] - mean) / std;\n  }\n  return data;\n}"]}

package/src/test-node.d.ts

@@ -1,11 +0,0 @@
-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-node.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"test-node.d.ts","sourceRoot":"","sources":["test-node.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"}

package/src/test-node.js

@@ -1,96 +0,0 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-import * as path from "path";
-import * as os from "os";
-import * as fs from "fs";
-// @ts-ignore
-import * as yaml from 'js-yaml';
-const fetch = require('node-fetch');
-export function getToken(url, key) {
-    return __awaiter(this, void 0, void 0, function* () {
-        let response = yield fetch(`${url}/users/login/dev/${key}`, { method: 'POST' });
-        let json = yield response.json();
-        if (json.isSuccess == true)
-            return json.token;
-        else
-            throw 'Unable to login to server. Check your dev key';
-    });
-}
-export function getWebUrl(url, token) {
-    return __awaiter(this, void 0, void 0, function* () {
-        let response = yield fetch(`${url}/admin/plugins/admin/settings`, { headers: { Authorization: token } });
-        let json = yield response.json();
-        return json.settings.webRoot;
-    });
-}
-const grokDir = path.join(os.homedir(), '.grok');
-const confPath = path.join(grokDir, 'config.yaml');
-function mapURL(conf) {
-    let urls = {};
-    for (let server in conf.servers) {
-        urls[conf['servers'][server]['url']] = conf['servers'][server];
-    }
-    return urls;
-}
-export function getDevKey(hostKey) {
-    let config = yaml.load(fs.readFileSync(confPath, 'utf8'));
-    let host = hostKey == '' ? config.default : hostKey;
-    host = host.trim();
-    let urls = mapURL(config);
-    let key = '';
-    let url = '';
-    try {
-        let url = new URL(host).href;
-        if (url.endsWith('/'))
-            url = url.slice(0, -1);
-        if (url in urls)
-            key = config['servers'][urls[url]]['key'];
-    }
-    catch (error) {
-        if (config['servers'][host] == null)
-            throw `Unknown server alias. Please add it to ${confPath}`;
-        url = config['servers'][host]['url'];
-        key = config['servers'][host]['key'];
-    }
-    return { url, key };
-}
-export function getBrowserPage(puppeteer) {
-    var _a;
-    return __awaiter(this, void 0, void 0, function* () {
-        let url = (_a = process.env.HOST) !== null && _a !== void 0 ? _a : '';
-        let cfg = getDevKey(url);
-        url = cfg.url;
-        let key = cfg.key;
-        let token = yield getToken(url, key);
-        url = yield getWebUrl(url, token);
-        console.log(`Using web root: ${url}`);
-        let browser = yield puppeteer.launch({
-            args: ['--disable-dev-shm-usage', '--disable-features=site-per-process'],
-            ignoreHTTPSErrors: true,
-        });
-        let page = yield browser.newPage();
-        yield page.goto(`${url}/oauth/`);
-        yield page.setCookie({ name: 'auth', value: token });
-        yield page.evaluate((token) => {
-            window.localStorage.setItem('auth', token);
-        }, token);
-        yield page.goto(url);
-        try {
-            yield page.waitForSelector('.grok-preloader');
-            console.log('got preloader');
-            yield page.waitForFunction(() => document.querySelector('.grok-preloader') == null, { timeout: 100000 });
-        }
-        catch (error) {
-            throw error;
-        }
-        return { browser, page };
-    });
-}
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"test-node.js","sourceRoot":"","sources":["test-node.ts"],"names":[],"mappings":"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","sourcesContent":["import * as path from \"path\";\nimport * as os from \"os\";\nimport * as fs from \"fs\";\n// @ts-ignore\nimport * as yaml from 'js-yaml';\nconst fetch = require('node-fetch');\n\nexport async function getToken(url: string, key: string) {\n  let response = await fetch(`${url}/users/login/dev/${key}`, {method: 'POST'});\n  let json = await response.json();\n  if (json.isSuccess == true)\n    return json.token;\n  else\n    throw 'Unable to login to server. Check your dev key';\n}\n\nexport async function getWebUrl(url: string, token: string) {\n  let response = await fetch(`${url}/admin/plugins/admin/settings`, {headers: {Authorization: token}});\n  let json = await response.json();\n  return json.settings.webRoot;\n}\n\nconst grokDir = path.join(os.homedir(), '.grok');\nconst confPath = path.join(grokDir, 'config.yaml');\n\nfunction mapURL(conf: Config): Indexable {\n  let urls: Indexable = {};\n  for (let server in conf.servers) {\n    urls[conf['servers'][server]['url']] = conf['servers'][server];\n  }\n  return urls;\n}\n\nexport function getDevKey(hostKey: string): {url: string, key: string} {\n  let config = yaml.load(fs.readFileSync(confPath, 'utf8')) as any;\n  let host = hostKey == '' ? config.default : hostKey;\n  host = host.trim();\n  let urls = mapURL(config);\n  let key = '';\n  let url = '';\n  try {\n    let url = new URL(host).href;\n    if (url.endsWith('/')) url = url.slice(0, -1);\n    if (url in urls) key = config['servers'][urls[url]]['key'];\n  } catch (error) {\n    if (config['servers'][host] == null)\n      throw `Unknown server alias. Please add it to ${confPath}`;\n    url = config['servers'][host]['url'];\n    key = config['servers'][host]['key'];\n  }\n  return {url, key};\n}\n\nexport async function getBrowserPage(puppeteer: any): Promise<{browser: any, page: any}> {\n  let url:string = process.env.HOST ?? '';\n  let cfg = getDevKey(url);\n  url = cfg.url;\n\n  let key = cfg.key;\n  let token = await getToken(url, key);\n  url = await getWebUrl(url, token);\n  console.log(`Using web root: ${url}`);\n\n  let browser = await puppeteer.launch({\n    args: ['--disable-dev-shm-usage', '--disable-features=site-per-process'],\n    ignoreHTTPSErrors: true,\n  });\n\n  let page = await browser.newPage();\n  await page.goto(`${url}/oauth/`);\n  await page.setCookie({name: 'auth', value: token});\n  await page.evaluate((token: any) => {\n    window.localStorage.setItem('auth', token);\n  }, token);\n  await page.goto(url);\n  try {\n    await page.waitForSelector('.grok-preloader');\n    console.log('got preloader');\n    await page.waitForFunction(() => document.querySelector('.grok-preloader') == null, {timeout: 100000});\n  } catch (error) {\n    throw error;\n  }\n  return {browser, page};\n}\n\n\ninterface Config {\n  servers: {\n    [alias: string]: {\n      url: string,\n      key: string\n    }\n  },\n  default: string,\n}\n\ninterface Indexable { [key: string]: any }\n"]}