@justinelliottcobb/amari-wasm 0.9.1 → 0.9.3

package/amari_wasm.d.ts

@@ -1,9 +1,49 @@
 /* tslint:disable */
 /* eslint-disable */
+/**
+ * Convert velocity to Lorentz factor
+ */
+export function velocity_to_gamma(velocity_magnitude: number): number;
+/**
+ * Convert Lorentz factor to velocity
+ */
+export function gamma_to_velocity(gamma: number): number;
+/**
+ * Calculate light deflection angle for photon grazing massive object
+ */
+export function light_deflection_angle(impact_parameter: number, mass: number): number;
+/**
+ * Validate that this module loaded correctly
+ */
+export function validate_relativistic_module(): boolean;
 /**
  * Initialize the WASM module
  */
 export function init(): void;
+/**
+ * Automatic differentiation utilities
+ */
+export class AutoDiff {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Linear layer forward pass (y = Wx + b) with automatic gradients
+   */
+  static linearLayer(inputs: Float64Array, weights: Float64Array, bias: Float64Array, input_size: number, output_size: number): Float64Array;
+  /**
+   * Compute mean squared error with automatic gradients
+   */
+  static meanSquaredError(predictions: Float64Array, targets: Float64Array): WasmDualNumber;
+  /**
+   * Create a dual number and evaluate a polynomial
+   */
+  static evaluatePolynomial(x: number, coefficients: Float64Array): WasmDualNumber;
+  /**
+   * Compute numerical derivative using finite differences (fallback implementation)
+   */
+  static numericalDerivative(x: number, f: Function, h: number): number;
+}
 /**
  * Batch operations for performance
  */
@@ -21,6 +61,66 @@ export class BatchOperations {
    */
   static batchAdd(a_batch: Float64Array, b_batch: Float64Array): Float64Array;
 }
+/**
+ * Batch operations for efficient computation
+ */
+export class BatchOps {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Matrix multiplication with automatic gradients
+   */
+  static matrixMultiply(a: Float64Array, b: Float64Array, a_rows: number, a_cols: number, b_rows: number, b_cols: number): Float64Array;
+  /**
+   * Batch evaluate polynomial with derivatives
+   */
+  static batchPolynomial(x_values: Float64Array, coefficients: Float64Array): Float64Array;
+  /**
+   * Compute Jacobian matrix for vector function
+   */
+  static computeJacobian(input_values: Float64Array, function_name: string): Float64Array;
+}
+/**
+ * Advanced machine learning operations using dual numbers
+ */
+export class MLOps {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Batch apply activation function with gradients
+   */
+  static batchActivation(inputs: Float64Array, activation: string): Float64Array;
+  /**
+   * Compute cross-entropy loss with automatic gradients
+   */
+  static crossEntropyLoss(predictions: Float64Array, targets: Float64Array): WasmDualNumber;
+  /**
+   * Gradient descent step
+   */
+  static gradientDescentStep(parameters: Float64Array, gradients: Float64Array, learning_rate: number): Float64Array;
+  /**
+   * Compute softmax with automatic gradients
+   */
+  static softmax(inputs: Float64Array): Float64Array;
+}
+/**
+ * Batch network operations for performance
+ */
+export class NetworkBatchOperations {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Fast geometric clustering using k-means in 3D space
+   */
+  static geometricKMeansClustering(positions: Float64Array, num_nodes: number, k: number, max_iterations: number): Uint32Array;
+  /**
+   * Compute all pairwise distances in a network
+   */
+  static computeAllPairwiseDistances(positions: Float64Array, num_nodes: number): Float64Array;
+}
 /**
  * High-performance WASM operations with memory pooling
  */
@@ -45,6 +145,329 @@ export class PerformanceOperations {
    */
   static fastGeometricProduct(lhs: Float64Array, rhs: Float64Array): Float64Array;
 }
+/**
+ * Batch operations for tropical numbers
+ */
+export class TropicalBatch {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Convert array of log probabilities to tropical numbers and find maximum
+   */
+  static maxLogProb(log_probs: Float64Array): number;
+  /**
+   * Viterbi algorithm helper: find best path through trellis
+   */
+  static viterbiStep(prev_scores: Float64Array, transition_scores: Float64Array, emission_scores: Float64Array, num_states: number): Float64Array;
+  /**
+   * Batch tropical addition (max operation)
+   */
+  static batchTropicalAdd(values: Float64Array): number;
+  /**
+   * Batch tropical multiplication (addition)
+   */
+  static batchTropicalMul(values: Float64Array): number;
+}
+/**
+ * Advanced tropical operations for machine learning and optimization
+ */
+export class TropicalMLOps {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Compute shortest paths using tropical algebra (Floyd-Warshall)
+   */
+  static shortestPaths(distance_matrix: any): Array<any>;
+  /**
+   * Compute tropical matrix multiplication for pathfinding
+   */
+  static matrixMultiply(a: any, b: any): Array<any>;
+  /**
+   * Compute tropical convex combination (used in optimization)
+   */
+  static convexCombination(values: Float64Array, weights: Float64Array): number;
+}
+/**
+ * WASM wrapper for single-variable dual numbers
+ */
+export class WasmDualNumber {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Natural logarithm
+   */
+  ln(): WasmDualNumber;
+  /**
+   * Addition
+   */
+  add(other: WasmDualNumber): WasmDualNumber;
+  /**
+   * Cosine function
+   */
+  cos(): WasmDualNumber;
+  /**
+   * Division
+   */
+  div(other: WasmDualNumber): WasmDualNumber;
+  /**
+   * Exponential function
+   */
+  exp(): WasmDualNumber;
+  /**
+   * Maximum of two dual numbers
+   */
+  max(other: WasmDualNumber): WasmDualNumber;
+  /**
+   * Minimum of two dual numbers
+   */
+  min(other: WasmDualNumber): WasmDualNumber;
+  /**
+   * Multiplication
+   */
+  mul(other: WasmDualNumber): WasmDualNumber;
+  /**
+   * Negation
+   */
+  neg(): WasmDualNumber;
+  /**
+   * Create a new dual number with given real and dual parts
+   */
+  constructor(real: number, dual: number);
+  /**
+   * Power function
+   */
+  pow(exponent: number): WasmDualNumber;
+  /**
+   * Sine function
+   */
+  sin(): WasmDualNumber;
+  /**
+   * Subtraction
+   */
+  sub(other: WasmDualNumber): WasmDualNumber;
+  /**
+   * Tangent function
+   */
+  tan(): WasmDualNumber;
+  /**
+   * Hyperbolic cosine
+   */
+  cosh(): WasmDualNumber;
+  /**
+   * Integer power
+   */
+  powi(n: number): WasmDualNumber;
+  /**
+   * ReLU activation function
+   */
+  relu(): WasmDualNumber;
+  /**
+   * Hyperbolic sine
+   */
+  sinh(): WasmDualNumber;
+  /**
+   * Square root
+   */
+  sqrt(): WasmDualNumber;
+  /**
+   * Hyperbolic tangent
+   */
+  tanh(): WasmDualNumber;
+  /**
+   * Sigmoid activation function
+   */
+  sigmoid(): WasmDualNumber;
+  /**
+   * Create a constant (derivative = 0)
+   */
+  static constant(value: number): WasmDualNumber;
+  /**
+   * Get the dual part (derivative)
+   */
+  getDual(): number;
+  /**
+   * Get the real part (function value)
+   */
+  getReal(): number;
+  /**
+   * Softplus activation function
+   */
+  softplus(): WasmDualNumber;
+  /**
+   * Create a variable (derivative = 1)
+   */
+  static variable(value: number): WasmDualNumber;
+}
+/**
+ * WASM wrapper for four-velocity
+ */
+export class WasmFourVelocity {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Create four-velocity from 3-velocity components
+   */
+  static from_velocity(vx: number, vy: number, vz: number): WasmFourVelocity;
+  /**
+   * Check if normalized (u·u = c²)
+   */
+  is_normalized(): boolean;
+  /**
+   * Get as spacetime vector
+   */
+  as_spacetime_vector(): WasmSpacetimeVector;
+  /**
+   * Get spatial velocity magnitude
+   */
+  spatial_velocity_magnitude(): number;
+  /**
+   * Get Lorentz factor γ
+   */
+  gamma(): number;
+  /**
+   * Get rapidity
+   */
+  rapidity(): number;
+  /**
+   * Get string representation
+   */
+  to_string(): string;
+}
+/**
+ * WASM wrapper for geodesic integration
+ */
+export class WasmGeodesicIntegrator {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Propagate particle through spacetime
+   */
+  propagate_particle(particle: WasmRelativisticParticle, integration_time: number, time_step: number): Array<any>;
+  /**
+   * Create integrator with Schwarzschild metric
+   */
+  static with_schwarzschild(metric: WasmSchwarzschildMetric): WasmGeodesicIntegrator;
+}
+/**
+ * WASM wrapper for GeometricNetwork
+ */
+export class WasmGeometricNetwork {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Get degree of a node
+   */
+  getDegree(node: number): number;
+  /**
+   * Get neighbors of a node
+   */
+  getNeighbors(node: number): Uint32Array;
+  /**
+   * Find shortest path between two nodes
+   * Returns the path as an array of node indices, or null if no path exists
+   */
+  shortestPath(source: number, target: number): Uint32Array | undefined;
+  /**
+   * Add a labeled node
+   */
+  addLabeledNode(x: number, y: number, z: number, label: string): number;
+  /**
+   * Find communities using geometric clustering
+   */
+  findCommunities(num_communities: number): Uint32Array;
+  /**
+   * Get node position as [x, y, z]
+   */
+  getNodePosition(node: number): Float64Array | undefined;
+  /**
+   * Compute geometric distance between two nodes
+   */
+  geometricDistance(node1: number, node2: number): number;
+  /**
+   * Add an undirected edge
+   */
+  addUndirectedEdge(a: number, b: number, weight: number): void;
+  /**
+   * Find shortest path with distance between two nodes
+   * Returns an object with path and distance, or null if no path exists
+   */
+  shortestPathWithDistance(source: number, target: number): any;
+  /**
+   * Compute geometric centrality for all nodes
+   */
+  computeGeometricCentrality(): Float64Array;
+  /**
+   * Create a new geometric network
+   */
+  constructor();
+  /**
+   * Add an edge between two nodes
+   */
+  addEdge(source: number, target: number, weight: number): void;
+  /**
+   * Add a node at the given position
+   */
+  addNode(x: number, y: number, z: number): number;
+  /**
+   * Get number of edges
+   */
+  numEdges(): number;
+  /**
+   * Get number of nodes
+   */
+  numNodes(): number;
+}
+/**
+ * WASM wrapper for multi-variable dual numbers
+ */
+export class WasmMultiDualNumber {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Get a specific partial derivative
+   */
+  getPartial(index: number): number;
+  /**
+   * Get the gradient (all partial derivatives)
+   */
+  getGradient(): Float64Array;
+  /**
+   * Get number of variables
+   */
+  getNumVars(): number;
+  /**
+   * Addition
+   */
+  add(other: WasmMultiDualNumber): WasmMultiDualNumber;
+  /**
+   * Multiplication
+   */
+  mul(other: WasmMultiDualNumber): WasmMultiDualNumber;
+  /**
+   * Create a new multi-dual number
+   */
+  constructor(real: number, duals: Float64Array);
+  /**
+   * Square root
+   */
+  sqrt(): WasmMultiDualNumber;
+  /**
+   * Create a constant (all derivatives are zero)
+   */
+  static constant(value: number, num_vars: number): WasmMultiDualNumber;
+  /**
+   * Get the real part (function value)
+   */
+  getReal(): number;
+  /**
+   * Create a variable with derivative 1 at the specified index
+   */
+  static variable(value: number, num_vars: number, var_index: number): WasmMultiDualNumber;
+}
 /**
  * WASM wrapper for Multivector with TypedArray support
  */
@@ -136,6 +559,81 @@ export class WasmMultivector {
    */
   normalize(): WasmMultivector;
 }
+/**
+ * Physical constants
+ */
+export class WasmRelativisticConstants {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Earth mass (kg)
+   */
+  static readonly earth_mass: number;
+  /**
+   * Solar mass (kg)
+   */
+  static readonly solar_mass: number;
+  /**
+   * Speed of light in vacuum (m/s)
+   */
+  static readonly speed_of_light: number;
+  /**
+   * Gravitational constant (m³/kg·s²)
+   */
+  static readonly gravitational_constant: number;
+}
+/**
+ * WASM wrapper for relativistic particles
+ */
+export class WasmRelativisticParticle {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Get 3D position components
+   */
+  position_3d(): Array<any>;
+  /**
+   * Get position as spacetime vector
+   */
+  position_4d(): WasmSpacetimeVector;
+  /**
+   * Create particle with specified energy
+   */
+  static with_energy(x: number, y: number, z: number, direction_x: number, direction_y: number, direction_z: number, kinetic_energy: number, mass: number, charge: number): WasmRelativisticParticle;
+  /**
+   * Get total energy
+   */
+  total_energy(): number;
+  /**
+   * Get four-velocity
+   */
+  four_velocity(): WasmFourVelocity;
+  /**
+   * Get kinetic energy
+   */
+  kinetic_energy(): number;
+  /**
+   * Get momentum magnitude
+   */
+  momentum_magnitude(): number;
+  /**
+   * Create a new relativistic particle
+   */
+  constructor(x: number, y: number, z: number, vx: number, vy: number, vz: number, spin: number, mass: number, charge: number);
+  /**
+   * Get rest mass
+   */
+  mass(): number;
+  /**
+   * Get electric charge
+   */
+  charge(): number;
+  /**
+   * Get string representation
+   */
+  to_string(): string;
+}
 /**
  * Rotor operations for WASM
  */
@@ -160,20 +658,342 @@ export class WasmRotor {
    */
   inverse(): WasmRotor;
 }
+/**
+ * WASM wrapper for Schwarzschild metric
+ */
+export class WasmSchwarzschildMetric {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Check for singularity at given position
+   */
+  has_singularity(position: WasmSpacetimeVector): boolean;
+  /**
+   * Compute effective potential for circular orbits
+   */
+  effective_potential(r: number, angular_momentum: number): number;
+  /**
+   * Get Schwarzschild radius
+   */
+  schwarzschild_radius(): number;
+  /**
+   * Create Schwarzschild metric for the Sun
+   */
+  static sun(): WasmSchwarzschildMetric;
+  /**
+   * Get central mass
+   */
+  mass(): number;
+  /**
+   * Create Schwarzschild metric for Earth
+   */
+  static earth(): WasmSchwarzschildMetric;
+  /**
+   * Create Schwarzschild metric for custom mass
+   */
+  static from_mass(mass: number): WasmSchwarzschildMetric;
+}
+/**
+ * WASM wrapper for spacetime vectors
+ */
+export class WasmSpacetimeVector {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Check if vector is timelike (massive particle)
+   */
+  is_timelike(): boolean;
+  /**
+   * Check if vector is spacelike
+   */
+  is_spacelike(): boolean;
+  /**
+   * Compute Minkowski norm squared
+   */
+  norm_squared(): number;
+  /**
+   * Compute Minkowski inner product with another spacetime vector
+   */
+  minkowski_dot(other: WasmSpacetimeVector): number;
+  /**
+   * Create a new spacetime vector with components (ct, x, y, z)
+   */
+  constructor(t: number, x: number, y: number, z: number);
+  /**
+   * Check if vector is null (lightlike)
+   */
+  is_null(): boolean;
+  /**
+   * Create a timelike vector
+   */
+  static timelike(t: number): WasmSpacetimeVector;
+  /**
+   * Create a spacelike vector
+   */
+  static spacelike(x: number, y: number, z: number): WasmSpacetimeVector;
+  /**
+   * Get string representation
+   */
+  to_string(): string;
+  /**
+   * Get temporal component
+   */
+  readonly t: number;
+  /**
+   * Get x component
+   */
+  readonly x: number;
+  /**
+   * Get y component
+   */
+  readonly y: number;
+  /**
+   * Get z component
+   */
+  readonly z: number;
+}
+/**
+ * Trajectory point for particle propagation
+ */
+export class WasmTrajectoryPoint {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Get position
+   */
+  readonly position: WasmSpacetimeVector;
+  /**
+   * Time coordinate
+   */
+  time: number;
+}
+/**
+ * WASM wrapper for TropicalNumber
+ */
+export class WasmTropicalNumber {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Check if this is infinite
+   */
+  isInfinity(): boolean;
+  /**
+   * Tropical addition (max operation)
+   */
+  tropicalAdd(other: WasmTropicalNumber): WasmTropicalNumber;
+  /**
+   * Tropical multiplication (addition)
+   */
+  tropicalMul(other: WasmTropicalNumber): WasmTropicalNumber;
+  /**
+   * Tropical power (scalar multiplication)
+   */
+  tropicalPow(n: number): WasmTropicalNumber;
+  /**
+   * Create from log probability
+   */
+  static fromLogProb(log_p: number): WasmTropicalNumber;
+  /**
+   * Standard addition (for convenience)
+   */
+  add(other: WasmTropicalNumber): WasmTropicalNumber;
+  /**
+   * Standard multiplication (for convenience)
+   */
+  mul(other: WasmTropicalNumber): WasmTropicalNumber;
+  /**
+   * Negation
+   */
+  neg(): WasmTropicalNumber;
+  /**
+   * Create a new tropical number from a regular number
+   */
+  constructor(value: number);
+  /**
+   * Create tropical one (regular zero)
+   */
+  static one(): WasmTropicalNumber;
+  /**
+   * Create tropical zero (negative infinity)
+   */
+  static zero(): WasmTropicalNumber;
+  /**
+   * Check if this is tropical one (zero)
+   */
+  isOne(): boolean;
+  /**
+   * Check if this is tropical zero (negative infinity)
+   */
+  isZero(): boolean;
+  /**
+   * Convert to probability (via exp)
+   */
+  toProb(): number;
+  /**
+   * Get the underlying value
+   */
+  getValue(): number;
+}
+/**
+ * WASM wrapper for TropicalPolynomial - polynomial operations in tropical algebra
+ */
+export class WasmTropicalPolynomial {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Find tropical roots of the polynomial
+   */
+  tropical_roots(): Array<any>;
+  /**
+   * Get the number of coefficients
+   */
+  coefficients_count(): number;
+  /**
+   * Create a new tropical polynomial from coefficients
+   */
+  constructor(coefficients: Float64Array);
+  /**
+   * Evaluate the polynomial at a given tropical number
+   */
+  evaluate(x: WasmTropicalNumber): WasmTropicalNumber;
+}
+/**
+ * WASM wrapper for TropicalViterbi - Hidden Markov Model decoding
+ */
+export class WasmTropicalViterbi {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Compute forward probabilities for all states
+   */
+  forward_probabilities(observations: Uint32Array): Array<any>;
+  /**
+   * Create a new Viterbi decoder
+   *
+   * # Arguments
+   * * `transitions` - Transition probability matrix (2D array)
+   * * `emissions` - Emission probability matrix (2D array)
+   */
+  constructor(transitions: any, emissions: any);
+  /**
+   * Decode the most likely state sequence for given observations
+   *
+   * Returns an object with `states` (array of state indices) and `probability` (log probability)
+   */
+  decode(observations: Uint32Array): any;
+}
 
 export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
 
 export interface InitOutput {
   readonly memory: WebAssembly.Memory;
-  readonly __wbg_batchoperations_free: (a: number, b: number) => void;
+  readonly __wbg_autodiff_free: (a: number, b: number) => void;
+  readonly __wbg_get_wasmtrajectorypoint_time: (a: number) => number;
+  readonly __wbg_set_wasmtrajectorypoint_time: (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_wasmgeodesicintegrator_free: (a: number, b: number) => void;
+  readonly __wbg_wasmgeometricnetwork_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_wasmrelativisticparticle_free: (a: number, b: number) => void;
+  readonly __wbg_wasmschwarzschildmetric_free: (a: number, b: number) => void;
+  readonly __wbg_wasmtrajectorypoint_free: (a: number, b: number) => void;
+  readonly __wbg_wasmtropicalnumber_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 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];
+  readonly autodiff_numericalDerivative: (a: number, b: any, c: number) => [number, number, number];
   readonly batchoperations_batchAdd: (a: number, b: number, c: number, d: number) => [number, number, number, number];
   readonly batchoperations_batchGeometricProduct: (a: number, b: number, c: number, d: number) => [number, number, number, number];
+  readonly batchops_batchPolynomial: (a: number, b: number, c: number, d: number) => [number, number, number, number];
+  readonly batchops_computeJacobian: (a: number, b: number, c: number, d: number) => [number, number, number, number];
+  readonly batchops_matrixMultiply: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => [number, number, number, number];
+  readonly gamma_to_velocity: (a: number) => [number, number, number];
   readonly init: () => void;
+  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];
+  readonly mlops_gradientDescentStep: (a: number, b: number, c: number, d: number, e: number) => [number, number, number, number];
+  readonly mlops_softmax: (a: number, b: number) => [number, number];
+  readonly networkbatchoperations_computeAllPairwiseDistances: (a: number, b: number, c: number) => [number, number, number, number];
+  readonly networkbatchoperations_geometricKMeansClustering: (a: number, b: number, c: number, d: number, e: number) => [number, number, 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 tropicalbatch_batchTropicalAdd: (a: number, b: number) => number;
+  readonly tropicalbatch_batchTropicalMul: (a: number, b: number) => number;
+  readonly tropicalbatch_maxLogProb: (a: number, b: number) => number;
+  readonly tropicalbatch_viterbiStep: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => [number, number, number, number];
+  readonly tropicalmlops_convexCombination: (a: number, b: number, c: number, d: number) => [number, number, number];
+  readonly tropicalmlops_matrixMultiply: (a: any, b: any) => [number, number, number];
+  readonly tropicalmlops_shortestPaths: (a: any) => [number, number, number];
+  readonly validate_relativistic_module: () => number;
+  readonly velocity_to_gamma: (a: number) => [number, number, number];
+  readonly wasmdualnumber_add: (a: number, b: number) => number;
+  readonly wasmdualnumber_constant: (a: number) => number;
+  readonly wasmdualnumber_cos: (a: number) => number;
+  readonly wasmdualnumber_cosh: (a: number) => number;
+  readonly wasmdualnumber_div: (a: number, b: number) => [number, number, number];
+  readonly wasmdualnumber_exp: (a: number) => number;
+  readonly wasmdualnumber_getDual: (a: number) => number;
+  readonly wasmdualnumber_getReal: (a: number) => number;
+  readonly wasmdualnumber_ln: (a: number) => [number, number, number];
+  readonly wasmdualnumber_max: (a: number, b: number) => number;
+  readonly wasmdualnumber_min: (a: number, b: number) => number;
+  readonly wasmdualnumber_mul: (a: number, b: number) => number;
+  readonly wasmdualnumber_neg: (a: number) => number;
+  readonly wasmdualnumber_new: (a: number, b: number) => number;
+  readonly wasmdualnumber_pow: (a: number, b: number) => number;
+  readonly wasmdualnumber_powi: (a: number, b: number) => number;
+  readonly wasmdualnumber_relu: (a: number) => number;
+  readonly wasmdualnumber_sigmoid: (a: number) => number;
+  readonly wasmdualnumber_sin: (a: number) => number;
+  readonly wasmdualnumber_sinh: (a: number) => number;
+  readonly wasmdualnumber_softplus: (a: number) => number;
+  readonly wasmdualnumber_sqrt: (a: number) => [number, number, number];
+  readonly wasmdualnumber_sub: (a: number, b: number) => number;
+  readonly wasmdualnumber_tan: (a: number) => number;
+  readonly wasmdualnumber_tanh: (a: number) => number;
+  readonly wasmdualnumber_variable: (a: 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;
+  readonly wasmfourvelocity_is_normalized: (a: number) => number;
+  readonly wasmfourvelocity_rapidity: (a: number) => number;
+  readonly wasmfourvelocity_spatial_velocity_magnitude: (a: number) => number;
+  readonly wasmfourvelocity_to_string: (a: 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 wasmgeometricnetwork_addEdge: (a: number, b: number, c: number, d: number) => [number, number];
+  readonly wasmgeometricnetwork_addLabeledNode: (a: number, b: number, c: number, d: number, e: number, f: number) => number;
+  readonly wasmgeometricnetwork_addNode: (a: number, b: number, c: number, d: number) => number;
+  readonly wasmgeometricnetwork_addUndirectedEdge: (a: number, b: number, c: number, d: number) => [number, number];
+  readonly wasmgeometricnetwork_computeGeometricCentrality: (a: number) => [number, number, number, number];
+  readonly wasmgeometricnetwork_findCommunities: (a: number, b: number) => [number, number, number, number];
+  readonly wasmgeometricnetwork_geometricDistance: (a: number, b: number, c: number) => [number, number, number];
+  readonly wasmgeometricnetwork_getDegree: (a: number, b: number) => number;
+  readonly wasmgeometricnetwork_getNeighbors: (a: number, b: number) => [number, number];
+  readonly wasmgeometricnetwork_getNodePosition: (a: number, b: number) => [number, number];
+  readonly wasmgeometricnetwork_new: () => number;
+  readonly wasmgeometricnetwork_numEdges: (a: number) => number;
+  readonly wasmgeometricnetwork_numNodes: (a: number) => number;
+  readonly wasmgeometricnetwork_shortestPath: (a: number, b: number, c: number) => [number, number, number, number];
+  readonly wasmgeometricnetwork_shortestPathWithDistance: (a: number, b: number, c: 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];
+  readonly wasmmultidualnumber_getNumVars: (a: number) => number;
+  readonly wasmmultidualnumber_getPartial: (a: number, b: number) => [number, number, number];
+  readonly wasmmultidualnumber_mul: (a: number, b: number) => [number, number, number];
+  readonly wasmmultidualnumber_new: (a: number, b: number, c: number) => number;
+  readonly wasmmultidualnumber_sqrt: (a: number) => [number, number, number];
+  readonly wasmmultidualnumber_variable: (a: number, b: number, c: number) => number;
   readonly wasmmultivector_add: (a: number, b: number) => number;
   readonly wasmmultivector_basisVector: (a: number) => [number, number, number];
   readonly wasmmultivector_exp: (a: number) => number;
@@ -194,15 +1014,85 @@ export interface InitOutput {
   readonly wasmmultivector_scale: (a: number, b: number) => number;
   readonly wasmmultivector_setCoefficient: (a: number, b: number, c: number) => void;
   readonly wasmmultivector_sub: (a: number, b: number) => number;
+  readonly wasmrelativisticconstants_earth_mass: () => number;
+  readonly wasmrelativisticconstants_gravitational_constant: () => number;
+  readonly wasmrelativisticconstants_solar_mass: () => number;
+  readonly wasmrelativisticconstants_speed_of_light: () => number;
+  readonly wasmrelativisticparticle_charge: (a: number) => number;
+  readonly wasmrelativisticparticle_four_velocity: (a: number) => number;
+  readonly wasmrelativisticparticle_kinetic_energy: (a: number) => number;
+  readonly wasmrelativisticparticle_mass: (a: number) => number;
+  readonly wasmrelativisticparticle_momentum_magnitude: (a: number) => number;
+  readonly wasmrelativisticparticle_new: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => [number, number, number];
+  readonly wasmrelativisticparticle_position_3d: (a: number) => any;
+  readonly wasmrelativisticparticle_position_4d: (a: number) => number;
+  readonly wasmrelativisticparticle_to_string: (a: number) => [number, number];
+  readonly wasmrelativisticparticle_total_energy: (a: number) => number;
+  readonly wasmrelativisticparticle_with_energy: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => [number, number, number];
   readonly wasmrotor_apply: (a: number, b: number) => number;
   readonly wasmrotor_compose: (a: number, b: number) => number;
   readonly wasmrotor_fromBivector: (a: number, b: number) => number;
+  readonly wasmschwarzschildmetric_earth: () => number;
+  readonly wasmschwarzschildmetric_effective_potential: (a: number, b: number, c: number) => number;
+  readonly wasmschwarzschildmetric_from_mass: (a: number) => number;
+  readonly wasmschwarzschildmetric_has_singularity: (a: number, b: number) => number;
+  readonly wasmschwarzschildmetric_schwarzschild_radius: (a: number) => number;
+  readonly wasmschwarzschildmetric_sun: () => number;
+  readonly wasmspacetimevector_is_null: (a: number) => number;
+  readonly wasmspacetimevector_is_spacelike: (a: number) => number;
+  readonly wasmspacetimevector_is_timelike: (a: number) => number;
+  readonly wasmspacetimevector_minkowski_dot: (a: number, b: number) => number;
+  readonly wasmspacetimevector_new: (a: number, b: number, c: number, d: number) => number;
+  readonly wasmspacetimevector_norm_squared: (a: number) => number;
+  readonly wasmspacetimevector_spacelike: (a: number, b: number, c: number) => number;
+  readonly wasmspacetimevector_timelike: (a: number) => number;
+  readonly wasmspacetimevector_to_string: (a: number) => [number, number];
+  readonly wasmspacetimevector_y: (a: number) => number;
+  readonly wasmspacetimevector_z: (a: number) => number;
+  readonly wasmtropicalnumber_add: (a: number, b: number) => number;
+  readonly wasmtropicalnumber_fromLogProb: (a: number) => number;
+  readonly wasmtropicalnumber_isInfinity: (a: number) => number;
+  readonly wasmtropicalnumber_isOne: (a: number) => number;
+  readonly wasmtropicalnumber_isZero: (a: number) => number;
+  readonly wasmtropicalnumber_mul: (a: number, b: number) => number;
+  readonly wasmtropicalnumber_neg: (a: number) => number;
+  readonly wasmtropicalnumber_one: () => number;
+  readonly wasmtropicalnumber_toProb: (a: number) => number;
+  readonly wasmtropicalnumber_tropicalPow: (a: number, b: number) => number;
+  readonly wasmtropicalnumber_zero: () => number;
+  readonly wasmtropicalpolynomial_coefficients_count: (a: number) => number;
+  readonly wasmtropicalpolynomial_evaluate: (a: number, b: number) => number;
+  readonly wasmtropicalpolynomial_new: (a: number, b: number) => number;
+  readonly wasmtropicalpolynomial_tropical_roots: (a: number) => any;
+  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 wasmtropicalnumber_new: (a: number) => 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 wasmtropicalnumber_tropicalAdd: (a: number, b: number) => number;
+  readonly wasmmultidualnumber_getReal: (a: number) => number;
+  readonly wasmschwarzschildmetric_mass: (a: number) => number;
+  readonly wasmspacetimevector_x: (a: number) => number;
+  readonly wasmtropicalnumber_getValue: (a: number) => number;
+  readonly __wbg_batchoperations_free: (a: number, b: number) => void;
+  readonly __wbg_batchops_free: (a: number, b: number) => void;
+  readonly __wbg_mlops_free: (a: number, b: number) => void;
+  readonly __wbg_networkbatchoperations_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_wasmrelativisticconstants_free: (a: number, b: number) => void;
+  readonly __wbg_wasmspacetimevector_free: (a: number, b: number) => void;
   readonly wasmrotor_inverse: (a: number) => number;
   readonly __wbg_wasmrotor_free: (a: number, b: number) => void;
-  readonly __wbindgen_export_0: WebAssembly.Table;
+  readonly __wbindgen_exn_store: (a: number) => void;
+  readonly __externref_table_alloc: () => number;
+  readonly __wbindgen_export_2: WebAssembly.Table;
   readonly __wbindgen_malloc: (a: number, b: number) => number;
+  readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
   readonly __externref_table_dealloc: (a: number) => void;
   readonly __wbindgen_free: (a: number, b: number, c: number) => void;
   readonly __wbindgen_start: () => void;