@justinelliottcobb/amari-wasm 0.12.3 → 0.14.0

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
  */
@@ -1180,6 +1260,56 @@ export class WasmGeodesicIntegrator {
    */
   static with_schwarzschild(metric: WasmSchwarzschildMetric): WasmGeodesicIntegrator;
 }
+/**
+ * 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 {
+  free(): void;
+  /**
+   * 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]
+   */
+  samplePath(initial: Float64Array, t_end: number, num_steps: number): Float64Array;
+  /**
+   * Compute expected value at time t given initial value
+   *
+   * E[X(t)] = X(0) * exp(μt)
+   */
+  expectedValue(initial: Float64Array, t: number): Float64Array;
+  /**
+   * Create a new Geometric Brownian Motion process
+   *
+   * # Arguments
+   * * `mu` - Drift coefficient (expected growth rate)
+   * * `sigma` - Diffusion coefficient (volatility)
+   */
+  constructor(mu: number, sigma: number);
+  /**
+   * Get drift coefficient
+   */
+  getMu(): number;
+  /**
+   * Compute variance at time t given initial value
+   *
+   * Var(X(t)) = X(0)² * exp(2μt) * (exp(σ²t) - 1)
+   */
+  variance(initial: Float64Array, t: number): Float64Array;
+  /**
+   * Get diffusion coefficient
+   */
+  getSigma(): number;
+}
 /**
  * WASM wrapper for Geometric Cellular Automaton
  */
@@ -1380,6 +1510,50 @@ export class WasmGpuOptimizer {
    */
   constructor();
 }
+/**
+ * WASM wrapper for grade-projected distribution
+ *
+ * A distribution that only operates on components of a specific grade.
+ */
+export class WasmGradeProjectedDistribution {
+  free(): void;
+  /**
+   * Sample and embed into full multivector (other grades are zero)
+   *
+   * Returns 8 coefficients
+   */
+  sampleFull(): Float64Array;
+  /**
+   * Get standard deviations
+   */
+  getStdDevs(): Float64Array;
+  /**
+   * Get number of components in this grade
+   */
+  getNumComponents(): number;
+  /**
+   * 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))
+   */
+  constructor(gaussian: WasmGaussianMultivector, grade: number);
+  /**
+   * Sample from this grade-projected distribution
+   *
+   * Returns components for just this grade
+   */
+  sample(): Float64Array;
+  /**
+   * Get the mean for this grade's components
+   */
+  getMean(): Float64Array;
+  /**
+   * Get the grade
+   */
+  getGrade(): number;
+}
 /**
  * WASM wrapper for Grassmannian varieties
  */
@@ -1505,6 +1679,77 @@ export class WasmLebesgueMeasure {
    */
   constructor(dimension: number);
 }
+/**
+ * WASM wrapper for MCMC diagnostics
+ */
+export class WasmMCMCDiagnostics {
+  private constructor();
+  free(): void;
+  /**
+   * Check if the sampler has converged (R-hat < 1.1)
+   */
+  isConverged(): boolean;
+  /**
+   * Get effective sample size (or -1 if not computed)
+   */
+  getEffectiveSampleSize(): number;
+  /**
+   * Get R-hat statistic (or -1 if not computed)
+   */
+  getRHat(): number;
+  /**
+   * Total number of steps
+   */
+  num_steps: number;
+  /**
+   * Acceptance rate
+   */
+  acceptance_rate: number;
+}
+/**
+ * WASM wrapper for Metropolis-Hastings MCMC sampler
+ *
+ * Samples from a target distribution using random-walk proposals.
+ */
+export class WasmMetropolisHastings {
+  free(): void;
+  /**
+   * Get sampling diagnostics
+   */
+  diagnostics(): WasmMCMCDiagnostics;
+  /**
+   * Get current sample
+   */
+  getCurrent(): Float64Array;
+  /**
+   * Get current acceptance rate
+   */
+  getAcceptanceRate(): number;
+  /**
+   * 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
+   */
+  constructor(target: WasmGaussianMultivector, proposal_std: number);
+  /**
+   * 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)
+   */
+  run(num_samples: number, burnin: number): Float64Array;
+  /**
+   * Take a single MCMC step
+   *
+   * Returns the new sample (8 coefficients)
+   */
+  step(): Float64Array;
+}
 /**
  * WASM wrapper for moduli spaces (simplified)
  */
@@ -1536,6 +1781,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,30 +2797,185 @@ export class WasmTropicalViterbi {
    */
   decode(observations: Uint32Array): any;
 }
+/**
+ * WASM wrapper for uncertain multivector (mean + covariance)
+ *
+ * Represents a multivector with associated uncertainty, useful for
+ * error propagation through geometric operations.
+ */
+export class WasmUncertainMultivector {
+  free(): void;
+  /**
+   * Get standard deviations
+   */
+  getStdDevs(): Float64Array;
+  /**
+   * Create a deterministic (zero variance) uncertain multivector
+   */
+  static deterministic(value: Float64Array): WasmUncertainMultivector;
+  /**
+   * Get variances (diagonal of covariance)
+   */
+  getVariances(): Float64Array;
+  /**
+   * Get the covariance matrix (64 values, row-major)
+   */
+  getCovariance(): Float64Array;
+  /**
+   * Create with full covariance matrix
+   *
+   * # Arguments
+   * * `mean` - 8 coefficients for the mean
+   * * `covariance` - 64 values for 8x8 covariance matrix (row-major)
+   */
+  static withCovariance(mean: Float64Array, covariance: Float64Array): WasmUncertainMultivector;
+  /**
+   * Get total variance (trace of covariance)
+   */
+  getTotalVariance(): number;
+  /**
+   * Add two uncertain multivectors (assuming independence)
+   *
+   * For Z = X + Y: E[Z] = E[X] + E[Y], Var(Z) = Var(X) + Var(Y)
+   */
+  add(other: WasmUncertainMultivector): WasmUncertainMultivector;
+  /**
+   * Create an uncertain multivector with diagonal covariance
+   *
+   * # Arguments
+   * * `mean` - 8 coefficients for the mean
+   * * `variances` - 8 values for per-coefficient variance
+   */
+  constructor(mean: Float64Array, variances: Float64Array);
+  /**
+   * Linear propagation: scale by a constant
+   *
+   * For Y = aX: E[Y] = aE[X], Var(Y) = a²Var(X)
+   */
+  scale(scalar: number): WasmUncertainMultivector;
+  /**
+   * Get the mean
+   */
+  getMean(): Float64Array;
+}
+/**
+ * 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;
+}
+/**
+ * WASM wrapper for Wiener process (Brownian motion)
+ *
+ * Standard Brownian motion W(t) with W(0) = 0
+ */
+export class WasmWienerProcess {
+  free(): void;
+  /**
+   * 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, ...]
+   */
+  samplePath(t_end: number, num_steps: number): Float64Array;
+  /**
+   * Create a new Wiener process
+   *
+   * # Arguments
+   * * `dim` - Dimension of the process (default 8 for multivector space)
+   */
+  constructor(dim?: number | null);
+  /**
+   * Get dimension
+   */
+  getDim(): number;
+}
 
 export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
 
 export interface InitOutput {
   readonly memory: WebAssembly.Memory;
   readonly __wbg_autodiff_free: (a: number, b: number) => void;
-  readonly __wbg_get_wasmtrajectorypoint_time: (a: number) => number;
+  readonly __wbg_get_wasmmcmcdiagnostics_acceptance_rate: (a: number) => number;
+  readonly __wbg_get_wasmmcmcdiagnostics_num_steps: (a: number) => number;
   readonly __wbg_numericalderivative_free: (a: number, b: number) => void;
   readonly __wbg_riemannianmanifold_free: (a: number, b: number) => void;
   readonly __wbg_scalarfield_free: (a: number, b: number) => void;
-  readonly __wbg_set_wasmtrajectorypoint_time: (a: number, b: number) => void;
+  readonly __wbg_set_wasmmcmcdiagnostics_acceptance_rate: (a: number, b: number) => void;
+  readonly __wbg_set_wasmmcmcdiagnostics_num_steps: (a: number, b: number) => void;
   readonly __wbg_wasmchowclass_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;
+  readonly __wbg_wasmgradeprojecteddistribution_free: (a: number, b: number) => void;
   readonly __wbg_wasmgrassmannian_free: (a: number, b: number) => void;
   readonly __wbg_wasmholographicmemory_free: (a: number, b: number) => void;
   readonly __wbg_wasminversecadesigner_free: (a: number, b: number) => void;
   readonly __wbg_wasmlebesguemeasure_free: (a: number, b: number) => void;
+  readonly __wbg_wasmmcmcdiagnostics_free: (a: number, b: number) => void;
+  readonly __wbg_wasmmetropolishastings_free: (a: number, b: number) => void;
   readonly __wbg_wasmmodulispace_free: (a: number, b: number) => void;
   readonly __wbg_wasmmultidualnumber_free: (a: number, b: number) => void;
   readonly __wbg_wasmmultivector_free: (a: number, b: number) => void;
@@ -2541,7 +2984,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_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;
   readonly __wbg_wasmtrajectorypoint_free: (a: number, b: number) => void;
@@ -2549,6 +2991,8 @@ 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_wasmuncertainmultivector_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,8 +3151,22 @@ 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 wasmgeometricbrownianmotion_expectedValue: (a: number, b: number, c: number, d: number) => [number, number, number, number];
+  readonly wasmgeometricbrownianmotion_samplePath: (a: number, b: number, c: number, d: number, e: number) => [number, number, number, number];
+  readonly wasmgeometricbrownianmotion_variance: (a: number, b: number, c: number, d: number) => [number, number, number, number];
   readonly wasmgeometricca_addGlider: (a: number, b: number, c: number) => [number, number];
   readonly wasmgeometricca_addRandomPattern: (a: number, b: number) => [number, number];
   readonly wasmgeometricca_generation: (a: number) => number;
@@ -2751,6 +3209,12 @@ export interface InitOutput {
   readonly wasmgpuoptimizer_isGpuAvailable: (a: number) => number;
   readonly wasmgpuoptimizer_optimizeBatch: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => any;
   readonly wasmgpuoptimizer_optimizeQuadraticGpu: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => any;
+  readonly wasmgradeprojecteddistribution_getMean: (a: number) => [number, number];
+  readonly wasmgradeprojecteddistribution_getNumComponents: (a: number) => number;
+  readonly wasmgradeprojecteddistribution_getStdDevs: (a: number) => [number, number];
+  readonly wasmgradeprojecteddistribution_new: (a: number, b: number) => [number, number, number];
+  readonly wasmgradeprojecteddistribution_sample: (a: number) => [number, number];
+  readonly wasmgradeprojecteddistribution_sampleFull: (a: number) => [number, number];
   readonly wasmgrassmannian_getDimension: (a: number) => number;
   readonly wasmgrassmannian_getParameters: (a: number) => [number, number];
   readonly wasmgrassmannian_new: (a: number, b: number) => [number, number, number];
@@ -2773,11 +3237,24 @@ export interface InitOutput {
   readonly wasmlebesguemeasure_measureBox: (a: number, b: number, c: number) => [number, number, number];
   readonly wasmlebesguemeasure_measureInterval: (a: number, b: number, c: number, d: number, e: number) => [number, number, number];
   readonly wasmlebesguemeasure_new: (a: number) => [number, number, number];
+  readonly wasmmcmcdiagnostics_getEffectiveSampleSize: (a: number) => number;
+  readonly wasmmcmcdiagnostics_getRHat: (a: number) => number;
+  readonly wasmmcmcdiagnostics_isConverged: (a: number) => number;
+  readonly wasmmetropolishastings_diagnostics: (a: number) => number;
+  readonly wasmmetropolishastings_getAcceptanceRate: (a: number) => number;
+  readonly wasmmetropolishastings_getCurrent: (a: number) => [number, number];
+  readonly wasmmetropolishastings_new: (a: number, b: number) => number;
+  readonly wasmmetropolishastings_run: (a: number, b: number, c: number) => [number, number];
+  readonly wasmmetropolishastings_step: (a: number) => [number, number];
   readonly wasmmodulispace_expectedDimension: (a: number) => number;
   readonly wasmmodulispace_getMarkedPoints: (a: number) => number;
   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,9 +3415,32 @@ 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 wasmuncertainmultivector_add: (a: number, b: number) => number;
+  readonly wasmuncertainmultivector_deterministic: (a: number, b: number) => [number, number, number];
+  readonly wasmuncertainmultivector_getCovariance: (a: number) => [number, number];
+  readonly wasmuncertainmultivector_getMean: (a: number) => [number, number];
+  readonly wasmuncertainmultivector_getStdDevs: (a: number) => [number, number];
+  readonly wasmuncertainmultivector_getTotalVariance: (a: number) => number;
+  readonly wasmuncertainmultivector_getVariances: (a: number) => [number, number];
+  readonly wasmuncertainmultivector_new: (a: number, b: number, c: number, d: number) => [number, number, number];
+  readonly wasmuncertainmultivector_scale: (a: number, b: number) => number;
+  readonly wasmuncertainmultivector_withCovariance: (a: number, b: number, c: number, d: number) => [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 wasmwienerprocess_new: (a: number) => number;
+  readonly wasmwienerprocess_samplePath: (a: number, b: number, c: number) => [number, number];
   readonly wasmtropicalnumber_new: (a: number) => number;
   readonly vectorfield_fromFunction2D: (a: any) => number;
   readonly vectorfield_fromFunction3D: (a: any) => number;
+  readonly __wbg_set_wasmtrajectorypoint_time: (a: number, b: number) => void;
   readonly wasmmultivector_norm: (a: number) => number;
   readonly wasmspacetimevector_t: (a: number) => number;
   readonly wasmtropicalnumber_zero: () => number;
@@ -2952,13 +3452,18 @@ export interface InitOutput {
   readonly __wbg_wasmprobabilitymeasure_free: (a: number, b: number) => void;
   readonly __wbg_vectorfield_free: (a: number, b: number) => void;
   readonly vectorfield_new: (a: any, b: number) => number;
+  readonly wasmgeometricbrownianmotion_new: (a: number, b: number) => number;
   readonly wasmtropicalnumber_isZero: (a: number) => number;
   readonly wasmtropicalnumber_tropicalAdd: (a: number, b: number) => number;
+  readonly __wbg_get_wasmtrajectorypoint_time: (a: number) => number;
   readonly wasmcommunity_cohesion_score: (a: number) => number;
   readonly wasmdualnumber_getReal: (a: number) => number;
   readonly wasmevaluationresult_getBestPathScore: (a: number) => number;
   readonly wasmevaluationresult_getGradientNorm: (a: number) => number;
+  readonly wasmgeometricbrownianmotion_getMu: (a: number) => number;
+  readonly wasmgeometricbrownianmotion_getSigma: (a: number) => number;
   readonly wasmgeometricedge_weight: (a: number) => number;
+  readonly wasmgradeprojecteddistribution_getGrade: (a: number) => number;
   readonly wasmmodulispace_getGenus: (a: number) => number;
   readonly wasmmultidualnumber_getReal: (a: number) => number;
   readonly wasmoptimizationresult_iterations: (a: number) => number;
@@ -2972,6 +3477,7 @@ export interface InitOutput {
   readonly wasmtropicalcurve_getGenus: (a: number) => number;
   readonly wasmtropicalnetwork_getSize: (a: number) => number;
   readonly wasmtropicalnumber_getValue: (a: number) => number;
+  readonly wasmwienerprocess_getDim: (a: number) => number;
   readonly __wbg_automatabatchoperations_free: (a: number, b: number) => void;
   readonly __wbg_automatautils_free: (a: number, b: number) => void;
   readonly __wbg_batchoperations_free: (a: number, b: number) => void;
@@ -2991,17 +3497,21 @@ export interface InitOutput {
   readonly __wbg_wasmcountingmeasure_free: (a: number, b: number) => void;
   readonly __wbg_wasmdualnumber_free: (a: number, b: number) => void;
   readonly __wbg_wasmfourvelocity_free: (a: number, b: number) => void;
+  readonly __wbg_wasmgeometricbrownianmotion_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;
   readonly __wbg_wasmrelativisticconstants_free: (a: number, b: number) => void;
+  readonly __wbg_wasmschwarzschildmetric_free: (a: number, b: number) => void;
   readonly __wbg_wasmsimpleoptimizer_free: (a: number, b: number) => void;
   readonly __wbg_wasmspacetimevector_free: (a: number, b: number) => void;
   readonly __wbg_wasmtropicalcurve_free: (a: number, b: number) => void;
   readonly __wbg_wasmtropicalmeasure_free: (a: number, b: number) => void;
   readonly __wbg_wasmtropicalnumber_free: (a: number, b: number) => void;
+  readonly __wbg_wasmwienerprocess_free: (a: number, b: number) => void;
   readonly __wbg_wasmmultiobjectiveresult_free: (a: number, b: number) => void;
   readonly wasmrotor_inverse: (a: number) => number;
   readonly __wbg_wasmrotor_free: (a: number, b: number) => void;
@@ -3017,8 +3527,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;
 }