@justinelliottcobb/amari-wasm 0.12.3 → 0.13.0

package/README.md

@@ -1,4 +1,4 @@
-# @justinelliottcobb/amari-wasm v0.9.10
+# @justinelliottcobb/amari-wasm v0.13.0
 
 **Unified Mathematical Computing Library with High-Precision WebAssembly Support**
 
@@ -16,7 +16,8 @@ Amari is a comprehensive mathematical computing library that brings advanced alg
 - **Tropical Algebra**: Max-plus semiring operations for optimization and neural network applications
 - **Automatic Differentiation**: Forward-mode AD with dual numbers for exact derivatives
 - **Measure Theory** *(v0.10.0)*: Lebesgue integration, probability measures, and measure-theoretic foundations
-- **Holographic Memory** *(v0.12.2)*: Vector Symbolic Architecture for associative memory with binding and bundling operations
+- **Holographic Memory** *(v0.12.3)*: Vector Symbolic Architecture for associative memory with binding and bundling operations
+- **Probability Theory** *(v0.13.0)*: Distributions on multivector spaces, MCMC sampling, and Monte Carlo estimation
 - **Relativistic Physics**: Spacetime algebra (Cl(1,3)) with WebAssembly-compatible precision
 - **Spacecraft Orbital Mechanics**: Full-precision trajectory calculations in browsers
 - **Cellular Automata**: Geometric cellular automata with multivector states
@@ -275,6 +276,82 @@ async function holographicDemo() {
 holographicDemo();
 ```
 
+### Probability on Geometric Algebra *(v0.13.0)*
+
+Sample from distributions on multivector spaces and perform Monte Carlo estimation:
+
+```typescript
+import init, {
+  WasmGaussianMultivector,
+  WasmUniformMultivector,
+  WasmMonteCarloEstimator
+} from '@justinelliottcobb/amari-wasm';
+
+async function probabilisticDemo() {
+  await init();
+
+  // Create a standard Gaussian distribution on Cl(3,0,0)
+  const gaussian = WasmGaussianMultivector.standard();
+
+  // Draw samples
+  const samples = [];
+  for (let i = 0; i < 1000; i++) {
+    samples.push(gaussian.sample());
+  }
+  console.log(`Drew ${samples.length} Gaussian samples`);
+
+  // Compute log probability
+  const sample = gaussian.sample();
+  const logProb = gaussian.logProb(sample);
+  console.log(`Log probability: ${logProb}`);
+
+  // Grade-concentrated distribution (e.g., only on bivectors)
+  const bivectorDist = WasmGaussianMultivector.gradeConcentrated(2, 1.0);
+  const bivectorSample = bivectorDist.sample();
+
+  // Uniform distribution on unit multivectors
+  const uniform = WasmUniformMultivector.unitSphere();
+  const unitSample = uniform.sample();
+
+  // Monte Carlo estimation
+  const estimator = new WasmMonteCarloEstimator();
+
+  // Estimate expectation of a function
+  const estimate = estimator.estimate((mv) => mv.norm(), gaussian, 10000);
+  console.log(`Expected norm: ${estimate.mean} ± ${estimate.stdError}`);
+
+  // Clean up WASM memory
+  gaussian.free();
+  bivectorDist.free();
+  uniform.free();
+  sample.free();
+  bivectorSample.free();
+  unitSample.free();
+  estimator.free();
+  samples.forEach(s => s.free());
+}
+
+probabilisticDemo();
+```
+
+#### Probability API
+
+**WasmGaussianMultivector:**
+- `standard()`: Create standard Gaussian on full multivector space
+- `new(mean, covariance)`: Create with specified mean and covariance
+- `gradeConcentrated(grade, scale)`: Gaussian concentrated on specific grade
+- `sample()`: Draw a random sample
+- `logProb(sample)`: Compute log probability density
+
+**WasmUniformMultivector:**
+- `unitSphere()`: Uniform distribution on unit multivectors
+- `gradeSimplex(grade)`: Uniform on grade components summing to 1
+- `sample()`: Draw a random sample
+
+**WasmMonteCarloEstimator:**
+- `estimate(fn, distribution, nSamples)`: Estimate expectation
+- `estimateVariance(fn, distribution, nSamples)`: Estimate variance
+
 #### Holographic Memory API
 
 **TropicalDualClifford Operations:**
@@ -307,6 +384,8 @@ holographicDemo();
 - **Optimization**: Tropical algebra for shortest path and scheduling problems
 - **Scientific Computing**: High-performance mathematical operations with orbital-grade precision
 - **Probability & Statistics**: Measure theory and numerical integration for statistical computations
+- **Bayesian Inference**: Probabilistic modeling on geometric algebra spaces
+- **Uncertainty Quantification**: Monte Carlo methods for error propagation
 - **Game Development**: Efficient spatial transformations and physics
 - **Spacecraft Trajectory Planning**: High-precision orbital mechanics in web applications
 - **Symbolic AI**: Holographic memory for associative reasoning and concept binding
@@ -348,6 +427,16 @@ holographicDemo();
 - `WasmHolographicMemory.retrieve(key)`: Retrieve by key
 - `WasmResonator.cleanup(input)`: Clean up noisy input
 
+### Probabilistic Operations
+
+- `WasmGaussianMultivector.standard()`: Standard Gaussian distribution
+- `WasmGaussianMultivector.gradeConcentrated(grade, scale)`: Grade-specific Gaussian
+- `WasmGaussianMultivector.sample()`: Draw random sample
+- `WasmGaussianMultivector.logProb(sample)`: Log probability density
+- `WasmUniformMultivector.unitSphere()`: Uniform on unit sphere
+- `WasmUniformMultivector.sample()`: Draw random sample
+- `WasmMonteCarloEstimator.estimate(fn, dist, n)`: Monte Carlo expectation
+
 ## Examples
 
 Check out the [examples directory](https://github.com/justinelliottcobb/Amari/tree/master/examples) for more detailed usage:

package/amari_wasm.d.ts

@@ -1165,6 +1165,86 @@ export class WasmFourVelocity {
    */
   to_string(): string;
 }
+/**
+ * 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 {
+  free(): void;
+  /**
+   * Get the standard deviations
+   *
+   * Returns 8 values
+   */
+  getStdDevs(): Float64Array;
+  /**
+   * Get the variance (square of std devs)
+   *
+   * Returns 8 values
+   */
+  getVariance(): Float64Array;
+  /**
+   * Draw multiple samples from this distribution
+   *
+   * Returns flat array of coefficients: num_samples * 8
+   */
+  sampleBatch(num_samples: number): Float64Array;
+  /**
+   * Get the full covariance matrix (flattened, row-major)
+   *
+   * Returns 64 values (8x8 matrix)
+   */
+  getCovariance(): Float64Array;
+  /**
+   * 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
+   */
+  static withParameters(mean: Float64Array, std_dev: Float64Array): WasmGaussianMultivector;
+  /**
+   * 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
+   */
+  static gradeConcentrated(grade: number, variance: number): WasmGaussianMultivector;
+  /**
+   * Create a standard Gaussian (zero mean, unit variance per coefficient)
+   */
+  constructor();
+  /**
+   * Draw a sample from this distribution
+   *
+   * Returns 8 coefficients for the sampled multivector
+   */
+  sample(): Float64Array;
+  /**
+   * Get the mean of this distribution
+   *
+   * Returns 8 coefficients
+   */
+  getMean(): Float64Array;
+  /**
+   * Compute log probability of a multivector
+   *
+   * # Arguments
+   * * `coefficients` - 8 coefficients of the multivector
+   */
+  logProb(coefficients: Float64Array): number;
+  /**
+   * Create an isotropic Gaussian with given mean and variance
+   *
+   * # Arguments
+   * * `mean` - 8 coefficients for the mean multivector
+   * * `variance` - Variance (same for all components)
+   */
+  static isotropic(mean: Float64Array, variance: number): WasmGaussianMultivector;
+}
 /**
  * WASM wrapper for geodesic integration
  */
@@ -1536,6 +1616,49 @@ export class WasmModuliSpace {
    */
   static ofCurves(genus: number, marked_points: number): WasmModuliSpace;
 }
+/**
+ * Monte Carlo estimation utilities
+ */
+export class WasmMonteCarloEstimator {
+  private constructor();
+  free(): void;
+  /**
+   * Compute sample mean from batch samples
+   *
+   * # Arguments
+   * * `samples` - Flat array of samples (num_samples * 8)
+   *
+   * # Returns
+   * 8 coefficients for the mean
+   */
+  static sampleMean(samples: Float64Array): Float64Array;
+  /**
+   * Compute sample variance from batch samples
+   *
+   * # Arguments
+   * * `samples` - Flat array of samples (num_samples * 8)
+   *
+   * # Returns
+   * 8 values for per-coefficient variance
+   */
+  static sampleVariance(samples: Float64Array): Float64Array;
+  /**
+   * 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)
+   */
+  static sampleCovariance(samples: Float64Array): Float64Array;
+  /**
+   * 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
+   */
+  static expectationGeometricProduct(dist_x: WasmGaussianMultivector, dist_y: WasmGaussianMultivector, num_samples: number): Float64Array;
+}
 /**
  * WASM wrapper for multi-variable dual numbers
  */
@@ -2509,6 +2632,64 @@ export class WasmTropicalViterbi {
    */
   decode(observations: Uint32Array): any;
 }
+/**
+ * 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 {
+  free(): void;
+  /**
+   * Create a uniform distribution with specified bounds
+   *
+   * # Arguments
+   * * `lower` - 8 coefficients for lower bounds
+   * * `upper` - 8 coefficients for upper bounds
+   */
+  static withBounds(lower: Float64Array, upper: Float64Array): WasmUniformMultivector;
+  /**
+   * Get the variance of this distribution
+   */
+  getVariance(): Float64Array;
+  /**
+   * Draw multiple samples from this distribution
+   *
+   * Returns flat array of coefficients: num_samples * 8
+   */
+  sampleBatch(num_samples: number): Float64Array;
+  /**
+   * Create a standard uniform distribution on [-1, 1]^8
+   */
+  constructor();
+  /**
+   * Draw a sample from this distribution
+   *
+   * Returns 8 coefficients for the sampled multivector
+   */
+  sample(): Float64Array;
+  /**
+   * Get the mean of this distribution
+   */
+  getMean(): Float64Array;
+  /**
+   * Compute log probability of a multivector
+   *
+   * Returns log(1/volume) if inside bounds, error otherwise
+   */
+  logProb(coefficients: Float64Array): number;
+  /**
+   * Get the lower bounds
+   */
+  getLower(): Float64Array;
+  /**
+   * Get the upper bounds
+   */
+  getUpper(): Float64Array;
+  /**
+   * Create a uniform distribution on a hypercube [min, max]^8
+   */
+  static hypercube(min: number, max: number): WasmUniformMultivector;
+}
 
 export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
 
@@ -2526,6 +2707,7 @@ export interface InitOutput {
   readonly __wbg_wasmevaluationresult_free: (a: number, b: number) => void;
   readonly __wbg_wasmfisherinformationmatrix_free: (a: number, b: number) => void;
   readonly __wbg_wasmfishermeasure_free: (a: number, b: number) => void;
+  readonly __wbg_wasmgaussianmultivector_free: (a: number, b: number) => void;
   readonly __wbg_wasmgeodesicintegrator_free: (a: number, b: number) => void;
   readonly __wbg_wasmgeometricca_free: (a: number, b: number) => void;
   readonly __wbg_wasmgeometricnetwork_free: (a: number, b: number) => void;
@@ -2549,6 +2731,7 @@ export interface InitOutput {
   readonly __wbg_wasmtropicalnetwork_free: (a: number, b: number) => void;
   readonly __wbg_wasmtropicalpolynomial_free: (a: number, b: number) => void;
   readonly __wbg_wasmtropicalviterbi_free: (a: number, b: number) => void;
+  readonly __wbg_wasmuniformmultivector_free: (a: number, b: number) => void;
   readonly autodiff_evaluatePolynomial: (a: number, b: number, c: number) => number;
   readonly autodiff_linearLayer: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => [number, number, number, number];
   readonly autodiff_meanSquaredError: (a: number, b: number, c: number, d: number) => [number, number, number];
@@ -2707,6 +2890,17 @@ export interface InitOutput {
   readonly wasmfourvelocity_rapidity: (a: number) => number;
   readonly wasmfourvelocity_spatial_velocity_magnitude: (a: number) => number;
   readonly wasmfourvelocity_to_string: (a: number) => [number, number];
+  readonly wasmgaussianmultivector_getCovariance: (a: number) => [number, number];
+  readonly wasmgaussianmultivector_getMean: (a: number) => [number, number];
+  readonly wasmgaussianmultivector_getStdDevs: (a: number) => [number, number];
+  readonly wasmgaussianmultivector_getVariance: (a: number) => [number, number];
+  readonly wasmgaussianmultivector_gradeConcentrated: (a: number, b: number) => [number, number, number];
+  readonly wasmgaussianmultivector_isotropic: (a: number, b: number, c: number) => [number, number, number];
+  readonly wasmgaussianmultivector_logProb: (a: number, b: number, c: number) => [number, number, number];
+  readonly wasmgaussianmultivector_new: () => number;
+  readonly wasmgaussianmultivector_sample: (a: number) => [number, number];
+  readonly wasmgaussianmultivector_sampleBatch: (a: number, b: number) => [number, number];
+  readonly wasmgaussianmultivector_withParameters: (a: number, b: number, c: number, d: number) => [number, number, number];
   readonly wasmgeodesicintegrator_propagate_particle: (a: number, b: number, c: number, d: number) => [number, number, number];
   readonly wasmgeodesicintegrator_with_schwarzschild: (a: number) => number;
   readonly wasmgeometricca_addGlider: (a: number, b: number, c: number) => [number, number];
@@ -2778,6 +2972,10 @@ export interface InitOutput {
   readonly wasmmodulispace_isProper: (a: number) => number;
   readonly wasmmodulispace_ofCurves: (a: number, b: number) => number;
   readonly wasmmodulispace_ofStableCurves: (a: number, b: number) => number;
+  readonly wasmmontecarloestimator_expectationGeometricProduct: (a: number, b: number, c: number) => [number, number];
+  readonly wasmmontecarloestimator_sampleCovariance: (a: number, b: number) => [number, number, number, number];
+  readonly wasmmontecarloestimator_sampleMean: (a: number, b: number) => [number, number, number, number];
+  readonly wasmmontecarloestimator_sampleVariance: (a: number, b: number) => [number, number, number, number];
   readonly wasmmultidualnumber_add: (a: number, b: number) => [number, number, number];
   readonly wasmmultidualnumber_constant: (a: number, b: number) => number;
   readonly wasmmultidualnumber_getGradient: (a: number) => [number, number];
@@ -2938,6 +3136,16 @@ export interface InitOutput {
   readonly wasmtropicalviterbi_decode: (a: number, b: number, c: number) => [number, number, number];
   readonly wasmtropicalviterbi_forward_probabilities: (a: number, b: number, c: number) => [number, number, number];
   readonly wasmtropicalviterbi_new: (a: any, b: any) => [number, number, number];
+  readonly wasmuniformmultivector_getLower: (a: number) => [number, number];
+  readonly wasmuniformmultivector_getMean: (a: number) => [number, number];
+  readonly wasmuniformmultivector_getUpper: (a: number) => [number, number];
+  readonly wasmuniformmultivector_getVariance: (a: number) => [number, number];
+  readonly wasmuniformmultivector_hypercube: (a: number, b: number) => [number, number, number];
+  readonly wasmuniformmultivector_logProb: (a: number, b: number, c: number) => [number, number, number];
+  readonly wasmuniformmultivector_new: () => [number, number, number];
+  readonly wasmuniformmultivector_sample: (a: number) => [number, number];
+  readonly wasmuniformmultivector_sampleBatch: (a: number, b: number) => [number, number];
+  readonly wasmuniformmultivector_withBounds: (a: number, b: number, c: number, d: number) => [number, number, number];
   readonly wasmtropicalnumber_new: (a: number) => number;
   readonly vectorfield_fromFunction2D: (a: any) => number;
   readonly vectorfield_fromFunction3D: (a: any) => number;
@@ -2993,6 +3201,7 @@ export interface InitOutput {
   readonly __wbg_wasmfourvelocity_free: (a: number, b: number) => void;
   readonly __wbg_wasmgeometricedge_free: (a: number, b: number) => void;
   readonly __wbg_wasmgpuoptimizer_free: (a: number, b: number) => void;
+  readonly __wbg_wasmmontecarloestimator_free: (a: number, b: number) => void;
   readonly __wbg_wasmmultiobjectiveoptimizer_free: (a: number, b: number) => void;
   readonly __wbg_wasmoptimizationutils_free: (a: number, b: number) => void;
   readonly __wbg_wasmprojectivespace_free: (a: number, b: number) => void;
@@ -3017,8 +3226,8 @@ export interface InitOutput {
   readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
   readonly __wbindgen_export_6: WebAssembly.Table;
   readonly __externref_table_dealloc: (a: number) => void;
-  readonly closure40_externref_shim: (a: number, b: number, c: any) => void;
-  readonly closure33_externref_shim: (a: number, b: number, c: any, d: any) => void;
+  readonly closure41_externref_shim: (a: number, b: number, c: any) => void;
+  readonly closure34_externref_shim: (a: number, b: number, c: any, d: any) => void;
   readonly __wbindgen_start: () => void;
 }
 

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_511(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));
@@ -4428,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));
@@ -7110,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) {
@@ -7191,7 +7641,7 @@ function __wbg_get_imports() {
         const ret = arg0.length;
         return ret;
     };
-    imports.wbg.__wbg_log_73e7856ded7435b4 = function(arg0, arg1) {
+    imports.wbg.__wbg_log_7696259bf4d9d36d = function(arg0, arg1) {
         console.log(getStringFromWasm0(arg0, arg1));
     };
     imports.wbg.__wbg_log_ea240990d83e374e = function(arg0) {
@@ -7216,7 +7666,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_511(a, state0.b, arg0, arg1);
                 } finally {
                     state0.a = a;
                 }
@@ -7316,8 +7766,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_wrapper1647 = function(arg0, arg1, arg2) {
+        const ret = makeMutClosure(arg0, arg1, 40, __wbg_adapter_28);
         return ret;
     };
     imports.wbg.__wbindgen_debug_string = function(arg0, arg1) {

package/package.json

@@ -5,7 +5,7 @@
     "Amari Contributors"
   ],
   "description": "WebAssembly bindings for Amari mathematical computing library - geometric algebra, tropical algebra, automatic differentiation, measure theory, fusion systems, and information geometry",
-  "version": "0.12.3",
+  "version": "0.13.0",
   "license": "MIT OR Apache-2.0",
   "repository": {
     "type": "git",