@justinelliottcobb/amari-wasm 0.9.2 → 0.9.3

package/amari_wasm.d.ts

@@ -1,13 +1,13 @@
 /* tslint:disable */
 /* eslint-disable */
-/**
- * Convert Lorentz factor to velocity
- */
-export function gamma_to_velocity(gamma: number): number;
 /**
  * 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
  */
@@ -20,6 +20,30 @@ 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
  */
@@ -37,6 +61,50 @@ 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
  */
@@ -77,6 +145,161 @@ 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
  */
@@ -198,6 +421,53 @@ export class WasmGeometricNetwork {
    */
   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
  */
@@ -499,34 +769,198 @@ export class WasmTrajectoryPoint {
    */
   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;
@@ -551,6 +985,15 @@ export interface InitOutput {
   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;
@@ -593,7 +1036,6 @@ export interface InitOutput {
   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_mass: (a: number) => number;
   readonly wasmschwarzschildmetric_schwarzschild_radius: (a: number) => number;
   readonly wasmschwarzschildmetric_sun: () => number;
   readonly wasmspacetimevector_is_null: (a: number) => number;
@@ -605,14 +1047,43 @@ export interface InitOutput {
   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_x: (a: 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;