@justinelliottcobb/amari-wasm 0.12.3 → 0.14.0

package/amari_wasm.js

@@ -429,11 +429,11 @@ function passArray32ToWasm0(arg, malloc) {
     return ptr;
 }
 function __wbg_adapter_28(arg0, arg1, arg2) {
-    wasm.closure40_externref_shim(arg0, arg1, arg2);
+    wasm.closure41_externref_shim(arg0, arg1, arg2);
 }
 
-function __wbg_adapter_486(arg0, arg1, arg2, arg3) {
-    wasm.closure33_externref_shim(arg0, arg1, arg2, arg3);
+function __wbg_adapter_550(arg0, arg1, arg2, arg3) {
+    wasm.closure34_externref_shim(arg0, arg1, arg2, arg3);
 }
 
 /**
@@ -3362,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));
@@ -3416,6 +3604,126 @@ export class WasmGeodesicIntegrator {
     }
 }
 
+const WasmGeometricBrownianMotionFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmgeometricbrownianmotion_free(ptr >>> 0, 1));
+/**
+ * WASM wrapper for Geometric Brownian Motion on multivector space
+ *
+ * dX = μX dt + σX dW
+ *
+ * Useful for modeling multiplicative noise processes in geometric algebra.
+ */
+export class WasmGeometricBrownianMotion {
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmGeometricBrownianMotionFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmgeometricbrownianmotion_free(ptr, 0);
+    }
+    /**
+     * Sample a single path of the process
+     *
+     * # Arguments
+     * * `initial` - Initial multivector (8 coefficients)
+     * * `t_end` - End time
+     * * `num_steps` - Number of time steps
+     *
+     * Returns flat array: (num_steps + 1) * 9 values
+     * Each point is [time, coeff0, coeff1, ..., coeff7]
+     * @param {Float64Array} initial
+     * @param {number} t_end
+     * @param {number} num_steps
+     * @returns {Float64Array}
+     */
+    samplePath(initial, t_end, num_steps) {
+        const ptr0 = passArrayF64ToWasm0(initial, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmgeometricbrownianmotion_samplePath(this.__wbg_ptr, ptr0, len0, t_end, num_steps);
+        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 expected value at time t given initial value
+     *
+     * E[X(t)] = X(0) * exp(μt)
+     * @param {Float64Array} initial
+     * @param {number} t
+     * @returns {Float64Array}
+     */
+    expectedValue(initial, t) {
+        const ptr0 = passArrayF64ToWasm0(initial, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmgeometricbrownianmotion_expectedValue(this.__wbg_ptr, ptr0, len0, t);
+        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;
+    }
+    /**
+     * Create a new Geometric Brownian Motion process
+     *
+     * # Arguments
+     * * `mu` - Drift coefficient (expected growth rate)
+     * * `sigma` - Diffusion coefficient (volatility)
+     * @param {number} mu
+     * @param {number} sigma
+     */
+    constructor(mu, sigma) {
+        const ret = wasm.wasmdualnumber_new(mu, sigma);
+        this.__wbg_ptr = ret >>> 0;
+        WasmGeometricBrownianMotionFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Get drift coefficient
+     * @returns {number}
+     */
+    getMu() {
+        const ret = wasm.wasmalphaconnection_getAlpha(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Compute variance at time t given initial value
+     *
+     * Var(X(t)) = X(0)² * exp(2μt) * (exp(σ²t) - 1)
+     * @param {Float64Array} initial
+     * @param {number} t
+     * @returns {Float64Array}
+     */
+    variance(initial, t) {
+        const ptr0 = passArrayF64ToWasm0(initial, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmgeometricbrownianmotion_variance(this.__wbg_ptr, ptr0, len0, t);
+        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;
+    }
+    /**
+     * Get diffusion coefficient
+     * @returns {number}
+     */
+    getSigma() {
+        const ret = wasm.wasmdualnumber_getDual(this.__wbg_ptr);
+        return ret;
+    }
+}
+
 const WasmGeometricCAFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_wasmgeometricca_free(ptr >>> 0, 1));
@@ -3995,6 +4303,108 @@ export class WasmGpuOptimizer {
     }
 }
 
+const WasmGradeProjectedDistributionFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmgradeprojecteddistribution_free(ptr >>> 0, 1));
+/**
+ * WASM wrapper for grade-projected distribution
+ *
+ * A distribution that only operates on components of a specific grade.
+ */
+export class WasmGradeProjectedDistribution {
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmGradeProjectedDistributionFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmgradeprojecteddistribution_free(ptr, 0);
+    }
+    /**
+     * Sample and embed into full multivector (other grades are zero)
+     *
+     * Returns 8 coefficients
+     * @returns {Float64Array}
+     */
+    sampleFull() {
+        const ret = wasm.wasmgradeprojecteddistribution_sampleFull(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * Get standard deviations
+     * @returns {Float64Array}
+     */
+    getStdDevs() {
+        const ret = wasm.wasmgradeprojecteddistribution_getStdDevs(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * Get number of components in this grade
+     * @returns {number}
+     */
+    getNumComponents() {
+        const ret = wasm.wasmgradeprojecteddistribution_getNumComponents(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Create a grade-projected distribution from a Gaussian
+     *
+     * # Arguments
+     * * `gaussian` - Source Gaussian distribution
+     * * `grade` - Grade to project onto (0, 1, 2, or 3 for Cl(3,0,0))
+     * @param {WasmGaussianMultivector} gaussian
+     * @param {number} grade
+     */
+    constructor(gaussian, grade) {
+        _assertClass(gaussian, WasmGaussianMultivector);
+        const ret = wasm.wasmgradeprojecteddistribution_new(gaussian.__wbg_ptr, grade);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0] >>> 0;
+        WasmGradeProjectedDistributionFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Sample from this grade-projected distribution
+     *
+     * Returns components for just this grade
+     * @returns {Float64Array}
+     */
+    sample() {
+        const ret = wasm.wasmgradeprojecteddistribution_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 for this grade's components
+     * @returns {Float64Array}
+     */
+    getMean() {
+        const ret = wasm.wasmgradeprojecteddistribution_getMean(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * Get the grade
+     * @returns {number}
+     */
+    getGrade() {
+        const ret = wasm.riemannianmanifold_dimension(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+
 const WasmGrassmannianFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_wasmgrassmannian_free(ptr >>> 0, 1));
@@ -4347,6 +4757,184 @@ export class WasmLebesgueMeasure {
     }
 }
 
+const WasmMCMCDiagnosticsFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmmcmcdiagnostics_free(ptr >>> 0, 1));
+/**
+ * WASM wrapper for MCMC diagnostics
+ */
+export class WasmMCMCDiagnostics {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(WasmMCMCDiagnostics.prototype);
+        obj.__wbg_ptr = ptr;
+        WasmMCMCDiagnosticsFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmMCMCDiagnosticsFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmmcmcdiagnostics_free(ptr, 0);
+    }
+    /**
+     * Total number of steps
+     * @returns {number}
+     */
+    get num_steps() {
+        const ret = wasm.__wbg_get_wasmmcmcdiagnostics_num_steps(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Total number of steps
+     * @param {number} arg0
+     */
+    set num_steps(arg0) {
+        wasm.__wbg_set_wasmmcmcdiagnostics_num_steps(this.__wbg_ptr, arg0);
+    }
+    /**
+     * Acceptance rate
+     * @returns {number}
+     */
+    get acceptance_rate() {
+        const ret = wasm.__wbg_get_wasmmcmcdiagnostics_acceptance_rate(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Acceptance rate
+     * @param {number} arg0
+     */
+    set acceptance_rate(arg0) {
+        wasm.__wbg_set_wasmmcmcdiagnostics_acceptance_rate(this.__wbg_ptr, arg0);
+    }
+    /**
+     * Check if the sampler has converged (R-hat < 1.1)
+     * @returns {boolean}
+     */
+    isConverged() {
+        const ret = wasm.wasmmcmcdiagnostics_isConverged(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Get effective sample size (or -1 if not computed)
+     * @returns {number}
+     */
+    getEffectiveSampleSize() {
+        const ret = wasm.wasmmcmcdiagnostics_getEffectiveSampleSize(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Get R-hat statistic (or -1 if not computed)
+     * @returns {number}
+     */
+    getRHat() {
+        const ret = wasm.wasmmcmcdiagnostics_getRHat(this.__wbg_ptr);
+        return ret;
+    }
+}
+
+const WasmMetropolisHastingsFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmmetropolishastings_free(ptr >>> 0, 1));
+/**
+ * WASM wrapper for Metropolis-Hastings MCMC sampler
+ *
+ * Samples from a target distribution using random-walk proposals.
+ */
+export class WasmMetropolisHastings {
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmMetropolisHastingsFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmmetropolishastings_free(ptr, 0);
+    }
+    /**
+     * Get sampling diagnostics
+     * @returns {WasmMCMCDiagnostics}
+     */
+    diagnostics() {
+        const ret = wasm.wasmmetropolishastings_diagnostics(this.__wbg_ptr);
+        return WasmMCMCDiagnostics.__wrap(ret);
+    }
+    /**
+     * Get current sample
+     * @returns {Float64Array}
+     */
+    getCurrent() {
+        const ret = wasm.wasmmetropolishastings_getCurrent(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * Get current acceptance rate
+     * @returns {number}
+     */
+    getAcceptanceRate() {
+        const ret = wasm.wasmmetropolishastings_getAcceptanceRate(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Create a new Metropolis-Hastings sampler for a Gaussian target
+     *
+     * # Arguments
+     * * `target` - The target Gaussian distribution to sample from
+     * * `proposal_std` - Standard deviation for the proposal distribution
+     * @param {WasmGaussianMultivector} target
+     * @param {number} proposal_std
+     */
+    constructor(target, proposal_std) {
+        _assertClass(target, WasmGaussianMultivector);
+        const ret = wasm.wasmmetropolishastings_new(target.__wbg_ptr, proposal_std);
+        this.__wbg_ptr = ret >>> 0;
+        WasmMetropolisHastingsFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Run the sampler for multiple steps
+     *
+     * # Arguments
+     * * `num_samples` - Number of samples to collect
+     * * `burnin` - Number of burn-in steps to discard
+     *
+     * Returns flat array of samples (num_samples * 8)
+     * @param {number} num_samples
+     * @param {number} burnin
+     * @returns {Float64Array}
+     */
+    run(num_samples, burnin) {
+        const ret = wasm.wasmmetropolishastings_run(this.__wbg_ptr, num_samples, burnin);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * Take a single MCMC step
+     *
+     * Returns the new sample (8 coefficients)
+     * @returns {Float64Array}
+     */
+    step() {
+        const ret = wasm.wasmmetropolishastings_step(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+}
+
 const WasmModuliSpaceFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_wasmmodulispace_free(ptr >>> 0, 1));
@@ -4422,9 +5010,113 @@ export class WasmModuliSpace {
      * @param {number} marked_points
      * @returns {WasmModuliSpace}
      */
-    static ofCurves(genus, marked_points) {
-        const ret = wasm.wasmmodulispace_ofCurves(genus, marked_points);
-        return WasmModuliSpace.__wrap(ret);
+    static ofCurves(genus, marked_points) {
+        const ret = wasm.wasmmodulispace_ofCurves(genus, marked_points);
+        return WasmModuliSpace.__wrap(ret);
+    }
+}
+
+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;
     }
 }
 
@@ -6214,7 +6906,7 @@ export class WasmTrajectoryPoint {
      * @returns {number}
      */
     get time() {
-        const ret = wasm.__wbg_get_wasmtrajectorypoint_time(this.__wbg_ptr);
+        const ret = wasm.__wbg_get_wasmmcmcdiagnostics_acceptance_rate(this.__wbg_ptr);
         return ret;
     }
     /**
@@ -6222,7 +6914,7 @@ export class WasmTrajectoryPoint {
      * @param {number} arg0
      */
     set time(arg0) {
-        wasm.__wbg_set_wasmtrajectorypoint_time(this.__wbg_ptr, arg0);
+        wasm.__wbg_set_wasmmcmcdiagnostics_acceptance_rate(this.__wbg_ptr, arg0);
     }
     /**
      * Get position
@@ -7110,6 +7802,387 @@ export class WasmTropicalViterbi {
     }
 }
 
+const WasmUncertainMultivectorFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmuncertainmultivector_free(ptr >>> 0, 1));
+/**
+ * WASM wrapper for uncertain multivector (mean + covariance)
+ *
+ * Represents a multivector with associated uncertainty, useful for
+ * error propagation through geometric operations.
+ */
+export class WasmUncertainMultivector {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(WasmUncertainMultivector.prototype);
+        obj.__wbg_ptr = ptr;
+        WasmUncertainMultivectorFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmUncertainMultivectorFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmuncertainmultivector_free(ptr, 0);
+    }
+    /**
+     * Get standard deviations
+     * @returns {Float64Array}
+     */
+    getStdDevs() {
+        const ret = wasm.wasmuncertainmultivector_getStdDevs(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * Create a deterministic (zero variance) uncertain multivector
+     * @param {Float64Array} value
+     * @returns {WasmUncertainMultivector}
+     */
+    static deterministic(value) {
+        const ptr0 = passArrayF64ToWasm0(value, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmuncertainmultivector_deterministic(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmUncertainMultivector.__wrap(ret[0]);
+    }
+    /**
+     * Get variances (diagonal of covariance)
+     * @returns {Float64Array}
+     */
+    getVariances() {
+        const ret = wasm.wasmuncertainmultivector_getVariances(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * Get the covariance matrix (64 values, row-major)
+     * @returns {Float64Array}
+     */
+    getCovariance() {
+        const ret = wasm.wasmuncertainmultivector_getCovariance(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * Create with full covariance matrix
+     *
+     * # Arguments
+     * * `mean` - 8 coefficients for the mean
+     * * `covariance` - 64 values for 8x8 covariance matrix (row-major)
+     * @param {Float64Array} mean
+     * @param {Float64Array} covariance
+     * @returns {WasmUncertainMultivector}
+     */
+    static withCovariance(mean, covariance) {
+        const ptr0 = passArrayF64ToWasm0(mean, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArrayF64ToWasm0(covariance, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmuncertainmultivector_withCovariance(ptr0, len0, ptr1, len1);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmUncertainMultivector.__wrap(ret[0]);
+    }
+    /**
+     * Get total variance (trace of covariance)
+     * @returns {number}
+     */
+    getTotalVariance() {
+        const ret = wasm.wasmuncertainmultivector_getTotalVariance(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Add two uncertain multivectors (assuming independence)
+     *
+     * For Z = X + Y: E[Z] = E[X] + E[Y], Var(Z) = Var(X) + Var(Y)
+     * @param {WasmUncertainMultivector} other
+     * @returns {WasmUncertainMultivector}
+     */
+    add(other) {
+        _assertClass(other, WasmUncertainMultivector);
+        const ret = wasm.wasmuncertainmultivector_add(this.__wbg_ptr, other.__wbg_ptr);
+        return WasmUncertainMultivector.__wrap(ret);
+    }
+    /**
+     * Create an uncertain multivector with diagonal covariance
+     *
+     * # Arguments
+     * * `mean` - 8 coefficients for the mean
+     * * `variances` - 8 values for per-coefficient variance
+     * @param {Float64Array} mean
+     * @param {Float64Array} variances
+     */
+    constructor(mean, variances) {
+        const ptr0 = passArrayF64ToWasm0(mean, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArrayF64ToWasm0(variances, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmuncertainmultivector_new(ptr0, len0, ptr1, len1);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0] >>> 0;
+        WasmUncertainMultivectorFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Linear propagation: scale by a constant
+     *
+     * For Y = aX: E[Y] = aE[X], Var(Y) = a²Var(X)
+     * @param {number} scalar
+     * @returns {WasmUncertainMultivector}
+     */
+    scale(scalar) {
+        const ret = wasm.wasmuncertainmultivector_scale(this.__wbg_ptr, scalar);
+        return WasmUncertainMultivector.__wrap(ret);
+    }
+    /**
+     * Get the mean
+     * @returns {Float64Array}
+     */
+    getMean() {
+        const ret = wasm.wasmuncertainmultivector_getMean(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+}
+
+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 WasmWienerProcessFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmwienerprocess_free(ptr >>> 0, 1));
+/**
+ * WASM wrapper for Wiener process (Brownian motion)
+ *
+ * Standard Brownian motion W(t) with W(0) = 0
+ */
+export class WasmWienerProcess {
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmWienerProcessFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmwienerprocess_free(ptr, 0);
+    }
+    /**
+     * Sample a path of the Wiener process
+     *
+     * # Arguments
+     * * `t_end` - End time
+     * * `num_steps` - Number of time steps
+     *
+     * Returns flat array: (num_steps + 1) * (dim + 1) values
+     * Each point is [time, w0, w1, ...]
+     * @param {number} t_end
+     * @param {number} num_steps
+     * @returns {Float64Array}
+     */
+    samplePath(t_end, num_steps) {
+        const ret = wasm.wasmwienerprocess_samplePath(this.__wbg_ptr, t_end, num_steps);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * Create a new Wiener process
+     *
+     * # Arguments
+     * * `dim` - Dimension of the process (default 8 for multivector space)
+     * @param {number | null} [dim]
+     */
+    constructor(dim) {
+        const ret = wasm.wasmwienerprocess_new(isLikeNone(dim) ? 0x100000001 : (dim) >>> 0);
+        this.__wbg_ptr = ret >>> 0;
+        WasmWienerProcessFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Get dimension
+     * @returns {number}
+     */
+    getDim() {
+        const ret = wasm.wasmlebesguemeasure_getDimension(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+
 const EXPECTED_RESPONSE_TYPES = new Set(['basic', 'cors', 'default']);
 
 async function __wbg_load(module, imports) {
@@ -7191,12 +8264,12 @@ function __wbg_get_imports() {
         const ret = arg0.length;
         return ret;
     };
-    imports.wbg.__wbg_log_73e7856ded7435b4 = function(arg0, arg1) {
-        console.log(getStringFromWasm0(arg0, arg1));
-    };
     imports.wbg.__wbg_log_ea240990d83e374e = function(arg0) {
         console.log(arg0);
     };
+    imports.wbg.__wbg_log_fcb816babb5e424a = function(arg0, arg1) {
+        console.log(getStringFromWasm0(arg0, arg1));
+    };
     imports.wbg.__wbg_new_07b483f72211fd66 = function() {
         const ret = new Object();
         return ret;
@@ -7216,7 +8289,7 @@ function __wbg_get_imports() {
                 const a = state0.a;
                 state0.a = 0;
                 try {
-                    return __wbg_adapter_486(a, state0.b, arg0, arg1);
+                    return __wbg_adapter_550(a, state0.b, arg0, arg1);
                 } finally {
                     state0.a = a;
                 }
@@ -7316,8 +8389,8 @@ function __wbg_get_imports() {
         const ret = false;
         return ret;
     };
-    imports.wbg.__wbindgen_closure_wrapper1599 = function(arg0, arg1, arg2) {
-        const ret = makeMutClosure(arg0, arg1, 39, __wbg_adapter_28);
+    imports.wbg.__wbindgen_closure_wrapper1708 = function(arg0, arg1, arg2) {
+        const ret = makeMutClosure(arg0, arg1, 40, __wbg_adapter_28);
         return ret;
     };
     imports.wbg.__wbindgen_debug_string = function(arg0, arg1) {