@justinelliottcobb/amari-wasm 0.9.10 → 0.11.0

package/amari_wasm.d.ts

@@ -1,9 +1,17 @@
 /* tslint:disable */
 /* eslint-disable */
+/**
+ * Initialize the WASM module
+ */
+export function init(): void;
 /**
  * Initialize the enumerative geometry module
  */
 export function initEnumerative(): void;
+/**
+ * Calculate light deflection angle for photon grazing massive object
+ */
+export function light_deflection_angle(impact_parameter: number, mass: number): number;
 /**
  * Convert velocity to Lorentz factor
  */
@@ -16,22 +24,76 @@ export function gamma_to_velocity(gamma: number): number;
  * Validate that this module loaded correctly
  */
 export function validate_relativistic_module(): boolean;
-/**
- * Calculate light deflection angle for photon grazing massive object
- */
-export function light_deflection_angle(impact_parameter: number, mass: number): number;
-/**
- * Initialize the WASM module
- */
-export function init(): void;
 /**
  * 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
  */
@@ -278,6 +340,58 @@ export class InfoGeomUtils {
    */
   static normalize(values: Float64Array): Float64Array;
 }
+/**
+ * Numerical integration operations
+ *
+ * Provides definite integrals, line integrals, and surface integrals
+ * using adaptive quadrature.
+ */
+export class Integration {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Compute 1D definite integral using Simpson's rule
+   *
+   * ∫[a,b] f(x) dx
+   *
+   * # Arguments
+   *
+   * * `func` - JavaScript function to integrate
+   * * `a` - Lower bound
+   * * `b` - Upper bound
+   * * `n` - Number of subdivisions (must be even)
+   *
+   * # Returns
+   *
+   * Integral value
+   *
+   * # JavaScript Example
+   *
+   * ```javascript
+   * // Integrate x^2 from 0 to 1
+   * const result = Integration.integrate1D(x => x*x, 0, 1, 100);
+   * // Returns approximately 0.333...
+   * ```
+   */
+  static integrate1D(func: Function, a: number, b: number, n: number): number;
+  /**
+   * Compute 2D integral over a rectangle using Simpson's rule
+   *
+   * ∫∫[a,b]×[c,d] f(x,y) dx dy
+   *
+   * # Arguments
+   *
+   * * `func` - JavaScript function (x, y) => f(x, y)
+   * * `ax` - Lower x bound
+   * * `bx` - Upper x bound
+   * * `ay` - Lower y bound
+   * * `by` - Upper y bound
+   * * `nx` - Number of x subdivisions (must be even)
+   * * `ny` - Number of y subdivisions (must be even)
+   */
+  static integrate2D(func: Function, ax: number, bx: number, ay: number, by: number, nx: number, ny: number): number;
+}
 /**
  * Advanced machine learning operations using dual numbers
  */
@@ -322,6 +436,92 @@ export class NetworkUtils {
    */
   static createSmallWorldNetwork(num_nodes: number, k: number, beta: number): WasmGeometricNetwork;
 }
+/**
+ * Numerical derivative operations
+ *
+ * Provides gradient, divergence, curl, and Laplacian computations
+ * using centered finite differences.
+ */
+export class NumericalDerivative {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Compute divergence of a vector field at a point
+   *
+   * ∇·F = ∂Fx/∂x + ∂Fy/∂y + ∂Fz/∂z
+   *
+   * # Arguments
+   *
+   * * `field` - Vector field
+   * * `point` - Evaluation point
+   *
+   * # Returns
+   *
+   * Divergence (scalar)
+   */
+  divergence(field: VectorField, point: Float64Array): number;
+  /**
+   * Create a new numerical derivative computer
+   *
+   * # Arguments
+   *
+   * * `step_size` - Optional step size for finite differences (default: 1e-5)
+   */
+  constructor(step_size?: number | null);
+  /**
+   * Compute curl of a 3D vector field at a point
+   *
+   * ∇×F = [∂Fz/∂y - ∂Fy/∂z, ∂Fx/∂z - ∂Fz/∂x, ∂Fy/∂x - ∂Fx/∂y]
+   *
+   * # Arguments
+   *
+   * * `field` - 3D vector field
+   * * `point` - Evaluation point [x, y, z]
+   *
+   * # Returns
+   *
+   * Curl vector [cx, cy, cz]
+   */
+  curl(field: VectorField, point: Float64Array): Float64Array;
+  /**
+   * Compute gradient of a scalar field at a point
+   *
+   * ∇f = [∂f/∂x, ∂f/∂y, ∂f/∂z]
+   *
+   * # Arguments
+   *
+   * * `field` - Scalar field
+   * * `point` - Evaluation point
+   *
+   * # Returns
+   *
+   * Gradient vector
+   *
+   * # JavaScript Example
+   *
+   * ```javascript
+   * const field = ScalarField.fromFunction2D((x, y) => x*x + y*y);
+   * const derivative = new NumericalDerivative();
+   * const grad = derivative.gradient(field, [1.0, 2.0]); // Returns [2.0, 4.0]
+   * ```
+   */
+  gradient(field: ScalarField, point: Float64Array): Float64Array;
+  /**
+   * Compute Laplacian of a scalar field at a point
+   *
+   * ∇²f = ∂²f/∂x² + ∂²f/∂y² + ∂²f/∂z²
+   *
+   * # Arguments
+   *
+   * * `field` - Scalar field
+   * * `point` - Evaluation point
+   *
+   * # Returns
+   *
+   * Laplacian (scalar)
+   */
+  laplacian(field: ScalarField, point: Float64Array): number;
+}
 /**
  * High-performance WASM operations with memory pooling
  */
@@ -346,6 +546,184 @@ export class PerformanceOperations {
    */
   static fastGeometricProduct(lhs: Float64Array, rhs: Float64Array): Float64Array;
 }
+/**
+ * Riemannian manifold with metric tensor
+ *
+ * Represents a curved space with a metric that defines distances and angles.
+ *
+ * # JavaScript Example
+ *
+ * ```javascript
+ * // Create a 2D sphere of radius 1
+ * const sphere = RiemannianManifold.sphere(1.0);
+ *
+ * // Compute scalar curvature at the north pole
+ * const R = sphere.scalarCurvature([0.0, 0.0]); // Returns 2.0 for unit sphere
+ * ```
+ */
+export class RiemannianManifold {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Create a 2D hyperbolic plane (Poincaré half-plane model)
+   *
+   * Metric: ds² = (dx² + dy²) / y²
+   */
+  static hyperbolic(): RiemannianManifold;
+  /**
+   * Compute Christoffel symbol Γ^k_ij at a point
+   *
+   * # Arguments
+   *
+   * * `k` - Upper index
+   * * `i` - First lower index
+   * * `j` - Second lower index
+   * * `coords` - Coordinates
+   */
+  christoffel(k: number, i: number, j: number, coords: Float64Array): number;
+  /**
+   * Compute Ricci tensor component R_ij
+   *
+   * # Arguments
+   *
+   * * `i` - First index
+   * * `j` - Second index
+   * * `coords` - Coordinates
+   */
+  ricciTensor(i: number, j: number, coords: Float64Array): number;
+  /**
+   * Compute Riemann curvature tensor component R^i_jkl
+   *
+   * # Arguments
+   *
+   * * `i` - Upper index
+   * * `j` - First lower index
+   * * `k` - Second lower index
+   * * `l` - Third lower index
+   * * `coords` - Coordinates
+   */
+  riemannTensor(i: number, j: number, k: number, l: number, coords: Float64Array): number;
+  /**
+   * Compute scalar curvature R
+   *
+   * # Arguments
+   *
+   * * `coords` - Coordinates
+   *
+   * # Returns
+   *
+   * Scalar curvature value
+   */
+  scalarCurvature(coords: Float64Array): number;
+  /**
+   * Create a 2D sphere of given radius
+   *
+   * Metric: ds² = dθ² + sin²θ dφ²
+   *
+   * # Arguments
+   *
+   * * `radius` - Sphere radius
+   */
+  static sphere(radius: number): RiemannianManifold;
+  /**
+   * Compute geodesic trajectory
+   *
+   * Solves the geodesic equations using RK4 integration.
+   *
+   * # Arguments
+   *
+   * * `initial_pos` - Initial position
+   * * `initial_vel` - Initial velocity
+   * * `t_max` - Maximum time
+   * * `dt` - Time step
+   *
+   * # Returns
+   *
+   * Flat array of trajectory points and velocities:
+   * [x0, y0, vx0, vy0, x1, y1, vx1, vy1, ...]
+   */
+  geodesic(initial_pos: Float64Array, initial_vel: Float64Array, t_max: number, dt: number): Float64Array;
+  /**
+   * Create a Euclidean (flat) manifold
+   *
+   * # Arguments
+   *
+   * * `dimension` - Dimension (2 or 3)
+   */
+  static euclidean(dimension: number): RiemannianManifold;
+  /**
+   * Get the dimension of the manifold
+   */
+  readonly dimension: number;
+}
+/**
+ * Scalar field f: ℝⁿ → ℝ
+ *
+ * Represents a function that maps points in n-dimensional space to real numbers.
+ *
+ * # JavaScript Example
+ *
+ * ```javascript
+ * // Create a scalar field f(x, y) = x² + y²
+ * const field = WasmScalarField.fromFunction2D((x, y) => x*x + y*y);
+ *
+ * // Evaluate at a point
+ * const value = field.evaluate([1.0, 2.0]); // Returns 5.0
+ * ```
+ */
+export class ScalarField {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Batch evaluate the field at multiple points
+   *
+   * # Arguments
+   *
+   * * `points` - Array of points as flat array [x1, y1, x2, y2, ...]
+   *
+   * # Returns
+   *
+   * Array of field values
+   */
+  batchEvaluate(points: Float64Array): Float64Array;
+  /**
+   * Create a 2D scalar field from a JavaScript function
+   *
+   * # Arguments
+   *
+   * * `func` - JavaScript function (x, y) => f(x, y)
+   */
+  static fromFunction2D(func: Function): ScalarField;
+  /**
+   * Create a 3D scalar field from a JavaScript function
+   *
+   * # Arguments
+   *
+   * * `func` - JavaScript function (x, y, z) => f(x, y, z)
+   */
+  static fromFunction3D(func: Function): ScalarField;
+  /**
+   * Create a 2D scalar field from a JavaScript function
+   *
+   * # Arguments
+   *
+   * * `func` - JavaScript function (x, y) => f(x, y)
+   */
+  constructor(func: Function, dimension: number);
+  /**
+   * Evaluate the scalar field at a point
+   *
+   * # Arguments
+   *
+   * * `point` - Coordinates [x, y] or [x, y, z]
+   *
+   * # Returns
+   *
+   * Field value at the point
+   */
+  evaluate(point: Float64Array): number;
+}
 /**
  * Batch operations for tropical numbers
  */
@@ -390,6 +768,57 @@ export class TropicalMLOps {
    */
   static convexCombination(values: Float64Array, weights: Float64Array): number;
 }
+/**
+ * Vector field F: ℝⁿ → ℝⁿ
+ *
+ * Represents a function that maps points to vectors.
+ *
+ * # JavaScript Example
+ *
+ * ```javascript
+ * // Create a 2D vector field F(x, y) = [y, -x] (rotation)
+ * const field = WasmVectorField.fromFunction2D((x, y) => [y, -x]);
+ *
+ * // Evaluate at a point
+ * const vector = field.evaluate([1.0, 2.0]); // Returns [2.0, -1.0]
+ * ```
+ */
+export class VectorField {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Create a 2D vector field from a JavaScript function
+   *
+   * # Arguments
+   *
+   * * `func` - JavaScript function (x, y) => [fx, fy]
+   */
+  static fromFunction2D(func: Function): VectorField;
+  /**
+   * Create a 3D vector field from a JavaScript function
+   *
+   * # Arguments
+   *
+   * * `func` - JavaScript function (x, y, z) => [fx, fy, fz]
+   */
+  static fromFunction3D(func: Function): VectorField;
+  /**
+   * Create a vector field from a JavaScript function
+   */
+  constructor(func: Function, dimension: number);
+  /**
+   * Evaluate the vector field at a point
+   *
+   * # Arguments
+   *
+   * * `point` - Coordinates [x, y] or [x, y, z]
+   *
+   * # Returns
+   *
+   * Vector at the point
+   */
+  evaluate(point: Float64Array): Float64Array;
+}
 /**
  * WASM wrapper for AlphaConnection
  */
@@ -480,6 +909,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 +1124,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 +1387,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 +1442,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 +1751,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 +2122,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 +2272,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
  */
@@ -1850,24 +2452,27 @@ 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_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_wasmalphaconnection_free: (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_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 +2509,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 +2531,10 @@ 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 integration_integrate1D: (a: any, b: number, c: number, d: number) => [number, number, number];
+  readonly integration_integrate2D: (a: any, b: number, c: number, d: number, e: number, f: number, g: 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];
@@ -1933,10 +2543,29 @@ export interface InitOutput {
   readonly networkutils_clusteringCoefficient: (a: number) => number;
   readonly networkutils_createRandomNetwork: (a: number, b: number) => [number, number, number];
   readonly networkutils_createSmallWorldNetwork: (a: number, b: number, c: number) => [number, number, number];
+  readonly numericalderivative_curl: (a: number, b: number, c: number, d: number) => [number, number, number, number];
+  readonly numericalderivative_divergence: (a: number, b: number, c: number, d: number) => [number, number, number];
+  readonly numericalderivative_gradient: (a: number, b: number, c: number, d: number) => [number, number, number, number];
+  readonly numericalderivative_laplacian: (a: number, b: number, c: number, d: number) => [number, number, number];
+  readonly numericalderivative_new: (a: number, b: number) => number;
   readonly performanceoperations_batchNormalize: (a: number, b: number, c: number) => [number, number];
   readonly performanceoperations_fastGeometricProduct: (a: number, b: number, c: number, d: number) => [number, number];
   readonly performanceoperations_vectorCrossProduct: (a: number, b: number, c: number, d: number) => [number, number];
   readonly performanceoperations_vectorDotProduct: (a: number, b: number, c: number, d: number) => number;
+  readonly riemannianmanifold_christoffel: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number, number];
+  readonly riemannianmanifold_dimension: (a: number) => number;
+  readonly riemannianmanifold_euclidean: (a: number) => [number, number, number];
+  readonly riemannianmanifold_geodesic: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => [number, number, number, number];
+  readonly riemannianmanifold_hyperbolic: () => number;
+  readonly riemannianmanifold_ricciTensor: (a: number, b: number, c: number, d: number, e: number) => [number, number, number];
+  readonly riemannianmanifold_riemannTensor: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => [number, number, number];
+  readonly riemannianmanifold_scalarCurvature: (a: number, b: number, c: number) => [number, number, number];
+  readonly riemannianmanifold_sphere: (a: number) => [number, number, number];
+  readonly scalarfield_batchEvaluate: (a: number, b: number, c: number) => [number, number, number, number];
+  readonly scalarfield_evaluate: (a: number, b: number, c: number) => [number, number, number];
+  readonly scalarfield_fromFunction2D: (a: any) => number;
+  readonly scalarfield_fromFunction3D: (a: any) => number;
+  readonly scalarfield_new: (a: any, b: number) => number;
   readonly tropicalbatch_batchTropicalAdd: (a: number, b: number) => number;
   readonly tropicalbatch_batchTropicalMul: (a: number, b: number) => number;
   readonly tropicalbatch_maxLogProb: (a: number, b: number) => number;
@@ -1945,6 +2574,7 @@ export interface InitOutput {
   readonly tropicalmlops_matrixMultiply: (a: any, b: any) => [number, number, number];
   readonly tropicalmlops_shortestPaths: (a: any) => [number, number, number];
   readonly validate_relativistic_module: () => number;
+  readonly vectorfield_evaluate: (a: number, b: number, c: number) => [number, number, number, number];
   readonly velocity_to_gamma: (a: number) => [number, number, number];
   readonly wasmalphaconnection_getAlpha: (a: number) => number;
   readonly wasmalphaconnection_isExponential: (a: number) => number;
@@ -1962,6 +2592,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 +2632,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 +2684,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 +2693,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;
@@ -2104,10 +2742,21 @@ export interface InitOutput {
   readonly wasmnodemetadata_set_label: (a: number, b: number, c: number) => void;
   readonly wasmnodemetadata_withLabel: (a: number, b: number) => number;
   readonly wasmoptimizationresult_converged: (a: number) => number;
-  readonly wasmoptimizationresult_iterations: (a: number) => number;
   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 +2832,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];
@@ -2206,18 +2858,26 @@ export interface InitOutput {
   readonly wasmtropicalviterbi_forward_probabilities: (a: number, b: number, c: number) => [number, number, number];
   readonly wasmtropicalviterbi_new: (a: any, b: any) => [number, number, number];
   readonly wasmtropicalnumber_new: (a: number) => number;
+  readonly vectorfield_fromFunction2D: (a: any) => number;
+  readonly vectorfield_fromFunction3D: (a: any) => number;
   readonly wasmmultivector_norm: (a: number) => number;
   readonly wasmspacetimevector_t: (a: number) => number;
   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 __wbg_vectorfield_free: (a: number, b: number) => void;
+  readonly vectorfield_new: (a: any, b: number) => number;
   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_iterations: (a: number) => number;
   readonly wasmoptimizationresult_objective_value: (a: number) => number;
   readonly wasmprojectivespace_getDimension: (a: number) => number;
   readonly wasmpropagationanalysis_convergence_time: (a: number) => number;
@@ -2237,30 +2897,37 @@ export interface InitOutput {
   readonly __wbg_fusionbatchoperations_free: (a: number, b: number) => void;
   readonly __wbg_fusionutils_free: (a: number, b: number) => void;
   readonly __wbg_infogeomutils_free: (a: number, b: number) => void;
+  readonly __wbg_integration_free: (a: number, b: number) => void;
   readonly __wbg_mlops_free: (a: number, b: number) => void;
   readonly __wbg_networkutils_free: (a: number, b: number) => void;
   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_wasmalphaconnection_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__h9e55f7f912fc76ac: (a: number, b: number, c: any) => void;
-  readonly wasm_bindgen__closure__destroy__ha65d378aaf4b53b1: (a: number, b: number) => void;
-  readonly wasm_bindgen__convert__closures_____invoke__h04878e576420376d: (a: number, b: number, c: any, d: any) => void;
+  readonly wasmtropicalmeasure_new: () => number;
+  readonly wasm_bindgen_e07ba2a7d21574bf___convert__closures_____invoke___wasm_bindgen_e07ba2a7d21574bf___JsValue_____: (a: number, b: number, c: any) => void;
+  readonly wasm_bindgen_e07ba2a7d21574bf___closure__destroy___dyn_core_a2b7f04d45112077___ops__function__FnMut__wasm_bindgen_e07ba2a7d21574bf___JsValue____Output_______: (a: number, b: number) => void;
+  readonly wasm_bindgen_e07ba2a7d21574bf___convert__closures_____invoke___wasm_bindgen_e07ba2a7d21574bf___JsValue__wasm_bindgen_e07ba2a7d21574bf___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;