@justinelliottcobb/amari-wasm 0.9.6 → 0.9.7-1

package/amari_wasm.d.ts

@@ -4,22 +4,22 @@
  * Initialize the enumerative geometry module
  */
 export function initEnumerative(): void;
-/**
- * Convert velocity to Lorentz factor
- */
-export function velocity_to_gamma(velocity_magnitude: number): number;
 /**
  * Calculate light deflection angle for photon grazing massive object
  */
 export function light_deflection_angle(impact_parameter: number, mass: number): number;
+/**
+ * Validate that this module loaded correctly
+ */
+export function validate_relativistic_module(): boolean;
 /**
  * Convert Lorentz factor to velocity
  */
 export function gamma_to_velocity(gamma: number): number;
 /**
- * Validate that this module loaded correctly
+ * Convert velocity to Lorentz factor
  */
-export function validate_relativistic_module(): boolean;
+export function velocity_to_gamma(velocity_magnitude: number): number;
 /**
  * Initialize the WASM module
  */
@@ -899,6 +899,33 @@ export class WasmGeometricNetwork {
    */
   numNodes(): number;
 }
+/**
+ * GPU-accelerated optimization wrapper for WASM
+ */
+export class WasmGpuOptimizer {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Initialize GPU context for optimization
+   */
+  initializeGpu(): Promise<boolean>;
+  /**
+   * 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>;
+  /**
+   * Create a new GPU optimizer
+   */
+  constructor();
+}
 /**
  * WASM wrapper for Grassmannian varieties
  */
@@ -1020,6 +1047,42 @@ export class WasmMultiDualNumber {
    */
   static variable(value: number, num_vars: number, var_index: number): WasmMultiDualNumber;
 }
+/**
+ * Simple multi-objective optimizer for WASM
+ */
+export class WasmMultiObjectiveOptimizer {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Optimize a simple bi-objective problem
+   * f1 = sum(x_i^2), f2 = sum((x_i - 1)^2)
+   */
+  optimizeBiObjective(dimension: number, population_size: number, generations: number): WasmMultiObjectiveResult;
+  /**
+   * Create a new multi-objective optimizer
+   */
+  constructor();
+}
+/**
+ * Multi-objective optimization result
+ */
+export class WasmMultiObjectiveResult {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Get number of generations
+   */
+  readonly generations: number;
+  /**
+   * Get Pareto front as flattened array
+   */
+  readonly pareto_front: Float64Array;
+  /**
+   * Check if optimization converged
+   */
+  readonly converged: boolean;
+}
 /**
  * WASM wrapper for Multivector with TypedArray support
  */
@@ -1142,6 +1205,46 @@ export class WasmNodeMetadata {
    */
   set label(value: string | null | undefined);
 }
+/**
+ * WASM wrapper for optimization results
+ */
+export class WasmOptimizationResult {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Get number of iterations
+   */
+  readonly iterations: number;
+  /**
+   * Get final objective value
+   */
+  readonly objective_value: number;
+  /**
+   * Get solution vector
+   */
+  readonly solution: Float64Array;
+  /**
+   * Check if optimization converged
+   */
+  readonly converged: boolean;
+}
+/**
+ * Utility functions for optimization
+ */
+export class WasmOptimizationUtils {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Compute numerical gradient
+   */
+  static numericalGradient(coefficients: Float64Array, point: Float64Array, epsilon: number): Float64Array;
+  /**
+   * Check if a point dominates another in multi-objective optimization
+   */
+  static dominates(objectives1: Float64Array, objectives2: Float64Array): boolean;
+}
 /**
  * WASM wrapper for projective spaces
  */
@@ -1363,6 +1466,21 @@ export class WasmSensitivityMap {
    */
   getTotalSensitivity(): number;
 }
+/**
+ * Simple quadratic optimization problem for WASM demonstration
+ */
+export class WasmSimpleOptimizer {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Optimize a simple quadratic function: minimize sum(c_i * x_i^2)
+   */
+  optimizeQuadratic(coefficients: Float64Array, initial_point: Float64Array): WasmOptimizationResult;
+  /**
+   * Create a new simple optimizer
+   */
+  constructor();
+}
 /**
  * WASM wrapper for spacetime vectors
  */
@@ -1748,6 +1866,7 @@ export interface InitOutput {
   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;
@@ -1927,6 +2046,11 @@ export interface InitOutput {
   readonly wasmgeometricnetwork_spectralClustering: (a: number, b: number) => [number, number, number];
   readonly wasmgeometricnetwork_toTropicalNetwork: (a: number) => [number, number, number];
   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;
   readonly wasmgrassmannian_getParameters: (a: number) => [number, number];
   readonly wasmgrassmannian_new: (a: number, b: number) => [number, number, number];
@@ -1949,6 +2073,10 @@ export interface InitOutput {
   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 wasmmultiobjectiveoptimizer_optimizeBiObjective: (a: number, b: number, c: number, d: number) => [number, number, number];
+  readonly wasmmultiobjectiveresult_converged: (a: number) => number;
+  readonly wasmmultiobjectiveresult_generations: (a: number) => number;
+  readonly wasmmultiobjectiveresult_pareto_front: (a: number) => [number, number];
   readonly wasmmultivector_add: (a: number, b: number) => number;
   readonly wasmmultivector_basisVector: (a: number) => [number, number, number];
   readonly wasmmultivector_exp: (a: number) => number;
@@ -1975,10 +2103,14 @@ export interface InitOutput {
   readonly wasmnodemetadata_setProperty: (a: number, b: number, c: number, d: number) => void;
   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 wasmprojectivespace_bezoutIntersection: (a: number, b: number, c: number) => number;
   readonly wasmprojectivespace_hasDimension: (a: number, b: number) => number;
   readonly wasmprojectivespace_new: (a: number) => number;
-  readonly wasmpropagationanalysis_convergence_time: (a: number) => number;
   readonly wasmpropagationanalysis_coverage: (a: number) => [number, number];
   readonly wasmpropagationanalysis_influence_scores: (a: number) => [number, number];
   readonly wasmrelativisticconstants_earth_mass: () => number;
@@ -2012,6 +2144,7 @@ export interface InitOutput {
   readonly wasmsensitivitymap_getAllSensitivities: (a: number) => [number, number, number];
   readonly wasmsensitivitymap_getMostSensitive: (a: number, b: number) => [number, number];
   readonly wasmsensitivitymap_getTotalSensitivity: (a: number) => number;
+  readonly wasmsimpleoptimizer_optimizeQuadratic: (a: number, b: number, c: number, d: number, e: number) => [number, number, number];
   readonly wasmspacetimevector_is_null: (a: number) => number;
   readonly wasmspacetimevector_is_spacelike: (a: number) => number;
   readonly wasmspacetimevector_is_timelike: (a: number) => number;
@@ -2051,7 +2184,6 @@ export interface InitOutput {
   readonly wasmtropicaldualdistribution_mostLikelySequence: (a: number, b: number) => [number, number];
   readonly wasmtropicaldualdistribution_new: (a: number, b: number) => number;
   readonly wasmtropicalnetwork_fromWeights: (a: number, b: number, c: number) => [number, number, number];
-  readonly wasmtropicalnetwork_getSize: (a: number) => number;
   readonly wasmtropicalnetwork_new: (a: number) => number;
   readonly wasmtropicalnetwork_setEdge: (a: number, b: number, c: number, d: number) => [number, number];
   readonly wasmtropicalnetwork_shortestPathTropical: (a: number, b: number, c: number) => [number, number, number];
@@ -2067,7 +2199,6 @@ export interface InitOutput {
   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;
@@ -2079,6 +2210,7 @@ export interface InitOutput {
   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 wasmtropicalnumber_tropicalAdd: (a: number, b: number) => number;
   readonly wasmcommunity_cohesion_score: (a: number) => number;
   readonly wasmdualnumber_getReal: (a: number) => number;
@@ -2086,12 +2218,15 @@ export interface InitOutput {
   readonly wasmevaluationresult_getGradientNorm: (a: number) => number;
   readonly wasmgeometricedge_weight: (a: number) => number;
   readonly wasmmultidualnumber_getReal: (a: number) => number;
+  readonly wasmoptimizationresult_objective_value: (a: number) => number;
   readonly wasmprojectivespace_getDimension: (a: number) => number;
+  readonly wasmpropagationanalysis_convergence_time: (a: number) => number;
   readonly wasmschwarzschildmetric_mass: (a: number) => number;
   readonly wasmspacetimevector_x: (a: number) => number;
   readonly wasmspacetimevector_y: (a: number) => number;
   readonly wasmspacetimevector_z: (a: number) => number;
   readonly wasmtropicalcurve_getGenus: (a: number) => number;
+  readonly wasmtropicalnetwork_getSize: (a: number) => number;
   readonly wasmtropicalnumber_getValue: (a: number) => number;
   readonly __wbg_automatabatchoperations_free: (a: number, b: number) => void;
   readonly __wbg_automatautils_free: (a: number, b: number) => void;
@@ -2110,19 +2245,29 @@ export interface InitOutput {
   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_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_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 wasmmultiobjectiveoptimizer_new: () => number;
+  readonly wasmsimpleoptimizer_new: () => number;
   readonly __wbindgen_exn_store: (a: number) => void;
   readonly __externref_table_alloc: () => number;
   readonly __wbindgen_export_2: WebAssembly.Table;
   readonly __wbindgen_free: (a: number, b: number, c: number) => void;
   readonly __wbindgen_malloc: (a: number, b: number) => number;
   readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
+  readonly __wbindgen_export_6: WebAssembly.Table;
   readonly __externref_table_dealloc: (a: number) => void;
+  readonly closure38_externref_shim: (a: number, b: number, c: any) => void;
+  readonly closure28_externref_shim: (a: number, b: number, c: any, d: any) => void;
   readonly __wbindgen_start: () => void;
 }
 

package/amari_wasm.js

@@ -108,6 +108,10 @@ function getDataViewMemory0() {
     return cachedDataViewMemory0;
 }
 
+function isLikeNone(x) {
+    return x === undefined || x === null;
+}
+
 function debugString(val) {
     // primitive types
     const type = typeof val;
@@ -173,8 +177,52 @@ function debugString(val) {
     return className;
 }
 
-function isLikeNone(x) {
-    return x === undefined || x === null;
+const CLOSURE_DTORS = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(
+state => {
+    wasm.__wbindgen_export_6.get(state.dtor)(state.a, state.b);
+}
+);
+
+function makeMutClosure(arg0, arg1, dtor, f) {
+    const state = { a: arg0, b: arg1, cnt: 1, dtor };
+    const real = (...args) => {
+
+        // First up with a closure we increment the internal reference
+        // count. This ensures that the Rust closure environment won't
+        // be deallocated while we're invoking it.
+        state.cnt++;
+        const a = state.a;
+        state.a = 0;
+        try {
+            return f(a, state.b, ...args);
+        } finally {
+            if (--state.cnt === 0) {
+                wasm.__wbindgen_export_6.get(state.dtor)(a, state.b);
+                CLOSURE_DTORS.unregister(state);
+            } else {
+                state.a = a;
+            }
+        }
+    };
+    real.original = state;
+    CLOSURE_DTORS.register(real, state, state);
+    return real;
+}
+
+let cachedFloat64ArrayMemory0 = null;
+
+function getFloat64ArrayMemory0() {
+    if (cachedFloat64ArrayMemory0 === null || cachedFloat64ArrayMemory0.byteLength === 0) {
+        cachedFloat64ArrayMemory0 = new Float64Array(wasm.memory.buffer);
+    }
+    return cachedFloat64ArrayMemory0;
+}
+
+function getArrayF64FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getFloat64ArrayMemory0().subarray(ptr / 8, ptr / 8 + len);
 }
 
 function _assertClass(instance, klass) {
@@ -205,20 +253,6 @@ function takeFromExternrefTable0(idx) {
     return value;
 }
 
-let cachedFloat64ArrayMemory0 = null;
-
-function getFloat64ArrayMemory0() {
-    if (cachedFloat64ArrayMemory0 === null || cachedFloat64ArrayMemory0.byteLength === 0) {
-        cachedFloat64ArrayMemory0 = new Float64Array(wasm.memory.buffer);
-    }
-    return cachedFloat64ArrayMemory0;
-}
-
-function getArrayF64FromWasm0(ptr, len) {
-    ptr = ptr >>> 0;
-    return getFloat64ArrayMemory0().subarray(ptr / 8, ptr / 8 + len);
-}
-
 function getArrayU32FromWasm0(ptr, len) {
     ptr = ptr >>> 0;
     return getUint32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
@@ -230,19 +264,12 @@ export function initEnumerative() {
     wasm.initEnumerative();
 }
 
-/**
- * Convert velocity to Lorentz factor
- * @param {number} velocity_magnitude
- * @returns {number}
- */
-export function velocity_to_gamma(velocity_magnitude) {
-    const ret = wasm.velocity_to_gamma(velocity_magnitude);
-    if (ret[2]) {
-        throw takeFromExternrefTable0(ret[1]);
-    }
-    return ret[0];
+function passArrayF64ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 8, 8) >>> 0;
+    getFloat64ArrayMemory0().set(arg, ptr / 8);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
 }
-
 /**
  * Calculate light deflection angle for photon grazing massive object
  * @param {number} impact_parameter
@@ -254,6 +281,15 @@ export function light_deflection_angle(impact_parameter, mass) {
     return ret;
 }
 
+/**
+ * Validate that this module loaded correctly
+ * @returns {boolean}
+ */
+export function validate_relativistic_module() {
+    const ret = wasm.validate_relativistic_module();
+    return ret !== 0;
+}
+
 /**
  * Convert Lorentz factor to velocity
  * @param {number} gamma
@@ -268,20 +304,18 @@ export function gamma_to_velocity(gamma) {
 }
 
 /**
- * Validate that this module loaded correctly
- * @returns {boolean}
+ * Convert velocity to Lorentz factor
+ * @param {number} velocity_magnitude
+ * @returns {number}
  */
-export function validate_relativistic_module() {
-    const ret = wasm.validate_relativistic_module();
-    return ret !== 0;
+export function velocity_to_gamma(velocity_magnitude) {
+    const ret = wasm.velocity_to_gamma(velocity_magnitude);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return ret[0];
 }
 
-function passArrayF64ToWasm0(arg, malloc) {
-    const ptr = malloc(arg.length * 8, 8) >>> 0;
-    getFloat64ArrayMemory0().set(arg, ptr / 8);
-    WASM_VECTOR_LEN = arg.length;
-    return ptr;
-}
 /**
  * Initialize the WASM module
  */
@@ -307,6 +341,13 @@ function getArrayU8FromWasm0(ptr, len) {
     ptr = ptr >>> 0;
     return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
 }
+function __wbg_adapter_8(arg0, arg1, arg2) {
+    wasm.closure38_externref_shim(arg0, arg1, arg2);
+}
+
+function __wbg_adapter_387(arg0, arg1, arg2, arg3) {
+    wasm.closure28_externref_shim(arg0, arg1, arg2, arg3);
+}
 
 const AutoDiffFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
@@ -2950,6 +2991,84 @@ export class WasmGeometricNetwork {
 }
 if (Symbol.dispose) WasmGeometricNetwork.prototype[Symbol.dispose] = WasmGeometricNetwork.prototype.free;
 
+const WasmGpuOptimizerFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmgpuoptimizer_free(ptr >>> 0, 1));
+/**
+ * GPU-accelerated optimization wrapper for WASM
+ */
+export class WasmGpuOptimizer {
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmGpuOptimizerFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmgpuoptimizer_free(ptr, 0);
+    }
+    /**
+     * Initialize GPU context for optimization
+     * @returns {Promise<boolean>}
+     */
+    initializeGpu() {
+        const ret = wasm.wasmgpuoptimizer_initializeGpu(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Batch optimization with parallel processing simulation
+     * @param {Float64Array} problems_data
+     * @param {number} problem_size
+     * @param {number} num_problems
+     * @param {number} max_iterations
+     * @param {number} tolerance
+     * @returns {Promise<Float64Array>}
+     */
+    optimizeBatch(problems_data, problem_size, num_problems, max_iterations, tolerance) {
+        const ptr0 = passArrayF64ToWasm0(problems_data, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmgpuoptimizer_optimizeBatch(this.__wbg_ptr, ptr0, len0, problem_size, num_problems, max_iterations, tolerance);
+        return ret;
+    }
+    /**
+     * Check if GPU acceleration is available
+     * @returns {boolean}
+     */
+    isGpuAvailable() {
+        const ret = wasm.wasmgpuoptimizer_isGpuAvailable(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Optimize a quadratic function with GPU acceleration
+     * @param {Float64Array} coefficients
+     * @param {Float64Array} initial_point
+     * @param {number} max_iterations
+     * @param {number} tolerance
+     * @returns {Promise<WasmOptimizationResult>}
+     */
+    optimizeQuadraticGpu(coefficients, initial_point, max_iterations, tolerance) {
+        const ptr0 = passArrayF64ToWasm0(coefficients, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArrayF64ToWasm0(initial_point, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmgpuoptimizer_optimizeQuadraticGpu(this.__wbg_ptr, ptr0, len0, ptr1, len1, max_iterations, tolerance);
+        return ret;
+    }
+    /**
+     * Create a new GPU optimizer
+     */
+    constructor() {
+        const ret = wasm.wasmgpuoptimizer_new();
+        this.__wbg_ptr = ret >>> 0;
+        WasmGpuOptimizerFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+}
+if (Symbol.dispose) WasmGpuOptimizer.prototype[Symbol.dispose] = WasmGpuOptimizer.prototype.free;
+
 const WasmGrassmannianFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_wasmgrassmannian_free(ptr >>> 0, 1));
@@ -3299,6 +3418,108 @@ export class WasmMultiDualNumber {
 }
 if (Symbol.dispose) WasmMultiDualNumber.prototype[Symbol.dispose] = WasmMultiDualNumber.prototype.free;
 
+const WasmMultiObjectiveOptimizerFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmmultiobjectiveoptimizer_free(ptr >>> 0, 1));
+/**
+ * Simple multi-objective optimizer for WASM
+ */
+export class WasmMultiObjectiveOptimizer {
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmMultiObjectiveOptimizerFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmmultiobjectiveoptimizer_free(ptr, 0);
+    }
+    /**
+     * Optimize a simple bi-objective problem
+     * f1 = sum(x_i^2), f2 = sum((x_i - 1)^2)
+     * @param {number} dimension
+     * @param {number} population_size
+     * @param {number} generations
+     * @returns {WasmMultiObjectiveResult}
+     */
+    optimizeBiObjective(dimension, population_size, generations) {
+        const ret = wasm.wasmmultiobjectiveoptimizer_optimizeBiObjective(this.__wbg_ptr, dimension, population_size, generations);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmMultiObjectiveResult.__wrap(ret[0]);
+    }
+    /**
+     * Create a new multi-objective optimizer
+     */
+    constructor() {
+        const ret = wasm.wasmgpuoptimizer_new();
+        this.__wbg_ptr = ret >>> 0;
+        WasmMultiObjectiveOptimizerFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+}
+if (Symbol.dispose) WasmMultiObjectiveOptimizer.prototype[Symbol.dispose] = WasmMultiObjectiveOptimizer.prototype.free;
+
+const WasmMultiObjectiveResultFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmmultiobjectiveresult_free(ptr >>> 0, 1));
+/**
+ * Multi-objective optimization result
+ */
+export class WasmMultiObjectiveResult {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(WasmMultiObjectiveResult.prototype);
+        obj.__wbg_ptr = ptr;
+        WasmMultiObjectiveResultFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmMultiObjectiveResultFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmmultiobjectiveresult_free(ptr, 0);
+    }
+    /**
+     * Get number of generations
+     * @returns {number}
+     */
+    get generations() {
+        const ret = wasm.wasmmultiobjectiveresult_generations(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Get Pareto front as flattened array
+     * @returns {Float64Array}
+     */
+    get pareto_front() {
+        const ret = wasm.wasmmultiobjectiveresult_pareto_front(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * Check if optimization converged
+     * @returns {boolean}
+     */
+    get converged() {
+        const ret = wasm.wasmmultiobjectiveresult_converged(this.__wbg_ptr);
+        return ret !== 0;
+    }
+}
+if (Symbol.dispose) WasmMultiObjectiveResult.prototype[Symbol.dispose] = WasmMultiObjectiveResult.prototype.free;
+
 const WasmMultivectorFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_wasmmultivector_free(ptr >>> 0, 1));
@@ -3625,6 +3846,126 @@ export class WasmNodeMetadata {
 }
 if (Symbol.dispose) WasmNodeMetadata.prototype[Symbol.dispose] = WasmNodeMetadata.prototype.free;
 
+const WasmOptimizationResultFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmoptimizationresult_free(ptr >>> 0, 1));
+/**
+ * WASM wrapper for optimization results
+ */
+export class WasmOptimizationResult {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(WasmOptimizationResult.prototype);
+        obj.__wbg_ptr = ptr;
+        WasmOptimizationResultFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmOptimizationResultFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmoptimizationresult_free(ptr, 0);
+    }
+    /**
+     * Get number of iterations
+     * @returns {number}
+     */
+    get iterations() {
+        const ret = wasm.wasmoptimizationresult_iterations(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Get final objective value
+     * @returns {number}
+     */
+    get objective_value() {
+        const ret = wasm.wasmalphaconnection_getAlpha(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Get solution vector
+     * @returns {Float64Array}
+     */
+    get solution() {
+        const ret = wasm.wasmoptimizationresult_solution(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * Check if optimization converged
+     * @returns {boolean}
+     */
+    get converged() {
+        const ret = wasm.wasmoptimizationresult_converged(this.__wbg_ptr);
+        return ret !== 0;
+    }
+}
+if (Symbol.dispose) WasmOptimizationResult.prototype[Symbol.dispose] = WasmOptimizationResult.prototype.free;
+
+const WasmOptimizationUtilsFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmoptimizationutils_free(ptr >>> 0, 1));
+/**
+ * Utility functions for optimization
+ */
+export class WasmOptimizationUtils {
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmOptimizationUtilsFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmoptimizationutils_free(ptr, 0);
+    }
+    /**
+     * Compute numerical gradient
+     * @param {Float64Array} coefficients
+     * @param {Float64Array} point
+     * @param {number} epsilon
+     * @returns {Float64Array}
+     */
+    static numericalGradient(coefficients, point, epsilon) {
+        const ptr0 = passArrayF64ToWasm0(coefficients, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArrayF64ToWasm0(point, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmoptimizationutils_numericalGradient(ptr0, len0, ptr1, len1, epsilon);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v3 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v3;
+    }
+    /**
+     * Check if a point dominates another in multi-objective optimization
+     * @param {Float64Array} objectives1
+     * @param {Float64Array} objectives2
+     * @returns {boolean}
+     */
+    static dominates(objectives1, objectives2) {
+        const ptr0 = passArrayF64ToWasm0(objectives1, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArrayF64ToWasm0(objectives2, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmoptimizationutils_dominates(ptr0, len0, ptr1, len1);
+        return ret !== 0;
+    }
+}
+if (Symbol.dispose) WasmOptimizationUtils.prototype[Symbol.dispose] = WasmOptimizationUtils.prototype.free;
+
 const WasmProjectiveSpaceFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_wasmprojectivespace_free(ptr >>> 0, 1));
@@ -3716,7 +4057,7 @@ export class WasmPropagationAnalysis {
      * @returns {number}
      */
     get convergenceTime() {
-        const ret = wasm.wasmpropagationanalysis_convergence_time(this.__wbg_ptr);
+        const ret = wasm.wasmoptimizationresult_iterations(this.__wbg_ptr);
         return ret >>> 0;
     }
     /**
@@ -4228,6 +4569,54 @@ export class WasmSensitivityMap {
 }
 if (Symbol.dispose) WasmSensitivityMap.prototype[Symbol.dispose] = WasmSensitivityMap.prototype.free;
 
+const WasmSimpleOptimizerFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmsimpleoptimizer_free(ptr >>> 0, 1));
+/**
+ * Simple quadratic optimization problem for WASM demonstration
+ */
+export class WasmSimpleOptimizer {
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmSimpleOptimizerFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmsimpleoptimizer_free(ptr, 0);
+    }
+    /**
+     * Optimize a simple quadratic function: minimize sum(c_i * x_i^2)
+     * @param {Float64Array} coefficients
+     * @param {Float64Array} initial_point
+     * @returns {WasmOptimizationResult}
+     */
+    optimizeQuadratic(coefficients, initial_point) {
+        const ptr0 = passArrayF64ToWasm0(coefficients, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArrayF64ToWasm0(initial_point, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmsimpleoptimizer_optimizeQuadratic(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmOptimizationResult.__wrap(ret[0]);
+    }
+    /**
+     * Create a new simple optimizer
+     */
+    constructor() {
+        const ret = wasm.wasmgpuoptimizer_new();
+        this.__wbg_ptr = ret >>> 0;
+        WasmSimpleOptimizerFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+}
+if (Symbol.dispose) WasmSimpleOptimizer.prototype[Symbol.dispose] = WasmSimpleOptimizer.prototype.free;
+
 const WasmSpacetimeVectorFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_wasmspacetimevector_free(ptr >>> 0, 1));
@@ -4883,7 +5272,7 @@ export class WasmTropicalNetwork {
      * @returns {number}
      */
     getSize() {
-        const ret = wasm.wasmtropicalnetwork_getSize(this.__wbg_ptr);
+        const ret = wasm.wasmmultiobjectiveresult_generations(this.__wbg_ptr);
         return ret >>> 0;
     }
     /**
@@ -5095,7 +5484,7 @@ export class WasmTropicalPolynomial {
      * @returns {number}
      */
     coefficients_count() {
-        const ret = wasm.wasmtropicalpolynomial_coefficients_count(this.__wbg_ptr);
+        const ret = wasm.wasmgpuoptimizer_isGpuAvailable(this.__wbg_ptr);
         return ret >>> 0;
     }
     /**
@@ -5235,6 +5624,14 @@ function __wbg_get_imports() {
         const ret = arg0.apply(arg1, arg2);
         return ret;
     }, arguments) };
+    imports.wbg.__wbg_call_13410aac570ffff7 = function() { return handleError(function (arg0, arg1) {
+        const ret = arg0.call(arg1);
+        return ret;
+    }, arguments) };
+    imports.wbg.__wbg_call_a5400b25a865cfd8 = function() { return handleError(function (arg0, arg1, arg2) {
+        const ret = arg0.call(arg1, arg2);
+        return ret;
+    }, arguments) };
     imports.wbg.__wbg_error_7534b8e9a36f1ab4 = function(arg0, arg1) {
         let deferred0_0;
         let deferred0_1;
@@ -5261,7 +5658,7 @@ function __wbg_get_imports() {
     imports.wbg.__wbg_log_6c7b5f4f00b8ce3f = function(arg0) {
         console.log(arg0);
     };
-    imports.wbg.__wbg_log_ebffc6906074deb0 = function(arg0, arg1) {
+    imports.wbg.__wbg_log_a7603c93036d4d3e = function(arg0, arg1) {
         console.log(getStringFromWasm0(arg0, arg1));
     };
     imports.wbg.__wbg_new_19c25a3f2fa63a02 = function() {
@@ -5272,14 +5669,47 @@ function __wbg_get_imports() {
         const ret = new Array();
         return ret;
     };
+    imports.wbg.__wbg_new_2e3c58a15f39f5f9 = function(arg0, arg1) {
+        try {
+            var state0 = {a: arg0, b: arg1};
+            var cb0 = (arg0, arg1) => {
+                const a = state0.a;
+                state0.a = 0;
+                try {
+                    return __wbg_adapter_387(a, state0.b, arg0, arg1);
+                } finally {
+                    state0.a = a;
+                }
+            };
+            const ret = new Promise(cb0);
+            return ret;
+        } finally {
+            state0.a = state0.b = 0;
+        }
+    };
     imports.wbg.__wbg_new_8a6f238a6ece86ea = function() {
         const ret = new Error();
         return ret;
     };
+    imports.wbg.__wbg_newnoargs_254190557c45b4ec = function(arg0, arg1) {
+        const ret = new Function(getStringFromWasm0(arg0, arg1));
+        return ret;
+    };
     imports.wbg.__wbg_push_330b2eb93e4e1212 = function(arg0, arg1) {
         const ret = arg0.push(arg1);
         return ret;
     };
+    imports.wbg.__wbg_queueMicrotask_25d0739ac89e8c88 = function(arg0) {
+        queueMicrotask(arg0);
+    };
+    imports.wbg.__wbg_queueMicrotask_4488407636f5bf24 = function(arg0) {
+        const ret = arg0.queueMicrotask;
+        return ret;
+    };
+    imports.wbg.__wbg_resolve_4055c623acdd6a1b = function(arg0) {
+        const ret = Promise.resolve(arg0);
+        return ret;
+    };
     imports.wbg.__wbg_set_3f1d0b984ed272ed = function(arg0, arg1, arg2) {
         arg0[arg1] = arg2;
     };
@@ -5297,10 +5727,34 @@ function __wbg_get_imports() {
         getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
         getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
     };
+    imports.wbg.__wbg_static_accessor_GLOBAL_8921f820c2ce3f12 = function() {
+        const ret = typeof global === 'undefined' ? null : global;
+        return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+    };
+    imports.wbg.__wbg_static_accessor_GLOBAL_THIS_f0a4409105898184 = function() {
+        const ret = typeof globalThis === 'undefined' ? null : globalThis;
+        return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+    };
+    imports.wbg.__wbg_static_accessor_SELF_995b214ae681ff99 = function() {
+        const ret = typeof self === 'undefined' ? null : self;
+        return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+    };
+    imports.wbg.__wbg_static_accessor_WINDOW_cde3890479c675ea = function() {
+        const ret = typeof window === 'undefined' ? null : window;
+        return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+    };
+    imports.wbg.__wbg_then_e22500defe16819f = function(arg0, arg1) {
+        const ret = arg0.then(arg1);
+        return ret;
+    };
     imports.wbg.__wbg_wasmcommunity_new = function(arg0) {
         const ret = WasmCommunity.__wrap(arg0);
         return ret;
     };
+    imports.wbg.__wbg_wasmoptimizationresult_new = function(arg0) {
+        const ret = WasmOptimizationResult.__wrap(arg0);
+        return ret;
+    };
     imports.wbg.__wbg_wasmspacetimevector_new = function(arg0) {
         const ret = WasmSpacetimeVector.__wrap(arg0);
         return ret;
@@ -5309,6 +5763,15 @@ function __wbg_get_imports() {
         const ret = WasmTropicalNumber.__wrap(arg0);
         return ret;
     };
+    imports.wbg.__wbg_wbindgencbdrop_eb10308566512b88 = function(arg0) {
+        const obj = arg0.original;
+        if (obj.cnt-- == 1) {
+            obj.a = 0;
+            return true;
+        }
+        const ret = false;
+        return ret;
+    };
     imports.wbg.__wbg_wbindgendebugstring_99ef257a3ddda34d = function(arg0, arg1) {
         const ret = debugString(arg1);
         const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
@@ -5316,6 +5779,14 @@ function __wbg_get_imports() {
         getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
         getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
     };
+    imports.wbg.__wbg_wbindgenisfunction_8cee7dce3725ae74 = function(arg0) {
+        const ret = typeof(arg0) === 'function';
+        return ret;
+    };
+    imports.wbg.__wbg_wbindgenisundefined_c4b71d073b92f3c5 = function(arg0) {
+        const ret = arg0 === undefined;
+        return ret;
+    };
     imports.wbg.__wbg_wbindgennumberget_f74b4c7525ac05cb = function(arg0, arg1) {
         const obj = arg1;
         const ret = typeof(obj) === 'number' ? obj : undefined;
@@ -5335,6 +5806,18 @@ function __wbg_get_imports() {
         const ret = BigInt.asUintN(64, arg0);
         return ret;
     };
+    imports.wbg.__wbindgen_cast_69f35aa0fcaecc47 = function(arg0, arg1) {
+        // Cast intrinsic for `Closure(Closure { dtor_idx: 37, function: Function { arguments: [Externref], shim_idx: 38, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+        const ret = makeMutClosure(arg0, arg1, 37, __wbg_adapter_8);
+        return ret;
+    };
+    imports.wbg.__wbindgen_cast_b63aeb0d85365734 = function(arg0, arg1) {
+        var v0 = getArrayF64FromWasm0(arg0, arg1).slice();
+        wasm.__wbindgen_free(arg0, arg1 * 8, 8);
+        // Cast intrinsic for `Vector(F64) -> Externref`.
+        const ret = v0;
+        return ret;
+    };
     imports.wbg.__wbindgen_cast_d6cd19b81560fd6e = function(arg0) {
         // Cast intrinsic for `F64 -> Externref`.
         const ret = arg0;

package/package.json

@@ -5,7 +5,7 @@
     "Amari Contributors"
   ],
   "description": "WebAssembly bindings for Amari mathematical computing library - geometric algebra, tropical algebra, automatic differentiation, fusion systems, and information geometry",
-  "version": "0.9.6",
+  "version": "0.9.7-1",
   "license": "MIT OR Apache-2.0",
   "repository": {
     "type": "git",