@justinelliottcobb/amari-wasm 0.9.9 → 0.10.0

package/README.md

@@ -1,4 +1,4 @@
-# @justinelliottcobb/amari-wasm v0.9.8
+# @justinelliottcobb/amari-wasm v0.9.10
 
 **Unified Mathematical Computing Library with High-Precision WebAssembly Support**
 
@@ -15,6 +15,7 @@ Amari is a comprehensive mathematical computing library that brings advanced alg
 - **Geometric Algebra (Clifford Algebra)**: Multivectors, rotors, and geometric products for 3D rotations and spatial transformations
 - **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** *(new in v0.10.0)*: Lebesgue integration, probability measures, and measure-theoretic foundations
 - **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
@@ -186,6 +187,27 @@ for (let i = 0; i < 100; i++) {
 console.log(`Generation: ${ca.generation()}`);
 ```
 
+### Measure Theory and Integration *(new in v0.10.0)*
+
+Perform numerical integration and work with probability measures:
+
+```typescript
+import { WasmLebesgueMeasure, WasmProbabilityMeasure, integrate } from '@justinelliottcobb/amari-wasm';
+
+// Lebesgue measure - compute volumes
+const measure = new WasmLebesgueMeasure(3); // 3D space
+const volume = measure.measureBox([2.0, 3.0, 4.0]); // 2×3×4 box = 24
+
+// Numerical integration
+const f = (x) => x * x; // Function to integrate
+const result = integrate(f, 0, 2, 1000, WasmIntegrationMethod.Riemann);
+console.log(`∫₀² x² dx ≈ ${result}`); // ≈ 2.667
+
+// Probability measures
+const prob = WasmProbabilityMeasure.uniform(0, 1);
+const p = prob.probabilityInterval(0.25, 0.75, 0, 1); // P(0.25 ≤ X ≤ 0.75) = 0.5
+```
+
 ## Use Cases
 
 - Computer Graphics: 3D rotations and transformations using rotors
@@ -193,6 +215,7 @@ console.log(`Generation: ${ca.generation()}`);
 - Machine Learning: Tropical neural networks and automatic differentiation
 - 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
 - Game Development: Efficient spatial transformations and physics
 - Spacecraft Trajectory Planning: High-precision orbital mechanics in web applications
 

package/amari_wasm.d.ts

@@ -1,37 +1,99 @@
 /* tslint:disable */
 /* eslint-disable */
+/**
+ * Initialize the WASM module
+ */
+export function init(): void;
 /**
  * Initialize the enumerative geometry module
  */
 export function initEnumerative(): void;
 /**
- * Validate that this module loaded correctly
+ * Calculate light deflection angle for photon grazing massive object
  */
-export function validate_relativistic_module(): boolean;
+export function light_deflection_angle(impact_parameter: number, mass: number): number;
 /**
  * Convert velocity to Lorentz factor
  */
 export function velocity_to_gamma(velocity_magnitude: number): number;
-/**
- * Calculate light deflection angle for photon grazing massive object
- */
-export function light_deflection_angle(impact_parameter: number, mass: number): number;
 /**
  * Convert Lorentz factor to velocity
  */
 export function gamma_to_velocity(gamma: number): number;
 /**
- * Initialize the WASM module
+ * Validate that this module loaded correctly
  */
-export function init(): void;
+export function validate_relativistic_module(): boolean;
 /**
  * Initialize the fusion module
  */
 export function initFusion(): void;
+/**
+ * Integrate a JavaScript function over an interval
+ *
+ * This function provides numerical integration capabilities to JavaScript.
+ *
+ * # Arguments
+ * * `f` - JavaScript function to integrate (must accept a number and return a number)
+ * * `a` - Lower bound of integration
+ * * `b` - Upper bound of integration
+ * * `points` - Number of sample points to use
+ * * `method` - Integration method to use
+ *
+ * # Returns
+ * Approximate value of the integral ∫_a^b f(x) dx
+ */
+export function integrate(f: Function, a: number, b: number, points: number, method: WasmIntegrationMethod): number;
+/**
+ * Compute expectation E[f(X)] for uniform distribution on [a, b]
+ *
+ * # Arguments
+ * * `f` - JavaScript function (must accept a number and return a number)
+ * * `a` - Lower bound
+ * * `b` - Upper bound
+ * * `samples` - Number of Monte Carlo samples
+ */
+export function expectation(f: Function, a: number, b: number, samples: number): number;
+/**
+ * Compute KL divergence D_KL(P||Q) between two distributions
+ *
+ * # Arguments
+ * * `p_density` - First distribution
+ * * `q_density` - Second distribution
+ * * `p_params` - Parameters for P
+ * * `q_params` - Parameters for Q
+ * * `sample_points` - Points to evaluate at
+ */
+export function klDivergence(p_density: WasmParametricDensity, q_density: WasmParametricDensity, p_params: Float64Array, q_params: Float64Array, sample_points: Float64Array): number;
 /**
  * Initialize the automata module
  */
 export function initAutomata(): void;
+/**
+ * Integration methods available in WASM
+ */
+export enum WasmIntegrationMethod {
+  /**
+   * Riemann sum approximation
+   */
+  Riemann = 0,
+  /**
+   * Monte Carlo integration
+   */
+  MonteCarlo = 1,
+  /**
+   * Trapezoidal rule
+   */
+  Trapezoidal = 2,
+  /**
+   * Simpson's rule
+   */
+  Simpson = 3,
+  /**
+   * Adaptive quadrature
+   */
+  Adaptive = 4,
+}
 /**
  * Automatic differentiation utilities
  */
@@ -480,6 +542,31 @@ export class WasmCommunity {
    */
   readonly nodes: Uint32Array;
 }
+/**
+ * WASM wrapper for counting measure
+ *
+ * The counting measure assigns to each set the number of elements it contains.
+ */
+export class WasmCountingMeasure {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Check if a set is measurable under counting measure
+   * (all sets are measurable under counting measure)
+   */
+  isMeasurable(): boolean;
+  /**
+   * Measure a finite set (returns its cardinality)
+   *
+   * # Arguments
+   * * `set_size` - The number of elements in the set
+   */
+  measureFiniteSet(set_size: number): number;
+  /**
+   * Create a new counting measure
+   */
+  constructor();
+}
 /**
  * WASM wrapper for single-variable dual numbers
  */
@@ -670,6 +757,26 @@ export class WasmFisherInformationMatrix {
    */
   isPositiveDefinite(): boolean;
 }
+/**
+ * Fisher-Riemannian geometry on statistical manifolds
+ */
+export class WasmFisherMeasure {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Create Fisher measure from a parametric density
+   */
+  static fromDensity(density: WasmParametricDensity): WasmFisherMeasure;
+  /**
+   * Compute the Fisher information metric at parameter point θ
+   */
+  fisherMetric(data: Float64Array, params: Float64Array): Float64Array;
+  /**
+   * Compute the Riemannian volume element √det(g(θ))
+   */
+  volumeElement(data: Float64Array, params: Float64Array): number;
+}
 /**
  * WASM wrapper for four-velocity
  */
@@ -913,14 +1020,14 @@ export class WasmGpuOptimizer {
    * Batch optimization with parallel processing simulation
    */
   optimizeBatch(problems_data: Float64Array, problem_size: number, num_problems: number, max_iterations: number, tolerance: number): Promise<Float64Array>;
-  /**
-   * Check if GPU acceleration is available
-   */
-  isGpuAvailable(): boolean;
   /**
    * Optimize a quadratic function with GPU acceleration
    */
   optimizeQuadraticGpu(coefficients: Float64Array, initial_point: Float64Array, max_iterations: number, tolerance: number): Promise<WasmOptimizationResult>;
+  /**
+   * Check if GPU acceleration is available
+   */
+  isGpuAvailable(): boolean;
   /**
    * Create a new GPU optimizer
    */
@@ -968,6 +1075,38 @@ export class WasmInverseCADesigner {
    */
   findSeed(_max_generations: number, max_attempts: number): Float64Array;
 }
+/**
+ * WASM wrapper for Lebesgue measure
+ *
+ * The Lebesgue measure generalizes the notion of length, area, and volume
+ * to higher dimensions and more complex sets.
+ */
+export class WasmLebesgueMeasure {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Compute the measure of a box (hyper-rectangle) with given side lengths
+   */
+  measureBox(sides: Float64Array): number;
+  /**
+   * Get the dimension of this measure
+   */
+  getDimension(): number;
+  /**
+   * Compute the measure of an interval [a, b]
+   *
+   * For 1D: returns length (b - a)
+   * For higher dimensions: returns the product of interval lengths
+   */
+  measureInterval(lower: Float64Array, upper: Float64Array): number;
+  /**
+   * Create a new Lebesgue measure for the specified dimension
+   *
+   * # Arguments
+   * * `dimension` - The dimension of the space (1 for length, 2 for area, 3 for volume, etc.)
+   */
+  constructor(dimension: number);
+}
 /**
  * WASM wrapper for moduli spaces (simplified)
  */
@@ -1245,6 +1384,75 @@ export class WasmOptimizationUtils {
    */
   static dominates(objectives1: Float64Array, objectives2: Float64Array): boolean;
 }
+/**
+ * Parametric probability density families
+ */
+export class WasmParametricDensity {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Create an Exponential density Exp(λ)
+   */
+  static exponential(): WasmParametricDensity;
+  /**
+   * Compute log-density log p(x|θ)
+   */
+  logDensity(x: number, params: Float64Array): number;
+  /**
+   * Compute Fisher information matrix from data samples
+   */
+  fisherInformation(data: Float64Array, params: Float64Array): Float64Array;
+  /**
+   * Create a Cauchy density Cauchy(x₀, γ)
+   */
+  static cauchy(): WasmParametricDensity;
+  /**
+   * Create a Laplace density Laplace(μ, b)
+   */
+  static laplace(): WasmParametricDensity;
+  /**
+   * Evaluate density at point x with parameters
+   *
+   * # Arguments
+   * * `x` - Point to evaluate
+   * * `params` - Parameters (Gaussian: [μ, σ], Exponential: [λ], etc.)
+   */
+  evaluate(x: number, params: Float64Array): number;
+  /**
+   * Create a Gaussian density N(μ, σ²)
+   */
+  static gaussian(): WasmParametricDensity;
+  /**
+   * Compute numerical gradient ∇_θ p(x|θ)
+   */
+  gradient(x: number, params: Float64Array): Float64Array;
+}
+/**
+ * WASM wrapper for probability measures
+ *
+ * A probability measure assigns total measure 1 to the entire space.
+ */
+export class WasmProbabilityMeasure {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Get a description of this probability measure
+   */
+  getDescription(): string;
+  /**
+   * Compute P(X ∈ [a, b]) for uniform distribution
+   */
+  probabilityInterval(a: number, b: number, lower: number, upper: number): number;
+  /**
+   * Create a new uniform probability measure on [0, 1]
+   */
+  constructor();
+  /**
+   * Create a uniform probability measure on [a, b]
+   */
+  static uniform(a: number, b: number): WasmProbabilityMeasure;
+}
 /**
  * WASM wrapper for projective spaces
  */
@@ -1547,14 +1755,14 @@ export class WasmTrajectoryPoint {
   private constructor();
   free(): void;
   [Symbol.dispose](): void;
-  /**
-   * Get position
-   */
-  readonly position: WasmSpacetimeVector;
   /**
    * Time coordinate
    */
   time: number;
+  /**
+   * Get position
+   */
+  readonly position: WasmSpacetimeVector;
 }
 /**
  * WASM wrapper for tropical curves (simplified)
@@ -1697,6 +1905,33 @@ export class WasmTropicalDualDistribution {
    */
   constructor(logits: Float64Array);
 }
+/**
+ * Tropical (max-plus) algebra operations for optimization
+ */
+export class WasmTropicalMeasure {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Tropical integration (supremum over region)
+   */
+  tropicalIntegrate(f: Function, a: number, b: number, samples: number): number;
+  /**
+   * Create a new tropical measure
+   */
+  constructor();
+  /**
+   * Compute tropical infimum (minimum) of function over sample points
+   *
+   * Returns the minimum value and the point where it occurs
+   */
+  infimum(f: Function, points: Float64Array): Float64Array;
+  /**
+   * Compute tropical supremum (maximum) of function over sample points
+   *
+   * Returns the maximum value and the point where it occurs
+   */
+  supremum(f: Function, points: Float64Array): Float64Array;
+}
 /**
  * WASM wrapper for tropical networks
  */
@@ -1857,17 +2092,18 @@ export interface InitOutput {
   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_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_wasmgrassmannian_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_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;
   readonly __wbg_wasmnodemetadata_free: (a: number, b: number) => void;
   readonly __wbg_wasmoptimizationresult_free: (a: number, b: number) => void;
-  readonly __wbg_wasmprojectivespace_free: (a: number, b: number) => void;
   readonly __wbg_wasmpropagationanalysis_free: (a: number, b: number) => void;
   readonly __wbg_wasmrelativisticparticle_free: (a: number, b: number) => void;
   readonly __wbg_wasmschwarzschildmetric_free: (a: number, b: number) => void;
@@ -1904,6 +2140,7 @@ export interface InitOutput {
   readonly enumerativeutils_eulerCharacteristic: (a: number) => number;
   readonly enumerativeutils_expectedRationalCurves: (a: number, b: number) => [number, number, number];
   readonly enumerativeutils_validatePartition: (a: number, b: number, c: number, d: number) => number;
+  readonly expectation: (a: any, b: number, c: number, d: number) => [number, number, number];
   readonly fusionbatchoperations_batchDistance: (a: number, b: number, c: number, d: number, e: number) => [number, number, number, number];
   readonly fusionbatchoperations_batchEvaluate: (a: number, b: number, c: number, d: number, e: number) => [number, number, number, number];
   readonly fusionbatchoperations_batchSensitivity: (a: number, b: number, c: number) => [number, number, number, number];
@@ -1925,6 +2162,8 @@ export interface InitOutput {
   readonly initAutomata: () => void;
   readonly initEnumerative: () => void;
   readonly initFusion: () => void;
+  readonly integrate: (a: any, b: number, c: number, d: number, e: number) => [number, number, number];
+  readonly klDivergence: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => [number, number, number];
   readonly light_deflection_angle: (a: number, b: number) => number;
   readonly mlops_batchActivation: (a: number, b: number, c: number, d: number) => [number, number, number, number];
   readonly mlops_crossEntropyLoss: (a: number, b: number, c: number, d: number) => [number, number, number];
@@ -1962,6 +2201,9 @@ export interface InitOutput {
   readonly wasmchowclass_power: (a: number, b: number) => number;
   readonly wasmcommunity_centroid_coefficients: (a: number) => [number, number];
   readonly wasmcommunity_nodes: (a: number) => [number, number];
+  readonly wasmcountingmeasure_isMeasurable: (a: number) => number;
+  readonly wasmcountingmeasure_measureFiniteSet: (a: number, b: number) => number;
+  readonly wasmcountingmeasure_new: () => number;
   readonly wasmduallyflatmanifold_bregmanDivergence: (a: number, b: number, c: number, d: number, e: number) => number;
   readonly wasmduallyflatmanifold_fisherMetricAt: (a: number, b: number, c: number) => number;
   readonly wasmduallyflatmanifold_jsDivergence: (a: number, b: number, c: number, d: number, e: number) => [number, number, number];
@@ -1999,6 +2241,9 @@ export interface InitOutput {
   readonly wasmfisherinformationmatrix_conditionNumber: (a: number) => number;
   readonly wasmfisherinformationmatrix_getEigenvalues: (a: number) => [number, number];
   readonly wasmfisherinformationmatrix_isPositiveDefinite: (a: number) => number;
+  readonly wasmfishermeasure_fisherMetric: (a: number, b: number, c: number, d: number, e: number) => [number, number, number, number];
+  readonly wasmfishermeasure_fromDensity: (a: number) => number;
+  readonly wasmfishermeasure_volumeElement: (a: number, b: number, c: number, d: number, e: number) => [number, number, number];
   readonly wasmfourvelocity_as_spacetime_vector: (a: number) => number;
   readonly wasmfourvelocity_from_velocity: (a: number, b: number, c: number) => [number, number, number];
   readonly wasmfourvelocity_gamma: (a: number) => number;
@@ -2048,7 +2293,6 @@ export interface InitOutput {
   readonly wasmgeometricnetwork_withCapacity: (a: number, b: number) => number;
   readonly wasmgpuoptimizer_initializeGpu: (a: number) => any;
   readonly wasmgpuoptimizer_isGpuAvailable: (a: number) => number;
-  readonly wasmgpuoptimizer_new: () => 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 wasmgrassmannian_getDimension: (a: number) => number;
@@ -2058,8 +2302,11 @@ export interface InitOutput {
   readonly wasminversecadesigner_findSeed: (a: number, b: number, c: number) => [number, number, number, number];
   readonly wasminversecadesigner_new: (a: number, b: number) => number;
   readonly wasminversecadesigner_setTarget: (a: number, b: number, c: number) => [number, number];
+  readonly wasmlebesguemeasure_getDimension: (a: number) => number;
+  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 wasmmodulispace_expectedDimension: (a: number) => number;
-  readonly wasmmodulispace_getGenus: (a: number) => number;
   readonly wasmmodulispace_getMarkedPoints: (a: number) => number;
   readonly wasmmodulispace_isProper: (a: number) => number;
   readonly wasmmodulispace_ofCurves: (a: number, b: number) => number;
@@ -2108,6 +2355,18 @@ export interface InitOutput {
   readonly wasmoptimizationresult_solution: (a: number) => [number, number];
   readonly wasmoptimizationutils_dominates: (a: number, b: number, c: number, d: number) => number;
   readonly wasmoptimizationutils_numericalGradient: (a: number, b: number, c: number, d: number, e: number) => [number, number, number, number];
+  readonly wasmparametricdensity_cauchy: () => number;
+  readonly wasmparametricdensity_evaluate: (a: number, b: number, c: number, d: number) => [number, number, number];
+  readonly wasmparametricdensity_exponential: () => number;
+  readonly wasmparametricdensity_fisherInformation: (a: number, b: number, c: number, d: number, e: number) => [number, number, number, number];
+  readonly wasmparametricdensity_gaussian: () => number;
+  readonly wasmparametricdensity_gradient: (a: number, b: number, c: number, d: number) => [number, number, number, number];
+  readonly wasmparametricdensity_laplace: () => number;
+  readonly wasmparametricdensity_logDensity: (a: number, b: number, c: number, d: number) => [number, number, number];
+  readonly wasmprobabilitymeasure_getDescription: (a: number) => [number, number];
+  readonly wasmprobabilitymeasure_new: () => number;
+  readonly wasmprobabilitymeasure_probabilityInterval: (a: number, b: number, c: number, d: number, e: number) => number;
+  readonly wasmprobabilitymeasure_uniform: (a: number, b: number) => [number, number, number];
   readonly wasmprojectivespace_bezoutIntersection: (a: number, b: number, c: number) => number;
   readonly wasmprojectivespace_hasDimension: (a: number, b: number) => number;
   readonly wasmprojectivespace_new: (a: number) => number;
@@ -2183,6 +2442,9 @@ export interface InitOutput {
   readonly wasmtropicaldualdistribution_klDivergence: (a: number, b: number) => [number, number, number];
   readonly wasmtropicaldualdistribution_mostLikelySequence: (a: number, b: number) => [number, number];
   readonly wasmtropicaldualdistribution_new: (a: number, b: number) => number;
+  readonly wasmtropicalmeasure_infimum: (a: number, b: any, c: number, d: number) => [number, number, number, number];
+  readonly wasmtropicalmeasure_supremum: (a: number, b: any, c: number, d: number) => [number, number, number, number];
+  readonly wasmtropicalmeasure_tropicalIntegrate: (a: number, b: any, c: number, d: number, e: number) => [number, number, number];
   readonly wasmtropicalnetwork_fromWeights: (a: number, b: number, c: number) => [number, number, number];
   readonly wasmtropicalnetwork_new: (a: number) => number;
   readonly wasmtropicalnetwork_setEdge: (a: number, b: number, c: number, d: number) => [number, number];
@@ -2211,12 +2473,15 @@ export interface InitOutput {
   readonly wasmtropicalnumber_tropicalMul: (a: number, b: number) => number;
   readonly wasmtrajectorypoint_position: (a: number) => number;
   readonly wasmtropicalpolynomial_coefficients_count: (a: number) => number;
+  readonly __wbg_wasmparametricdensity_free: (a: number, b: number) => void;
+  readonly __wbg_wasmprobabilitymeasure_free: (a: number, b: number) => void;
   readonly wasmtropicalnumber_tropicalAdd: (a: number, b: 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 wasmgeometricedge_weight: (a: number) => number;
+  readonly wasmmodulispace_getGenus: (a: number) => number;
   readonly wasmmultidualnumber_getReal: (a: number) => number;
   readonly wasmoptimizationresult_objective_value: (a: number) => number;
   readonly wasmprojectivespace_getDimension: (a: number) => number;
@@ -2242,25 +2507,30 @@ export interface InitOutput {
   readonly __wbg_performanceoperations_free: (a: number, b: number) => void;
   readonly __wbg_tropicalbatch_free: (a: number, b: number) => void;
   readonly __wbg_tropicalmlops_free: (a: number, b: number) => void;
+  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_wasmgeometricedge_free: (a: number, b: number) => void;
   readonly __wbg_wasmgpuoptimizer_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_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_wasmmultiobjectiveresult_free: (a: number, b: number) => void;
   readonly wasmrotor_inverse: (a: number) => number;
   readonly __wbg_wasmrotor_free: (a: number, b: number) => void;
+  readonly wasmgpuoptimizer_new: () => number;
   readonly wasmmultiobjectiveoptimizer_new: () => number;
   readonly wasmsimpleoptimizer_new: () => number;
-  readonly wasm_bindgen__convert__closures_____invoke__h79d0d9c6410c14e7: (a: number, b: number, c: any) => void;
-  readonly wasm_bindgen__closure__destroy__h1dd832fb828dedcc: (a: number, b: number) => void;
-  readonly wasm_bindgen__convert__closures_____invoke__h0bb870c532b1b216: (a: number, b: number, c: any, d: any) => void;
+  readonly wasmtropicalmeasure_new: () => number;
+  readonly wasm_bindgen_83f782f110bf2942___convert__closures_____invoke___wasm_bindgen_83f782f110bf2942___JsValue_____: (a: number, b: number, c: any) => void;
+  readonly wasm_bindgen_83f782f110bf2942___closure__destroy___dyn_core_f622c628fd7f704e___ops__function__FnMut__wasm_bindgen_83f782f110bf2942___JsValue____Output_______: (a: number, b: number) => void;
+  readonly wasm_bindgen_83f782f110bf2942___convert__closures_____invoke___wasm_bindgen_83f782f110bf2942___JsValue__wasm_bindgen_83f782f110bf2942___JsValue_____: (a: number, b: number, c: any, d: any) => void;
   readonly __wbindgen_malloc: (a: number, b: number) => number;
   readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
   readonly __wbindgen_exn_store: (a: number) => void;