wasm-bhtsne 0.1.4 → 0.2.1

package/README.md

@@ -21,16 +21,16 @@ npm i wasm-bhtsne
 ```javascript
 import {tSNE} from "wasm-bhtsne";
 
-const data = [];
-
-for (let i = 0; i < 300; i++) {
-    const randomNumber = Math.random();
-    data.push(randomNumber);
+function createRandomMatrix(rows, columns) {
+    return Array.from({ length: rows }, () =>
+        Array.from({ length: columns }, () => Math.random())
+    );
 }
 
-const tsne_encoder = new tSNE(data, 4);
-tsne_encoder.exact();
-const embedded_stuff = tsne_encoder.embedding();
+const data = createRandomMatrix(500, 4);
+
+const tsne_encoder = new tSNE(data);
+const compressed_vectors = tsne_encoder.barnes_hut(0.5);
 
-console.log(embedded_stuff);
+console.log(compressed_vectors);
 ```

package/package.json

@@ -4,7 +4,7 @@
     "lv291 <baiunco291@proton.me>"
   ],
   "description": "Exact and Barnes-Hut implementations of t-SNE in wasm",
-  "version": "0.1.4",
+  "version": "0.2.1",
   "license": "MIT",
   "repository": {
     "type": "git",

package/wasm_bhtsne.d.ts

@@ -7,15 +7,9 @@
 export class tSNE {
   free(): void;
 /**
-* @param {Float32Array} data
-* @param {number} d
+* @param {Array<any>} vectors
 */
-  constructor(data: Float32Array, d: number);
-/**
-* Returns the computed embedding.
-* @returns {Float32Array}
-*/
-  embedding(): Float32Array;
+  constructor(vectors: Array<any>);
 /**
 * Performs a parallel exact version of the t-SNE algorithm. Pairwise distances between samples
 * in the input space will be computed accordingly to the supplied function `distance_f`.
@@ -27,8 +21,9 @@ export class tSNE {
 * **Do note** that such a distance function needs not to be a metric distance, i.e. it is not
 * necessary for it so satisfy the triangle inequality. Consequently, the squared euclidean
 * distance, and many other, can be used.
+* @returns {Array<any>}
 */
-  exact(): void;
+  exact(): Array<any>;
 /**
 * Performs a parallel Barnes-Hut approximation of the t-SNE algorithm.
 *
@@ -46,8 +41,14 @@ export class tSNE {
 * **Do note that** `metric_f` **must be a metric distance**, i.e. it must
 * satisfy the [triangle inequality](https://en.wikipedia.org/wiki/Triangle_inequality).
 * @param {number} theta
+* @returns {Array<any>}
+*/
+  barnes_hut(theta: number): Array<any>;
+/**
+* Returns the computed embedding.
+* @returns {Array<any>}
 */
-  barnes_hut(theta: number): void;
+  embedding(): Array<any>;
 /**
 * Sets a new value for the embedding dimension.
 *

package/wasm_bhtsne_bg.js

@@ -24,6 +24,28 @@ function takeObject(idx) {
     return ret;
 }
 
+function isLikeNone(x) {
+    return x === undefined || x === null;
+}
+
+let cachedFloat64Memory0 = null;
+
+function getFloat64Memory0() {
+    if (cachedFloat64Memory0 === null || cachedFloat64Memory0.byteLength === 0) {
+        cachedFloat64Memory0 = new Float64Array(wasm.memory.buffer);
+    }
+    return cachedFloat64Memory0;
+}
+
+let cachedInt32Memory0 = null;
+
+function getInt32Memory0() {
+    if (cachedInt32Memory0 === null || cachedInt32Memory0.byteLength === 0) {
+        cachedInt32Memory0 = new Int32Array(wasm.memory.buffer);
+    }
+    return cachedInt32Memory0;
+}
+
 const lTextDecoder = typeof TextDecoder === 'undefined' ? (0, module.require)('util').TextDecoder : TextDecoder;
 
 let cachedTextDecoder = new lTextDecoder('utf-8', { ignoreBOM: true, fatal: true });
@@ -53,37 +75,72 @@ function addHeapObject(obj) {
     return idx;
 }
 
-let cachedFloat32Memory0 = null;
-
-function getFloat32Memory0() {
-    if (cachedFloat32Memory0 === null || cachedFloat32Memory0.byteLength === 0) {
-        cachedFloat32Memory0 = new Float32Array(wasm.memory.buffer);
+function debugString(val) {
+    // primitive types
+    const type = typeof val;
+    if (type == 'number' || type == 'boolean' || val == null) {
+        return  `${val}`;
     }
-    return cachedFloat32Memory0;
-}
-
-let WASM_VECTOR_LEN = 0;
-
-function passArrayF32ToWasm0(arg, malloc) {
-    const ptr = malloc(arg.length * 4, 4) >>> 0;
-    getFloat32Memory0().set(arg, ptr / 4);
-    WASM_VECTOR_LEN = arg.length;
-    return ptr;
-}
-
-let cachedInt32Memory0 = null;
-
-function getInt32Memory0() {
-    if (cachedInt32Memory0 === null || cachedInt32Memory0.byteLength === 0) {
-        cachedInt32Memory0 = new Int32Array(wasm.memory.buffer);
+    if (type == 'string') {
+        return `"${val}"`;
     }
-    return cachedInt32Memory0;
+    if (type == 'symbol') {
+        const description = val.description;
+        if (description == null) {
+            return 'Symbol';
+        } else {
+            return `Symbol(${description})`;
+        }
+    }
+    if (type == 'function') {
+        const name = val.name;
+        if (typeof name == 'string' && name.length > 0) {
+            return `Function(${name})`;
+        } else {
+            return 'Function';
+        }
+    }
+    // objects
+    if (Array.isArray(val)) {
+        const length = val.length;
+        let debug = '[';
+        if (length > 0) {
+            debug += debugString(val[0]);
+        }
+        for(let i = 1; i < length; i++) {
+            debug += ', ' + debugString(val[i]);
+        }
+        debug += ']';
+        return debug;
+    }
+    // Test for built-in
+    const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
+    let className;
+    if (builtInMatches.length > 1) {
+        className = builtInMatches[1];
+    } else {
+        // Failed to match the standard '[object ClassName]'
+        return toString.call(val);
+    }
+    if (className == 'Object') {
+        // we're a user defined class or Object
+        // JSON.stringify avoids problems with cycles, and is generally much
+        // easier than looping through ownProperties of `val`.
+        try {
+            return 'Object(' + JSON.stringify(val) + ')';
+        } catch (_) {
+            return 'Object';
+        }
+    }
+    // errors
+    if (val instanceof Error) {
+        return `${val.name}: ${val.message}\n${val.stack}`;
+    }
+    // TODO we could test for more things here, like `Set`s and `Map`s.
+    return className;
 }
 
-function getArrayF32FromWasm0(ptr, len) {
-    ptr = ptr >>> 0;
-    return getFloat32Memory0().subarray(ptr / 4, ptr / 4 + len);
-}
+let WASM_VECTOR_LEN = 0;
 
 const lTextEncoder = typeof TextEncoder === 'undefined' ? (0, module.require)('util').TextEncoder : TextEncoder;
 
@@ -173,16 +230,53 @@ export class tSNE {
         wasm.__wbg_tsne_free(ptr);
     }
     /**
-    * @param {Float32Array} data
-    * @param {number} d
+    * @param {Array<any>} vectors
     */
-    constructor(data, d) {
-        const ptr0 = passArrayF32ToWasm0(data, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.tsne_new(ptr0, len0, d);
+    constructor(vectors) {
+        const ret = wasm.tsne_new(addHeapObject(vectors));
         return tSNE.__wrap(ret);
     }
     /**
+    * Performs a parallel exact version of the t-SNE algorithm. Pairwise distances between samples
+    * in the input space will be computed accordingly to the supplied function `distance_f`.
+    *
+    * # Arguments
+    *
+    * `distance_f` - distance function.
+    *
+    * **Do note** that such a distance function needs not to be a metric distance, i.e. it is not
+    * necessary for it so satisfy the triangle inequality. Consequently, the squared euclidean
+    * distance, and many other, can be used.
+    * @returns {Array<any>}
+    */
+    exact() {
+        const ret = wasm.tsne_exact(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+    * Performs a parallel Barnes-Hut approximation of the t-SNE algorithm.
+    *
+    * # Arguments
+    *
+    * * `theta` - determines the accuracy of the approximation. Must be **strictly greater than
+    * 0.0**. Large values for θ increase the speed of the algorithm but decrease its accuracy.
+    * For small values of θ it is less probable that a cell in the space partitioning tree will
+    * be treated as a single point. For θ equal to 0.0 the method degenerates in the exact
+    * version.
+    *
+    * * `metric_f` - metric function.
+    *
+    *
+    * **Do note that** `metric_f` **must be a metric distance**, i.e. it must
+    * satisfy the [triangle inequality](https://en.wikipedia.org/wiki/Triangle_inequality).
+    * @param {number} theta
+    * @returns {Array<any>}
+    */
+    barnes_hut(theta) {
+        const ret = wasm.tsne_barnes_hut(this.__wbg_ptr, theta);
+        return takeObject(ret);
+    }
+    /**
     * Sets a new learning rate.
     *
     * # Arguments
@@ -279,59 +373,25 @@ export class tSNE {
     }
     /**
     * Returns the computed embedding.
-    * @returns {Float32Array}
+    * @returns {Array<any>}
     */
     embedding() {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.tsne_embedding(retptr, this.__wbg_ptr);
-            var r0 = getInt32Memory0()[retptr / 4 + 0];
-            var r1 = getInt32Memory0()[retptr / 4 + 1];
-            var v1 = getArrayF32FromWasm0(r0, r1).slice();
-            wasm.__wbindgen_free(r0, r1 * 4);
-            return v1;
-        } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
-        }
-    }
-    /**
-    * Performs a parallel exact version of the t-SNE algorithm. Pairwise distances between samples
-    * in the input space will be computed accordingly to the supplied function `distance_f`.
-    *
-    * # Arguments
-    *
-    * `distance_f` - distance function.
-    *
-    * **Do note** that such a distance function needs not to be a metric distance, i.e. it is not
-    * necessary for it so satisfy the triangle inequality. Consequently, the squared euclidean
-    * distance, and many other, can be used.
-    */
-    exact() {
-        wasm.tsne_exact(this.__wbg_ptr);
-    }
-    /**
-    * Performs a parallel Barnes-Hut approximation of the t-SNE algorithm.
-    *
-    * # Arguments
-    *
-    * * `theta` - determines the accuracy of the approximation. Must be **strictly greater than
-    * 0.0**. Large values for θ increase the speed of the algorithm but decrease its accuracy.
-    * For small values of θ it is less probable that a cell in the space partitioning tree will
-    * be treated as a single point. For θ equal to 0.0 the method degenerates in the exact
-    * version.
-    *
-    * * `metric_f` - metric function.
-    *
-    *
-    * **Do note that** `metric_f` **must be a metric distance**, i.e. it must
-    * satisfy the [triangle inequality](https://en.wikipedia.org/wiki/Triangle_inequality).
-    * @param {number} theta
-    */
-    barnes_hut(theta) {
-        wasm.tsne_barnes_hut(this.__wbg_ptr, theta);
+        const ret = wasm.tsne_embedding(this.__wbg_ptr);
+        return takeObject(ret);
     }
 }
 
+export function __wbindgen_object_drop_ref(arg0) {
+    takeObject(arg0);
+};
+
+export function __wbindgen_number_get(arg0, arg1) {
+    const obj = getObject(arg1);
+    const ret = typeof(obj) === 'number' ? obj : undefined;
+    getFloat64Memory0()[arg0 / 8 + 1] = isLikeNone(ret) ? 0 : ret;
+    getInt32Memory0()[arg0 / 4 + 0] = !isLikeNone(ret);
+};
+
 export function __wbg_new_abda76e883ba8a5f() {
     const ret = new Error();
     return addHeapObject(ret);
@@ -357,10 +417,6 @@ export function __wbg_error_f851667af71bcfc6(arg0, arg1) {
     }
 };
 
-export function __wbindgen_object_drop_ref(arg0) {
-    takeObject(arg0);
-};
-
 export function __wbg_randomFillSync_dc1e9a60c158336d() { return handleError(function (arg0, arg1) {
     getObject(arg0).randomFillSync(takeObject(arg1));
 }, arguments) };
@@ -415,6 +471,21 @@ export function __wbg_msCrypto_bcb970640f50a1e8(arg0) {
     return addHeapObject(ret);
 };
 
+export function __wbg_get_44be0491f933a435(arg0, arg1) {
+    const ret = getObject(arg0)[arg1 >>> 0];
+    return addHeapObject(ret);
+};
+
+export function __wbg_length_fff51ee6522a1a18(arg0) {
+    const ret = getObject(arg0).length;
+    return ret;
+};
+
+export function __wbg_new_898a68150f225f2e() {
+    const ret = new Array();
+    return addHeapObject(ret);
+};
+
 export function __wbindgen_is_function(arg0) {
     const ret = typeof(getObject(arg0)) === 'function';
     return ret;
@@ -455,6 +526,16 @@ export function __wbindgen_is_undefined(arg0) {
     return ret;
 };
 
+export function __wbg_isArray_4c24b343cb13cfb1(arg0) {
+    const ret = Array.isArray(getObject(arg0));
+    return ret;
+};
+
+export function __wbg_push_ca1c26067ef907ac(arg0, arg1) {
+    const ret = getObject(arg0).push(getObject(arg1));
+    return ret;
+};
+
 export function __wbg_call_01734de55d61e11d() { return handleError(function (arg0, arg1, arg2) {
     const ret = getObject(arg0).call(getObject(arg1), getObject(arg2));
     return addHeapObject(ret);
@@ -479,6 +560,16 @@ export function __wbg_set_5cf90238115182c3(arg0, arg1, arg2) {
     getObject(arg0).set(getObject(arg1), arg2 >>> 0);
 };
 
+export function __wbg_newwithbyteoffsetandlength_69193e31c844b792(arg0, arg1, arg2) {
+    const ret = new Float32Array(getObject(arg0), arg1 >>> 0, arg2 >>> 0);
+    return addHeapObject(ret);
+};
+
+export function __wbg_new_d086a66d1c264b3f(arg0) {
+    const ret = new Float32Array(getObject(arg0));
+    return addHeapObject(ret);
+};
+
 export function __wbg_newwithlength_e5d69174d6984cd7(arg0) {
     const ret = new Uint8Array(arg0 >>> 0);
     return addHeapObject(ret);
@@ -494,6 +585,14 @@ export function __wbindgen_object_clone_ref(arg0) {
     return addHeapObject(ret);
 };
 
+export function __wbindgen_debug_string(arg0, arg1) {
+    const ret = debugString(getObject(arg1));
+    const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    getInt32Memory0()[arg0 / 4 + 1] = len1;
+    getInt32Memory0()[arg0 / 4 + 0] = ptr1;
+};
+
 export function __wbindgen_throw(arg0, arg1) {
     throw new Error(getStringFromWasm0(arg0, arg1));
 };