@justinelliottcobb/amari-wasm 0.3.6 → 0.4.0

package/README.md

@@ -1,12 +1,12 @@
-# @amari/core
+# @justinelliottcobb/amari-wasm v0.4.0
 
-🚀 **Advanced Mathematical Computing Library for JavaScript/TypeScript**
+🚀 **Unified Mathematical Computing Library for JavaScript/TypeScript**
 
-[![npm version](https://badge.fury.io/js/%40amari%2Fcore.svg)](https://www.npmjs.com/package/@amari/core)
+[![npm version](https://badge.fury.io/js/%40justinelliottcobb%2Famari-wasm.svg)](https://www.npmjs.com/package/@justinelliottcobb/amari-wasm)
 [![CI](https://github.com/justinelliottcobb/Amari/actions/workflows/ci.yml/badge.svg)](https://github.com/justinelliottcobb/Amari/actions/workflows/ci.yml)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 
-Amari is a high-performance mathematical computing library that brings advanced algebraic structures to JavaScript/TypeScript through WebAssembly. It combines geometric algebra, tropical algebra, dual number automatic differentiation, and cellular automata in a unified framework.
+Amari is a comprehensive mathematical computing library that brings five advanced algebraic systems to JavaScript/TypeScript through WebAssembly: geometric algebra, tropical algebra, automatic differentiation, fusion systems, and information geometry.
 
 ## ✨ Features
 

package/amari_wasm.d.ts

@@ -4,6 +4,22 @@
  * Initialize the WASM module
  */
 export function init(): void;
+/**
+ * Automatic differentiation utilities
+ */
+export class AutoDiff {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Compute numerical derivative using finite differences (fallback implementation)
+   */
+  static numericalDerivative(x: number, f: Function, h: number): number;
+  /**
+   * Create a dual number and evaluate a polynomial
+   */
+  static evaluatePolynomial(x: number, coefficients: Float64Array): WasmDualNumber;
+}
 /**
  * Batch operations for performance
  */
@@ -20,6 +36,279 @@ export class BatchOperations {
    */
   static batchAdd(a_batch: Float64Array, b_batch: Float64Array): Float64Array;
 }
+/**
+ * Fusion utilities for batch operations
+ */
+export class FusionBatch {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Batch tropical attention across multiple queries
+   */
+  static batchTropicalAttention(queries: Float64Array, keys: Float64Array, values: Float64Array, query_dim: number): Float64Array;
+  /**
+   * Compute fusion similarity between two TDC objects
+   */
+  static fusionSimilarity(tdc1: WasmTropicalDualClifford, tdc2: WasmTropicalDualClifford): number;
+  /**
+   * Optimize TDC parameters using gradient information
+   */
+  static gradientStep(tdc: WasmTropicalDualClifford, learning_rate: number): WasmTropicalDualClifford;
+}
+/**
+ * Information geometry utilities
+ */
+export class InfoGeomUtils {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Normalize array to probability distribution
+   */
+  static normalize(values: Float64Array): Float64Array;
+  /**
+   * Convert log probabilities to probabilities
+   */
+  static softmax(logits: Float64Array): Float64Array;
+  /**
+   * Compute entropy of a probability distribution
+   */
+  static entropy(p: Float64Array): number;
+  /**
+   * Compute cross-entropy between two distributions
+   */
+  static crossEntropy(p: Float64Array, q: Float64Array): number;
+  /**
+   * Compute mutual information between two discrete distributions
+   */
+  static mutualInformation(joint: Float64Array, marginal_x: Float64Array, marginal_y: Float64Array, dim_x: number): number;
+  /**
+   * Generate points on the probability simplex for testing
+   * Note: Uses a simple deterministic sequence for reproducibility in WASM
+   */
+  static randomSimplex(dimension: number): Float64Array;
+}
+/**
+ * Batch operations for tropical numbers
+ */
+export class TropicalBatch {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Batch tropical addition (max operation)
+   */
+  static batchTropicalAdd(values: Float64Array): number;
+  /**
+   * Batch tropical multiplication (addition)
+   */
+  static batchTropicalMul(values: Float64Array): number;
+  /**
+   * 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;
+}
+/**
+ * WASM wrapper for AlphaConnection
+ */
+export class WasmAlphaConnection {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Create a new α-connection
+   */
+  constructor(alpha: number);
+  /**
+   * Get the α parameter
+   */
+  getAlpha(): number;
+  /**
+   * Check if this is the exponential connection (α = 1)
+   */
+  isExponential(): boolean;
+  /**
+   * Check if this is the mixture connection (α = -1)
+   */
+  isMixture(): boolean;
+  /**
+   * Check if this is the Levi-Civita connection (α = 0)
+   */
+  isLeviCivita(): boolean;
+}
+/**
+ * WASM wrapper for single-variable dual numbers
+ */
+export class WasmDualNumber {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Create a new dual number with given real and dual parts
+   */
+  constructor(real: number, dual: number);
+  /**
+   * Create a variable (derivative = 1)
+   */
+  static variable(value: number): WasmDualNumber;
+  /**
+   * Create a constant (derivative = 0)
+   */
+  static constant(value: number): WasmDualNumber;
+  /**
+   * Get the real part (function value)
+   */
+  getReal(): number;
+  /**
+   * Get the dual part (derivative)
+   */
+  getDual(): number;
+  /**
+   * Addition
+   */
+  add(other: WasmDualNumber): WasmDualNumber;
+  /**
+   * Subtraction
+   */
+  sub(other: WasmDualNumber): WasmDualNumber;
+  /**
+   * Multiplication
+   */
+  mul(other: WasmDualNumber): WasmDualNumber;
+  /**
+   * Division
+   */
+  div(other: WasmDualNumber): WasmDualNumber;
+  /**
+   * Negation
+   */
+  neg(): WasmDualNumber;
+  /**
+   * Power function
+   */
+  pow(exponent: number): WasmDualNumber;
+  /**
+   * Exponential function
+   */
+  exp(): WasmDualNumber;
+  /**
+   * Natural logarithm
+   */
+  ln(): WasmDualNumber;
+  /**
+   * Sine function
+   */
+  sin(): WasmDualNumber;
+  /**
+   * Cosine function
+   */
+  cos(): WasmDualNumber;
+  /**
+   * Square root
+   */
+  sqrt(): WasmDualNumber;
+}
+/**
+ * WASM wrapper for DuallyFlatManifold
+ */
+export class WasmDuallyFlatManifold {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Create a new dually flat manifold
+   */
+  constructor(dimension: number, alpha: number);
+  /**
+   * Compute Fisher information metric at a point
+   */
+  fisherMetricAt(point: Float64Array): WasmFisherInformationMatrix;
+  /**
+   * Compute Bregman divergence (KL divergence for probability distributions)
+   */
+  bregmanDivergence(p: Float64Array, q: Float64Array): number;
+  /**
+   * Compute KL divergence between two probability distributions
+   */
+  klDivergence(p: Float64Array, q: Float64Array): number;
+  /**
+   * Compute JS divergence (symmetric version of KL divergence)
+   */
+  jsDivergence(p: Float64Array, q: Float64Array): number;
+  /**
+   * Compute Wasserstein-1 distance (Earth Mover's Distance)
+   */
+  wassersteinDistance(p: Float64Array, q: Float64Array): number;
+}
+/**
+ * WASM wrapper for FisherInformationMatrix
+ */
+export class WasmFisherInformationMatrix {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Get eigenvalues of the Fisher matrix
+   */
+  getEigenvalues(): Float64Array;
+  /**
+   * Check if the matrix is positive definite
+   */
+  isPositiveDefinite(): boolean;
+  /**
+   * Compute condition number (ratio of largest to smallest eigenvalue)
+   */
+  conditionNumber(): number;
+}
+/**
+ * WASM wrapper for multi-variable dual numbers
+ */
+export class WasmMultiDualNumber {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Create a new multi-dual number
+   */
+  constructor(real: number, duals: Float64Array);
+  /**
+   * Create a variable with derivative 1 at the specified index
+   */
+  static variable(value: number, num_vars: number, var_index: number): WasmMultiDualNumber;
+  /**
+   * Create a constant (all derivatives are zero)
+   */
+  static constant(value: number, num_vars: number): WasmMultiDualNumber;
+  /**
+   * Get the real part (function value)
+   */
+  getReal(): number;
+  /**
+   * Get the gradient (all partial derivatives)
+   */
+  getGradient(): Float64Array;
+  /**
+   * Get a specific partial derivative
+   */
+  getPartial(index: number): number;
+  /**
+   * Get number of variables
+   */
+  getNumVars(): number;
+  /**
+   * Addition
+   */
+  add(other: WasmMultiDualNumber): WasmMultiDualNumber;
+  /**
+   * Multiplication
+   */
+  mul(other: WasmMultiDualNumber): WasmMultiDualNumber;
+  /**
+   * Square root
+   */
+  sqrt(): WasmMultiDualNumber;
+}
 /**
  * WASM wrapper for Multivector with TypedArray support
  */
@@ -135,11 +424,225 @@ export class WasmRotor {
    */
   inverse(): WasmRotor;
 }
+/**
+ * WASM wrapper for TropicalDualClifford fusion system
+ */
+export class WasmTropicalDualClifford {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Create a zero TDC object
+   */
+  constructor();
+  /**
+   * Create from logits (array of log-probabilities)
+   */
+  static fromLogits(logits: Float64Array): WasmTropicalDualClifford;
+  /**
+   * Create random TDC for testing
+   */
+  static random(): WasmTropicalDualClifford;
+  /**
+   * Create random TDC with specific scale
+   */
+  static randomWithScale(scale: number): WasmTropicalDualClifford;
+  /**
+   * Check if TDC is zero
+   */
+  isZero(): boolean;
+  /**
+   * Extract tropical features as array
+   */
+  getTropicalFeatures(): Float64Array;
+  /**
+   * Extract dual features as array of real parts
+   */
+  getDualReals(): Float64Array;
+  /**
+   * Extract dual features as array of dual parts (derivatives)
+   */
+  getDualDerivatives(): Float64Array;
+  /**
+   * Get Clifford coefficients
+   */
+  getCliffordCoefficients(): Float64Array;
+  /**
+   * Add two TDC objects
+   */
+  add(other: WasmTropicalDualClifford): WasmTropicalDualClifford;
+  /**
+   * Scale TDC object
+   */
+  scale(factor: number): WasmTropicalDualClifford;
+  /**
+   * Compute fusion norm (combined measure across all systems)
+   */
+  fusionNorm(): number;
+  /**
+   * Perform tropical attention operation
+   */
+  tropicalAttention(keys: Float64Array, values: Float64Array): Float64Array;
+  /**
+   * Extract geometric features using Clifford operations
+   */
+  extractGeometricFeatures(): Float64Array;
+}
+/**
+ * WASM wrapper for TropicalNumber
+ */
+export class WasmTropicalNumber {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Create a new tropical number from a regular number
+   */
+  constructor(value: number);
+  /**
+   * Create tropical zero (negative infinity)
+   */
+  static zero(): WasmTropicalNumber;
+  /**
+   * Create tropical one (regular zero)
+   */
+  static one(): WasmTropicalNumber;
+  /**
+   * Create from log probability
+   */
+  static fromLogProb(log_p: number): WasmTropicalNumber;
+  /**
+   * Get the underlying value
+   */
+  getValue(): number;
+  /**
+   * Convert to probability (via exp)
+   */
+  toProb(): number;
+  /**
+   * Check if this is tropical zero (negative infinity)
+   */
+  isZero(): boolean;
+  /**
+   * Check if this is tropical one (zero)
+   */
+  isOne(): boolean;
+  /**
+   * 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;
+  /**
+   * Standard addition (for convenience)
+   */
+  add(other: WasmTropicalNumber): WasmTropicalNumber;
+  /**
+   * Standard multiplication (for convenience)
+   */
+  mul(other: WasmTropicalNumber): WasmTropicalNumber;
+  /**
+   * Negation
+   */
+  neg(): WasmTropicalNumber;
+}
 
 export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
 
 export interface InitOutput {
   readonly memory: WebAssembly.Memory;
+  readonly wasmdualnumber_new: (a: number, b: number) => number;
+  readonly wasmdualnumber_variable: (a: number) => number;
+  readonly wasmdualnumber_constant: (a: number) => number;
+  readonly wasmdualnumber_getDual: (a: number) => number;
+  readonly wasmdualnumber_add: (a: number, b: number) => number;
+  readonly wasmdualnumber_sub: (a: number, b: number) => number;
+  readonly wasmdualnumber_mul: (a: number, b: number) => number;
+  readonly wasmdualnumber_div: (a: number, b: number) => [number, number, number];
+  readonly wasmdualnumber_neg: (a: number) => number;
+  readonly wasmdualnumber_pow: (a: number, b: number) => number;
+  readonly wasmdualnumber_exp: (a: number) => number;
+  readonly wasmdualnumber_ln: (a: number) => [number, number, number];
+  readonly wasmdualnumber_sin: (a: number) => number;
+  readonly wasmdualnumber_cos: (a: number) => number;
+  readonly wasmdualnumber_sqrt: (a: number) => [number, number, number];
+  readonly __wbg_wasmmultidualnumber_free: (a: number, b: number) => void;
+  readonly wasmmultidualnumber_new: (a: number, b: number, c: number) => number;
+  readonly wasmmultidualnumber_variable: (a: number, b: number, c: number) => number;
+  readonly wasmmultidualnumber_constant: (a: number, b: number) => number;
+  readonly wasmmultidualnumber_getGradient: (a: number) => [number, number];
+  readonly wasmmultidualnumber_getPartial: (a: number, b: number) => [number, number, number];
+  readonly wasmmultidualnumber_getNumVars: (a: number) => number;
+  readonly wasmmultidualnumber_add: (a: number, b: number) => [number, number, number];
+  readonly wasmmultidualnumber_mul: (a: number, b: number) => [number, number, number];
+  readonly wasmmultidualnumber_sqrt: (a: number) => [number, number, number];
+  readonly __wbg_autodiff_free: (a: number, b: number) => void;
+  readonly autodiff_numericalDerivative: (a: number, b: any, c: number) => [number, number, number];
+  readonly autodiff_evaluatePolynomial: (a: number, b: number, c: number) => number;
+  readonly __wbg_wasmtropicaldualclifford_free: (a: number, b: number) => void;
+  readonly wasmtropicaldualclifford_new: () => number;
+  readonly wasmtropicaldualclifford_fromLogits: (a: number, b: number) => number;
+  readonly wasmtropicaldualclifford_random: () => number;
+  readonly wasmtropicaldualclifford_randomWithScale: (a: number) => number;
+  readonly wasmtropicaldualclifford_isZero: (a: number) => number;
+  readonly wasmtropicaldualclifford_getTropicalFeatures: (a: number) => [number, number];
+  readonly wasmtropicaldualclifford_getDualReals: (a: number) => [number, number];
+  readonly wasmtropicaldualclifford_getDualDerivatives: (a: number) => [number, number];
+  readonly wasmtropicaldualclifford_getCliffordCoefficients: (a: number) => [number, number];
+  readonly wasmtropicaldualclifford_add: (a: number, b: number) => number;
+  readonly wasmtropicaldualclifford_scale: (a: number, b: number) => number;
+  readonly wasmtropicaldualclifford_fusionNorm: (a: number) => number;
+  readonly wasmtropicaldualclifford_tropicalAttention: (a: number, b: number, c: number, d: number, e: number) => [number, number, number, number];
+  readonly wasmtropicaldualclifford_extractGeometricFeatures: (a: number) => [number, number];
+  readonly fusionbatch_batchTropicalAttention: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => [number, number, number, number];
+  readonly fusionbatch_fusionSimilarity: (a: number, b: number) => number;
+  readonly fusionbatch_gradientStep: (a: number, b: number) => number;
+  readonly __wbg_wasmduallyflatmanifold_free: (a: number, b: number) => void;
+  readonly wasmduallyflatmanifold_new: (a: number, b: number) => number;
+  readonly wasmduallyflatmanifold_fisherMetricAt: (a: number, b: number, c: number) => number;
+  readonly wasmduallyflatmanifold_bregmanDivergence: (a: number, b: number, c: number, d: number, e: number) => number;
+  readonly wasmduallyflatmanifold_klDivergence: (a: number, b: number, c: number, d: number, e: number) => [number, number, number];
+  readonly wasmduallyflatmanifold_jsDivergence: (a: number, b: number, c: number, d: number, e: number) => [number, number, number];
+  readonly wasmduallyflatmanifold_wassersteinDistance: (a: number, b: number, c: number, d: number, e: number) => [number, number, number];
+  readonly __wbg_wasmfisherinformationmatrix_free: (a: number, b: number) => void;
+  readonly wasmfisherinformationmatrix_getEigenvalues: (a: number) => [number, number];
+  readonly wasmfisherinformationmatrix_isPositiveDefinite: (a: number) => number;
+  readonly wasmfisherinformationmatrix_conditionNumber: (a: number) => number;
+  readonly __wbg_wasmalphaconnection_free: (a: number, b: number) => void;
+  readonly wasmalphaconnection_new: (a: number) => [number, number, number];
+  readonly wasmalphaconnection_getAlpha: (a: number) => number;
+  readonly wasmalphaconnection_isExponential: (a: number) => number;
+  readonly wasmalphaconnection_isMixture: (a: number) => number;
+  readonly wasmalphaconnection_isLeviCivita: (a: number) => number;
+  readonly infogeomutils_normalize: (a: number, b: number) => [number, number, number, number];
+  readonly infogeomutils_softmax: (a: number, b: number) => [number, number];
+  readonly infogeomutils_entropy: (a: number, b: number) => [number, number, number];
+  readonly infogeomutils_crossEntropy: (a: number, b: number, c: number, d: number) => [number, number, number];
+  readonly infogeomutils_mutualInformation: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => [number, number, number];
+  readonly infogeomutils_randomSimplex: (a: number) => [number, number];
+  readonly wasmtropicalnumber_zero: () => number;
+  readonly wasmtropicalnumber_one: () => number;
+  readonly wasmtropicalnumber_fromLogProb: (a: number) => number;
+  readonly wasmtropicalnumber_toProb: (a: number) => number;
+  readonly wasmtropicalnumber_isZero: (a: number) => number;
+  readonly wasmtropicalnumber_isOne: (a: number) => number;
+  readonly wasmtropicalnumber_isInfinity: (a: number) => number;
+  readonly wasmtropicalnumber_tropicalPow: (a: number, b: number) => number;
+  readonly wasmtropicalnumber_add: (a: number, b: number) => number;
+  readonly wasmtropicalnumber_mul: (a: number, b: number) => number;
+  readonly wasmtropicalnumber_neg: (a: 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 __wbg_wasmmultivector_free: (a: number, b: number) => void;
   readonly wasmmultivector_new: () => number;
   readonly wasmmultivector_fromCoefficients: (a: number, b: number) => [number, number, number];
@@ -161,19 +664,32 @@ export interface InitOutput {
   readonly wasmmultivector_add: (a: number, b: number) => number;
   readonly wasmmultivector_sub: (a: number, b: number) => number;
   readonly wasmmultivector_scale: (a: number, b: number) => number;
-  readonly __wbg_batchoperations_free: (a: number, b: number) => void;
   readonly batchoperations_batchGeometricProduct: (a: number, b: number, c: number, d: number) => [number, number, number, number];
   readonly batchoperations_batchAdd: (a: number, b: number, c: number, d: number) => [number, number, number, number];
   readonly wasmrotor_fromBivector: (a: number, b: number) => number;
   readonly wasmrotor_apply: (a: number, b: number) => number;
   readonly wasmrotor_compose: (a: number, b: number) => number;
   readonly init: () => void;
+  readonly wasmtropicalnumber_new: (a: number) => number;
   readonly wasmmultivector_norm: (a: number) => number;
+  readonly wasmtropicalnumber_tropicalMul: (a: number, b: number) => number;
+  readonly wasmtropicalnumber_tropicalAdd: (a: number, b: number) => number;
+  readonly wasmmultidualnumber_getReal: (a: number) => number;
+  readonly wasmdualnumber_getReal: (a: number) => number;
+  readonly wasmtropicalnumber_getValue: (a: number) => number;
+  readonly __wbg_fusionbatch_free: (a: number, b: number) => void;
+  readonly __wbg_wasmdualnumber_free: (a: number, b: number) => void;
+  readonly __wbg_infogeomutils_free: (a: number, b: number) => void;
+  readonly __wbg_wasmtropicalnumber_free: (a: number, b: number) => void;
+  readonly __wbg_tropicalbatch_free: (a: number, b: number) => void;
+  readonly __wbg_batchoperations_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_malloc: (a: number, b: number) => number;
+  readonly __wbindgen_exn_store: (a: number) => void;
+  readonly __externref_table_alloc: () => number;
+  readonly __wbindgen_export_2: WebAssembly.Table;
   readonly __externref_table_dealloc: (a: number) => void;
+  readonly __wbindgen_malloc: (a: number, b: number) => number;
   readonly __wbindgen_free: (a: number, b: number, c: number) => void;
   readonly __wbindgen_start: () => void;
 }