@justinelliottcobb/amari-wasm 0.12.2 → 0.13.0

package/amari_wasm.js

@@ -45,6 +45,20 @@ function getStringFromWasm0(ptr, len) {
     return decodeText(ptr, len);
 }
 
+let cachedFloat64ArrayMemory0 = null;
+
+function getFloat64ArrayMemory0() {
+    if (cachedFloat64ArrayMemory0 === null || cachedFloat64ArrayMemory0.byteLength === 0) {
+        cachedFloat64ArrayMemory0 = new Float64Array(wasm.memory.buffer);
+    }
+    return cachedFloat64ArrayMemory0;
+}
+
+function getArrayF64FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getFloat64ArrayMemory0().subarray(ptr / 8, ptr / 8 + len);
+}
+
 let WASM_VECTOR_LEN = 0;
 
 const cachedTextEncoder = (typeof TextEncoder !== 'undefined' ? new TextEncoder('utf-8') : { encode: () => { throw Error('TextEncoder not available') } } );
@@ -209,20 +223,6 @@ function debugString(val) {
     // TODO we could test for more things here, like `Set`s and `Map`s.
     return className;
 }
-
-let cachedFloat64ArrayMemory0 = null;
-
-function getFloat64ArrayMemory0() {
-    if (cachedFloat64ArrayMemory0 === null || cachedFloat64ArrayMemory0.byteLength === 0) {
-        cachedFloat64ArrayMemory0 = new Float64Array(wasm.memory.buffer);
-    }
-    return cachedFloat64ArrayMemory0;
-}
-
-function getArrayF64FromWasm0(ptr, len) {
-    ptr = ptr >>> 0;
-    return getFloat64ArrayMemory0().subarray(ptr / 8, ptr / 8 + len);
-}
 /**
  * Initialize the WASM module
  */
@@ -429,11 +429,11 @@ function passArray32ToWasm0(arg, malloc) {
     return ptr;
 }
 function __wbg_adapter_28(arg0, arg1, arg2) {
-    wasm.closure58_externref_shim(arg0, arg1, arg2);
+    wasm.closure41_externref_shim(arg0, arg1, arg2);
 }
 
-function __wbg_adapter_496(arg0, arg1, arg2, arg3) {
-    wasm.closure49_externref_shim(arg0, arg1, arg2, arg3);
+function __wbg_adapter_511(arg0, arg1, arg2, arg3) {
+    wasm.closure34_externref_shim(arg0, arg1, arg2, arg3);
 }
 
 /**
@@ -2572,67 +2572,6 @@ export class WasmChowClass {
     }
 }
 
-const WasmCleanupResultFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_wasmcleanupresult_free(ptr >>> 0, 1));
-/**
- * WASM wrapper for cleanup results
- */
-export class WasmCleanupResult {
-
-    static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(WasmCleanupResult.prototype);
-        obj.__wbg_ptr = ptr;
-        WasmCleanupResultFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-    }
-
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        WasmCleanupResultFinalization.unregister(this);
-        return ptr;
-    }
-
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_wasmcleanupresult_free(ptr, 0);
-    }
-    /**
-     * Get the cleaned (denoised) value
-     * @returns {WasmTropicalDualClifford}
-     */
-    getCleaned() {
-        const ret = wasm.wasmcleanupresult_getCleaned(this.__wbg_ptr);
-        return WasmTropicalDualClifford.__wrap(ret);
-    }
-    /**
-     * Check if the cleanup converged
-     * @returns {boolean}
-     */
-    didConverge() {
-        const ret = wasm.wasmcleanupresult_didConverge(this.__wbg_ptr);
-        return ret !== 0;
-    }
-    /**
-     * Get the number of iterations used
-     * @returns {number}
-     */
-    getIterations() {
-        const ret = wasm.wasmcleanupresult_getIterations(this.__wbg_ptr);
-        return ret >>> 0;
-    }
-    /**
-     * Get the index of the best matching codebook item
-     * @returns {number}
-     */
-    getBestMatchIndex() {
-        const ret = wasm.wasmcleanupresult_getBestMatchIndex(this.__wbg_ptr);
-        return ret >>> 0;
-    }
-}
-
 const WasmCommunityFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_wasmcommunity_free(ptr >>> 0, 1));
@@ -3423,6 +3362,194 @@ export class WasmFourVelocity {
     }
 }
 
+const WasmGaussianMultivectorFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmgaussianmultivector_free(ptr >>> 0, 1));
+/**
+ * WASM wrapper for Gaussian distribution on Cl(3,0,0) multivector space
+ *
+ * A Gaussian distribution over 8-dimensional multivector space with
+ * configurable mean and per-component standard deviation.
+ */
+export class WasmGaussianMultivector {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(WasmGaussianMultivector.prototype);
+        obj.__wbg_ptr = ptr;
+        WasmGaussianMultivectorFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmGaussianMultivectorFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmgaussianmultivector_free(ptr, 0);
+    }
+    /**
+     * Get the standard deviations
+     *
+     * Returns 8 values
+     * @returns {Float64Array}
+     */
+    getStdDevs() {
+        const ret = wasm.wasmgaussianmultivector_getStdDevs(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * Get the variance (square of std devs)
+     *
+     * Returns 8 values
+     * @returns {Float64Array}
+     */
+    getVariance() {
+        const ret = wasm.wasmgaussianmultivector_getVariance(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * Draw multiple samples from this distribution
+     *
+     * Returns flat array of coefficients: num_samples * 8
+     * @param {number} num_samples
+     * @returns {Float64Array}
+     */
+    sampleBatch(num_samples) {
+        const ret = wasm.wasmgaussianmultivector_sampleBatch(this.__wbg_ptr, num_samples);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * Get the full covariance matrix (flattened, row-major)
+     *
+     * Returns 64 values (8x8 matrix)
+     * @returns {Float64Array}
+     */
+    getCovariance() {
+        const ret = wasm.wasmgaussianmultivector_getCovariance(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * Create a Gaussian with specified mean and standard deviation
+     *
+     * # Arguments
+     * * `mean` - 8 coefficients for the mean multivector
+     * * `std_dev` - 8 coefficients for per-coefficient standard deviation
+     * @param {Float64Array} mean
+     * @param {Float64Array} std_dev
+     * @returns {WasmGaussianMultivector}
+     */
+    static withParameters(mean, std_dev) {
+        const ptr0 = passArrayF64ToWasm0(mean, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArrayF64ToWasm0(std_dev, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmgaussianmultivector_withParameters(ptr0, len0, ptr1, len1);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmGaussianMultivector.__wrap(ret[0]);
+    }
+    /**
+     * Create a Gaussian concentrated on a specific grade
+     *
+     * # Arguments
+     * * `grade` - The grade to concentrate on (0=scalar, 1=vectors, 2=bivectors, 3=pseudoscalar)
+     * * `variance` - Variance for coefficients of that grade
+     * @param {number} grade
+     * @param {number} variance
+     * @returns {WasmGaussianMultivector}
+     */
+    static gradeConcentrated(grade, variance) {
+        const ret = wasm.wasmgaussianmultivector_gradeConcentrated(grade, variance);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmGaussianMultivector.__wrap(ret[0]);
+    }
+    /**
+     * Create a standard Gaussian (zero mean, unit variance per coefficient)
+     */
+    constructor() {
+        const ret = wasm.wasmgaussianmultivector_new();
+        this.__wbg_ptr = ret >>> 0;
+        WasmGaussianMultivectorFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Draw a sample from this distribution
+     *
+     * Returns 8 coefficients for the sampled multivector
+     * @returns {Float64Array}
+     */
+    sample() {
+        const ret = wasm.wasmgaussianmultivector_sample(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * Get the mean of this distribution
+     *
+     * Returns 8 coefficients
+     * @returns {Float64Array}
+     */
+    getMean() {
+        const ret = wasm.wasmgaussianmultivector_getMean(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * Compute log probability of a multivector
+     *
+     * # Arguments
+     * * `coefficients` - 8 coefficients of the multivector
+     * @param {Float64Array} coefficients
+     * @returns {number}
+     */
+    logProb(coefficients) {
+        const ptr0 = passArrayF64ToWasm0(coefficients, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmgaussianmultivector_logProb(this.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0];
+    }
+    /**
+     * Create an isotropic Gaussian with given mean and variance
+     *
+     * # Arguments
+     * * `mean` - 8 coefficients for the mean multivector
+     * * `variance` - Variance (same for all components)
+     * @param {Float64Array} mean
+     * @param {number} variance
+     * @returns {WasmGaussianMultivector}
+     */
+    static isotropic(mean, variance) {
+        const ptr0 = passArrayF64ToWasm0(mean, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmgaussianmultivector_isotropic(ptr0, len0, variance);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmGaussianMultivector.__wrap(ret[0]);
+    }
+}
+
 const WasmGeodesicIntegratorFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_wasmgeodesicintegrator_free(ptr >>> 0, 1));
@@ -4113,7 +4240,7 @@ const WasmHolographicMemoryFinalization = (typeof FinalizationRegistry === 'unde
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_wasmholographicmemory_free(ptr >>> 0, 1));
 /**
- * WASM wrapper for HolographicMemory
+ * WASM wrapper for HolographicMemory using ProductClifford algebra
  */
 export class WasmHolographicMemory {
 
@@ -4144,21 +4271,6 @@ export class WasmHolographicMemory {
         const ret = wasm.wasmholographicmemory_itemCount(this.__wbg_ptr);
         return ret >>> 0;
     }
-    /**
-     * Batch store multiple key-value pairs
-     * @param {Float64Array} keys
-     * @param {Float64Array} values
-     */
-    storeBatch(keys, values) {
-        const ptr0 = passArrayF64ToWasm0(keys, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ptr1 = passArrayF64ToWasm0(values, wasm.__wbindgen_malloc);
-        const len1 = WASM_VECTOR_LEN;
-        const ret = wasm.wasmholographicmemory_storeBatch(this.__wbg_ptr, ptr0, len0, ptr1, len1);
-        if (ret[1]) {
-            throw takeFromExternrefTable0(ret[0]);
-        }
-    }
     /**
      * Get the estimated SNR (signal-to-noise ratio)
      * @returns {number}
@@ -4168,21 +4280,22 @@ export class WasmHolographicMemory {
         return ret;
     }
     /**
-     * Check if memory is near capacity
-     * @returns {boolean}
+     * Generate a random versor (for use as key/value)
+     * @param {number} num_factors
+     * @returns {Float64Array}
      */
-    isNearCapacity() {
-        const ret = wasm.wasmholographicmemory_isNearCapacity(this.__wbg_ptr);
-        return ret !== 0;
+    static randomVersor(num_factors) {
+        const ret = wasm.wasmholographicmemory_randomVersor(num_factors);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
     }
     /**
-     * Check if memory probably contains a key
-     * @param {WasmTropicalDualClifford} key
+     * Check if memory is near capacity
      * @returns {boolean}
      */
-    probablyContains(key) {
-        _assertClass(key, WasmTropicalDualClifford);
-        const ret = wasm.wasmholographicmemory_probablyContains(this.__wbg_ptr, key.__wbg_ptr);
+    isNearCapacity() {
+        const ret = wasm.wasmholographicmemory_isNearCapacity(this.__wbg_ptr);
         return ret !== 0;
     }
     /**
@@ -4194,32 +4307,26 @@ export class WasmHolographicMemory {
         return WasmHolographicMemory.__wrap(ret);
     }
     /**
-     * Get the theoretical capacity
+     * Get retrieval confidence for a key
+     * @param {Float64Array} key
      * @returns {number}
      */
-    theoreticalCapacity() {
-        const ret = wasm.wasmholographicmemory_theoreticalCapacity(this.__wbg_ptr);
-        return ret >>> 0;
-    }
-    /**
-     * Retrieve with custom temperature
-     * @param {WasmTropicalDualClifford} key
-     * @param {number} beta
-     * @returns {WasmRetrievalResult}
-     */
-    retrieveAtTemperature(key, beta) {
-        _assertClass(key, WasmTropicalDualClifford);
-        const ret = wasm.wasmholographicmemory_retrieveAtTemperature(this.__wbg_ptr, key.__wbg_ptr, beta);
-        return WasmRetrievalResult.__wrap(ret);
+    retrieveConfidence(key) {
+        const ptr0 = passArrayF64ToWasm0(key, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmholographicmemory_retrieveConfidence(this.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0];
     }
     /**
-     * Create with custom bundle temperature
-     * @param {number} beta
-     * @returns {WasmHolographicMemory}
+     * Get capacity information
+     * @returns {number}
      */
-    static withBundleTemperature(beta) {
-        const ret = wasm.wasmholographicmemory_withBundleTemperature(beta);
-        return WasmHolographicMemory.__wrap(ret);
+    theoreticalCapacity() {
+        const ret = wasm.wasmholographicmemory_theoreticalCapacity(this.__wbg_ptr);
+        return ret >>> 0;
     }
     /**
      * Create a new holographic memory with default settings
@@ -4237,32 +4344,39 @@ export class WasmHolographicMemory {
         wasm.wasmholographicmemory_clear(this.__wbg_ptr);
     }
     /**
-     * Merge another memory into this one
-     * @param {WasmHolographicMemory} other
-     */
-    merge(other) {
-        _assertClass(other, WasmHolographicMemory);
-        wasm.wasmholographicmemory_merge(this.__wbg_ptr, other.__wbg_ptr);
-    }
-    /**
-     * Store a key-value pair in memory
-     * @param {WasmTropicalDualClifford} key
-     * @param {WasmTropicalDualClifford} value
+     * Store a key-value pair in memory (using flat coefficient arrays)
+     *
+     * Each array should have 256 coefficients for ProductCl3x32.
+     * @param {Float64Array} key
+     * @param {Float64Array} value
      */
     store(key, value) {
-        _assertClass(key, WasmTropicalDualClifford);
-        _assertClass(value, WasmTropicalDualClifford);
-        wasm.wasmholographicmemory_store(this.__wbg_ptr, key.__wbg_ptr, value.__wbg_ptr);
+        const ptr0 = passArrayF64ToWasm0(key, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArrayF64ToWasm0(value, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmholographicmemory_store(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
     }
     /**
      * Retrieve a value by key
-     * @param {WasmTropicalDualClifford} key
-     * @returns {WasmRetrievalResult}
+     *
+     * Returns the retrieved coefficients as a Float64Array.
+     * @param {Float64Array} key
+     * @returns {Float64Array}
      */
     retrieve(key) {
-        _assertClass(key, WasmTropicalDualClifford);
-        const ret = wasm.wasmholographicmemory_retrieve(this.__wbg_ptr, key.__wbg_ptr);
-        return WasmRetrievalResult.__wrap(ret);
+        const ptr0 = passArrayF64ToWasm0(key, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmholographicmemory_retrieve(this.__wbg_ptr, ptr0, len0);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v2;
     }
 }
 
@@ -4502,6 +4616,110 @@ export class WasmModuliSpace {
     }
 }
 
+const WasmMonteCarloEstimatorFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmmontecarloestimator_free(ptr >>> 0, 1));
+/**
+ * Monte Carlo estimation utilities
+ */
+export class WasmMonteCarloEstimator {
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmMonteCarloEstimatorFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmmontecarloestimator_free(ptr, 0);
+    }
+    /**
+     * Compute sample mean from batch samples
+     *
+     * # Arguments
+     * * `samples` - Flat array of samples (num_samples * 8)
+     *
+     * # Returns
+     * 8 coefficients for the mean
+     * @param {Float64Array} samples
+     * @returns {Float64Array}
+     */
+    static sampleMean(samples) {
+        const ptr0 = passArrayF64ToWasm0(samples, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmmontecarloestimator_sampleMean(ptr0, len0);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v2;
+    }
+    /**
+     * Compute sample variance from batch samples
+     *
+     * # Arguments
+     * * `samples` - Flat array of samples (num_samples * 8)
+     *
+     * # Returns
+     * 8 values for per-coefficient variance
+     * @param {Float64Array} samples
+     * @returns {Float64Array}
+     */
+    static sampleVariance(samples) {
+        const ptr0 = passArrayF64ToWasm0(samples, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmmontecarloestimator_sampleVariance(ptr0, len0);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v2;
+    }
+    /**
+     * Compute sample covariance matrix from batch samples
+     *
+     * # Arguments
+     * * `samples` - Flat array of samples (num_samples * 8)
+     *
+     * # Returns
+     * 64 values for 8x8 covariance matrix (row-major)
+     * @param {Float64Array} samples
+     * @returns {Float64Array}
+     */
+    static sampleCovariance(samples) {
+        const ptr0 = passArrayF64ToWasm0(samples, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmmontecarloestimator_sampleCovariance(ptr0, len0);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v2;
+    }
+    /**
+     * Monte Carlo estimate of expectation E[f(X)] where f is the geometric product
+     *
+     * Estimates E[X * Y] for independent X ~ dist_x, Y ~ dist_y
+     * @param {WasmGaussianMultivector} dist_x
+     * @param {WasmGaussianMultivector} dist_y
+     * @param {number} num_samples
+     * @returns {Float64Array}
+     */
+    static expectationGeometricProduct(dist_x, dist_y, num_samples) {
+        _assertClass(dist_x, WasmGaussianMultivector);
+        _assertClass(dist_y, WasmGaussianMultivector);
+        const ret = wasm.wasmmontecarloestimator_expectationGeometricProduct(dist_x.__wbg_ptr, dist_y.__wbg_ptr, num_samples);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+}
+
 const WasmMultiDualNumberFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_wasmmultidualnumber_free(ptr >>> 0, 1));
@@ -5716,18 +5934,10 @@ const WasmResonatorFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_wasmresonator_free(ptr >>> 0, 1));
 /**
- * WASM wrapper for Resonator (iterative cleanup)
+ * WASM wrapper for Resonator using ProductClifford algebra
  */
 export class WasmResonator {
 
-    static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(WasmResonator.prototype);
-        obj.__wbg_ptr = ptr;
-        WasmResonatorFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-    }
-
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
@@ -5739,22 +5949,6 @@ export class WasmResonator {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_wasmresonator_free(ptr, 0);
     }
-    /**
-     * Create with custom configuration
-     * @param {Float64Array} codebook_flat
-     * @param {number} max_iterations
-     * @param {number} convergence_threshold
-     * @returns {WasmResonator}
-     */
-    static withConfig(codebook_flat, max_iterations, convergence_threshold) {
-        const ptr0 = passArrayF64ToWasm0(codebook_flat, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.wasmresonator_withConfig(ptr0, len0, max_iterations, convergence_threshold);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return WasmResonator.__wrap(ret[0]);
-    }
     /**
      * Get the codebook size
      * @returns {number}
@@ -5764,7 +5958,23 @@ export class WasmResonator {
         return ret >>> 0;
     }
     /**
-     * Create a resonator from a codebook of TDC vectors
+     * Get cleanup result with metadata
+     * @param {Float64Array} input
+     * @returns {any}
+     */
+    cleanupWithInfo(input) {
+        const ptr0 = passArrayF64ToWasm0(input, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmresonator_cleanupWithInfo(this.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Create a resonator from a flat codebook array
+     *
+     * Each item should have 256 coefficients for ProductCl3x32.
      * @param {Float64Array} codebook_flat
      */
     constructor(codebook_flat) {
@@ -5780,69 +5990,19 @@ export class WasmResonator {
     }
     /**
      * Clean up a noisy input to find the closest codebook item
-     * @param {WasmTropicalDualClifford} input
-     * @returns {WasmCleanupResult}
+     * @param {Float64Array} input
+     * @returns {Float64Array}
      */
     cleanup(input) {
-        _assertClass(input, WasmTropicalDualClifford);
-        const ret = wasm.wasmresonator_cleanup(this.__wbg_ptr, input.__wbg_ptr);
-        return WasmCleanupResult.__wrap(ret);
-    }
-}
-
-const WasmRetrievalResultFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_wasmretrievalresult_free(ptr >>> 0, 1));
-/**
- * WASM wrapper for retrieval results
- */
-export class WasmRetrievalResult {
-
-    static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(WasmRetrievalResult.prototype);
-        obj.__wbg_ptr = ptr;
-        WasmRetrievalResultFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-    }
-
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        WasmRetrievalResultFinalization.unregister(this);
-        return ptr;
-    }
-
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_wasmretrievalresult_free(ptr, 0);
-    }
-    /**
-     * Get the retrieval confidence (0 to 1)
-     * @returns {number}
-     */
-    getConfidence() {
-        const ret = wasm.wasmretrievalresult_getConfidence(this.__wbg_ptr);
-        return ret;
-    }
-    /**
-     * Get attribution as arrays of [index, weight] pairs
-     * @returns {any}
-     */
-    getAttribution() {
-        const ret = wasm.wasmretrievalresult_getAttribution(this.__wbg_ptr);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
+        const ptr0 = passArrayF64ToWasm0(input, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmresonator_cleanup(this.__wbg_ptr, ptr0, len0);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
         }
-        return takeFromExternrefTable0(ret[0]);
-    }
-    /**
-     * Get the retrieved value
-     * @returns {WasmTropicalDualClifford}
-     */
-    getValue() {
-        const ret = wasm.wasmretrievalresult_getValue(this.__wbg_ptr);
-        return WasmTropicalDualClifford.__wrap(ret);
+        var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v2;
     }
 }
 
@@ -7242,6 +7402,164 @@ export class WasmTropicalViterbi {
     }
 }
 
+const WasmUniformMultivectorFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmuniformmultivector_free(ptr >>> 0, 1));
+/**
+ * WASM wrapper for Uniform distribution on Cl(3,0,0) multivector space
+ *
+ * A uniform distribution over a hyperrectangle in 8-dimensional multivector space.
+ */
+export class WasmUniformMultivector {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(WasmUniformMultivector.prototype);
+        obj.__wbg_ptr = ptr;
+        WasmUniformMultivectorFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmUniformMultivectorFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmuniformmultivector_free(ptr, 0);
+    }
+    /**
+     * Create a uniform distribution with specified bounds
+     *
+     * # Arguments
+     * * `lower` - 8 coefficients for lower bounds
+     * * `upper` - 8 coefficients for upper bounds
+     * @param {Float64Array} lower
+     * @param {Float64Array} upper
+     * @returns {WasmUniformMultivector}
+     */
+    static withBounds(lower, upper) {
+        const ptr0 = passArrayF64ToWasm0(lower, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArrayF64ToWasm0(upper, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmuniformmultivector_withBounds(ptr0, len0, ptr1, len1);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmUniformMultivector.__wrap(ret[0]);
+    }
+    /**
+     * Get the variance of this distribution
+     * @returns {Float64Array}
+     */
+    getVariance() {
+        const ret = wasm.wasmuniformmultivector_getVariance(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * Draw multiple samples from this distribution
+     *
+     * Returns flat array of coefficients: num_samples * 8
+     * @param {number} num_samples
+     * @returns {Float64Array}
+     */
+    sampleBatch(num_samples) {
+        const ret = wasm.wasmuniformmultivector_sampleBatch(this.__wbg_ptr, num_samples);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * Create a standard uniform distribution on [-1, 1]^8
+     */
+    constructor() {
+        const ret = wasm.wasmuniformmultivector_new();
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0] >>> 0;
+        WasmUniformMultivectorFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Draw a sample from this distribution
+     *
+     * Returns 8 coefficients for the sampled multivector
+     * @returns {Float64Array}
+     */
+    sample() {
+        const ret = wasm.wasmuniformmultivector_sample(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * Get the mean of this distribution
+     * @returns {Float64Array}
+     */
+    getMean() {
+        const ret = wasm.wasmuniformmultivector_getMean(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * Compute log probability of a multivector
+     *
+     * Returns log(1/volume) if inside bounds, error otherwise
+     * @param {Float64Array} coefficients
+     * @returns {number}
+     */
+    logProb(coefficients) {
+        const ptr0 = passArrayF64ToWasm0(coefficients, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmuniformmultivector_logProb(this.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0];
+    }
+    /**
+     * Get the lower bounds
+     * @returns {Float64Array}
+     */
+    getLower() {
+        const ret = wasm.wasmuniformmultivector_getLower(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * Get the upper bounds
+     * @returns {Float64Array}
+     */
+    getUpper() {
+        const ret = wasm.wasmuniformmultivector_getUpper(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * Create a uniform distribution on a hypercube [min, max]^8
+     * @param {number} min
+     * @param {number} max
+     * @returns {WasmUniformMultivector}
+     */
+    static hypercube(min, max) {
+        const ret = wasm.wasmuniformmultivector_hypercube(min, max);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmUniformMultivector.__wrap(ret[0]);
+    }
+}
+
 const EXPECTED_RESPONSE_TYPES = new Set(['basic', 'cors', 'default']);
 
 async function __wbg_load(module, imports) {
@@ -7323,7 +7641,7 @@ function __wbg_get_imports() {
         const ret = arg0.length;
         return ret;
     };
-    imports.wbg.__wbg_log_bf345a94df4f1349 = function(arg0, arg1) {
+    imports.wbg.__wbg_log_7696259bf4d9d36d = function(arg0, arg1) {
         console.log(getStringFromWasm0(arg0, arg1));
     };
     imports.wbg.__wbg_log_ea240990d83e374e = function(arg0) {
@@ -7348,7 +7666,7 @@ function __wbg_get_imports() {
                 const a = state0.a;
                 state0.a = 0;
                 try {
-                    return __wbg_adapter_496(a, state0.b, arg0, arg1);
+                    return __wbg_adapter_511(a, state0.b, arg0, arg1);
                 } finally {
                     state0.a = a;
                 }
@@ -7359,6 +7677,10 @@ function __wbg_get_imports() {
             state0.a = state0.b = 0;
         }
     };
+    imports.wbg.__wbg_newfromslice_bcd6b1e87ab624a5 = function(arg0, arg1) {
+        const ret = new Float64Array(getArrayF64FromWasm0(arg0, arg1));
+        return ret;
+    };
     imports.wbg.__wbg_newnoargs_ff528e72d35de39a = function(arg0, arg1) {
         const ret = new Function(getStringFromWasm0(arg0, arg1));
         return ret;
@@ -7444,8 +7766,8 @@ function __wbg_get_imports() {
         const ret = false;
         return ret;
     };
-    imports.wbg.__wbindgen_closure_wrapper1715 = function(arg0, arg1, arg2) {
-        const ret = makeMutClosure(arg0, arg1, 57, __wbg_adapter_28);
+    imports.wbg.__wbindgen_closure_wrapper1647 = function(arg0, arg1, arg2) {
+        const ret = makeMutClosure(arg0, arg1, 40, __wbg_adapter_28);
         return ret;
     };
     imports.wbg.__wbindgen_debug_string = function(arg0, arg1) {