@justinelliottcobb/amari-wasm 0.12.2 → 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

@@ -877,29 +877,6 @@ export class WasmChowClass {
    */
   multiply(other: WasmChowClass): WasmChowClass;
 }
-/**
- * WASM wrapper for cleanup results
- */
-export class WasmCleanupResult {
-  private constructor();
-  free(): void;
-  /**
-   * Get the cleaned (denoised) value
-   */
-  getCleaned(): WasmTropicalDualClifford;
-  /**
-   * Check if the cleanup converged
-   */
-  didConverge(): boolean;
-  /**
-   * Get the number of iterations used
-   */
-  getIterations(): number;
-  /**
-   * Get the index of the best matching codebook item
-   */
-  getBestMatchIndex(): number;
-}
 /**
  * WASM wrapper for community detection results
  */
@@ -1188,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
  */
@@ -1422,7 +1479,7 @@ export class WasmGrassmannian {
   constructor(k: number, n: number);
 }
 /**
- * WASM wrapper for HolographicMemory
+ * WASM wrapper for HolographicMemory using ProductClifford algebra
  */
 export class WasmHolographicMemory {
   free(): void;
@@ -1430,38 +1487,30 @@ export class WasmHolographicMemory {
    * Get the number of stored items
    */
   itemCount(): number;
-  /**
-   * Batch store multiple key-value pairs
-   */
-  storeBatch(keys: Float64Array, values: Float64Array): void;
   /**
    * Get the estimated SNR (signal-to-noise ratio)
    */
   estimatedSnr(): number;
   /**
-   * Check if memory is near capacity
+   * Generate a random versor (for use as key/value)
    */
-  isNearCapacity(): boolean;
+  static randomVersor(num_factors: number): Float64Array;
   /**
-   * Check if memory probably contains a key
+   * Check if memory is near capacity
    */
-  probablyContains(key: WasmTropicalDualClifford): boolean;
+  isNearCapacity(): boolean;
   /**
    * Create with key tracking enabled (for attribution)
    */
   static withKeyTracking(): WasmHolographicMemory;
   /**
-   * Get the theoretical capacity
+   * Get retrieval confidence for a key
    */
-  theoreticalCapacity(): number;
+  retrieveConfidence(key: Float64Array): number;
   /**
-   * Retrieve with custom temperature
+   * Get capacity information
    */
-  retrieveAtTemperature(key: WasmTropicalDualClifford, beta: number): WasmRetrievalResult;
-  /**
-   * Create with custom bundle temperature
-   */
-  static withBundleTemperature(beta: number): WasmHolographicMemory;
+  theoreticalCapacity(): number;
   /**
    * Create a new holographic memory with default settings
    */
@@ -1471,17 +1520,17 @@ export class WasmHolographicMemory {
    */
   clear(): void;
   /**
-   * Merge another memory into this one
-   */
-  merge(other: WasmHolographicMemory): void;
-  /**
-   * Store a key-value pair in memory
+   * Store a key-value pair in memory (using flat coefficient arrays)
+   *
+   * Each array should have 256 coefficients for ProductCl3x32.
    */
-  store(key: WasmTropicalDualClifford, value: WasmTropicalDualClifford): void;
+  store(key: Float64Array, value: Float64Array): void;
   /**
    * Retrieve a value by key
+   *
+   * Returns the retrieved coefficients as a Float64Array.
    */
-  retrieve(key: WasmTropicalDualClifford): WasmRetrievalResult;
+  retrieve(key: Float64Array): Float64Array;
 }
 /**
  * WASM wrapper for Inverse CA Designer (simplified)
@@ -1567,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
  */
@@ -1987,45 +2079,28 @@ export class WasmRelativisticParticle {
   to_string(): string;
 }
 /**
- * WASM wrapper for Resonator (iterative cleanup)
+ * WASM wrapper for Resonator using ProductClifford algebra
  */
 export class WasmResonator {
   free(): void;
-  /**
-   * Create with custom configuration
-   */
-  static withConfig(codebook_flat: Float64Array, max_iterations: number, convergence_threshold: number): WasmResonator;
   /**
    * Get the codebook size
    */
   codebookSize(): number;
   /**
-   * Create a resonator from a codebook of TDC vectors
-   */
-  constructor(codebook_flat: Float64Array);
-  /**
-   * Clean up a noisy input to find the closest codebook item
+   * Get cleanup result with metadata
    */
-  cleanup(input: WasmTropicalDualClifford): WasmCleanupResult;
-}
-/**
- * WASM wrapper for retrieval results
- */
-export class WasmRetrievalResult {
-  private constructor();
-  free(): void;
+  cleanupWithInfo(input: Float64Array): any;
   /**
-   * Get the retrieval confidence (0 to 1)
-   */
-  getConfidence(): number;
-  /**
-   * Get attribution as arrays of [index, weight] pairs
+   * Create a resonator from a flat codebook array
+   *
+   * Each item should have 256 coefficients for ProductCl3x32.
    */
-  getAttribution(): any;
+  constructor(codebook_flat: Float64Array);
   /**
-   * Get the retrieved value
+   * Clean up a noisy input to find the closest codebook item
    */
-  getValue(): WasmTropicalDualClifford;
+  cleanup(input: Float64Array): Float64Array;
 }
 /**
  * Rotor operations for WASM
@@ -2557,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;
 
@@ -2569,12 +2702,12 @@ export interface InitOutput {
   readonly __wbg_scalarfield_free: (a: number, b: number) => void;
   readonly __wbg_set_wasmtrajectorypoint_time: (a: number, b: number) => void;
   readonly __wbg_wasmchowclass_free: (a: number, b: number) => void;
-  readonly __wbg_wasmcleanupresult_free: (a: number, b: number) => void;
   readonly __wbg_wasmcommunity_free: (a: number, b: number) => void;
   readonly __wbg_wasmduallyflatmanifold_free: (a: number, b: number) => void;
   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;
@@ -2590,7 +2723,6 @@ export interface InitOutput {
   readonly __wbg_wasmpropagationanalysis_free: (a: number, b: number) => void;
   readonly __wbg_wasmrelativisticparticle_free: (a: number, b: number) => void;
   readonly __wbg_wasmresonator_free: (a: number, b: number) => void;
-  readonly __wbg_wasmretrievalresult_free: (a: number, b: number) => void;
   readonly __wbg_wasmschwarzschildmetric_free: (a: number, b: number) => void;
   readonly __wbg_wasmselfassembler_free: (a: number, b: number) => void;
   readonly __wbg_wasmsensitivitymap_free: (a: number, b: number) => void;
@@ -2599,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];
@@ -2705,10 +2838,6 @@ export interface InitOutput {
   readonly wasmchowclass_new: (a: number, b: number) => number;
   readonly wasmchowclass_point: () => number;
   readonly wasmchowclass_power: (a: number, b: number) => number;
-  readonly wasmcleanupresult_didConverge: (a: number) => number;
-  readonly wasmcleanupresult_getBestMatchIndex: (a: number) => number;
-  readonly wasmcleanupresult_getCleaned: (a: number) => number;
-  readonly wasmcleanupresult_getIterations: (a: number) => number;
   readonly wasmcommunity_centroid_coefficients: (a: number) => [number, number];
   readonly wasmcommunity_nodes: (a: number) => [number, number];
   readonly wasmcountingmeasure_isMeasurable: (a: number) => number;
@@ -2761,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];
@@ -2812,15 +2952,12 @@ export interface InitOutput {
   readonly wasmholographicmemory_estimatedSnr: (a: number) => number;
   readonly wasmholographicmemory_isNearCapacity: (a: number) => number;
   readonly wasmholographicmemory_itemCount: (a: number) => number;
-  readonly wasmholographicmemory_merge: (a: number, b: number) => void;
   readonly wasmholographicmemory_new: () => number;
-  readonly wasmholographicmemory_probablyContains: (a: number, b: number) => number;
-  readonly wasmholographicmemory_retrieve: (a: number, b: number) => number;
-  readonly wasmholographicmemory_retrieveAtTemperature: (a: number, b: number, c: number) => number;
-  readonly wasmholographicmemory_store: (a: number, b: number, c: number) => void;
-  readonly wasmholographicmemory_storeBatch: (a: number, b: number, c: number, d: number, e: number) => [number, number];
+  readonly wasmholographicmemory_randomVersor: (a: number) => [number, number];
+  readonly wasmholographicmemory_retrieve: (a: number, b: number, c: number) => [number, number, number, number];
+  readonly wasmholographicmemory_retrieveConfidence: (a: number, b: number, c: number) => [number, number, number];
+  readonly wasmholographicmemory_store: (a: number, b: number, c: number, d: number, e: number) => [number, number];
   readonly wasmholographicmemory_theoreticalCapacity: (a: number) => number;
-  readonly wasmholographicmemory_withBundleTemperature: (a: number) => number;
   readonly wasmholographicmemory_withKeyTracking: () => number;
   readonly wasminversecadesigner_evaluateFitness: (a: number, b: number, c: number) => [number, number, number];
   readonly wasminversecadesigner_findSeed: (a: number, b: number, c: number) => [number, number, number, number];
@@ -2835,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];
@@ -2910,13 +3051,10 @@ export interface InitOutput {
   readonly wasmrelativisticparticle_to_string: (a: number) => [number, number];
   readonly wasmrelativisticparticle_total_energy: (a: number) => number;
   readonly wasmrelativisticparticle_with_energy: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => [number, number, number];
-  readonly wasmresonator_cleanup: (a: number, b: number) => number;
+  readonly wasmresonator_cleanup: (a: number, b: number, c: number) => [number, number, number, number];
+  readonly wasmresonator_cleanupWithInfo: (a: number, b: number, c: number) => [number, number, number];
   readonly wasmresonator_codebookSize: (a: number) => number;
   readonly wasmresonator_new: (a: number, b: number) => [number, number, number];
-  readonly wasmresonator_withConfig: (a: number, b: number, c: number, d: number) => [number, number, number];
-  readonly wasmretrievalresult_getAttribution: (a: number) => [number, number, number];
-  readonly wasmretrievalresult_getConfidence: (a: number) => number;
-  readonly wasmretrievalresult_getValue: (a: number) => number;
   readonly wasmrotor_apply: (a: number, b: number) => number;
   readonly wasmrotor_compose: (a: number, b: number) => number;
   readonly wasmrotor_fromBivector: (a: number, b: number) => number;
@@ -2998,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;
@@ -3053,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;
@@ -3077,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 closure58_externref_shim: (a: number, b: number, c: any) => void;
-  readonly closure49_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;
 }