@justinelliottcobb/amari-wasm 0.4.0 → 0.7.0

package/amari_wasm.d.ts

@@ -29,6 +29,7 @@ export class BatchOperations {
   [Symbol.dispose](): void;
   /**
    * Batch geometric product: compute a[i] * b[i] for all i
+   * Optimized for WebAssembly performance with reduced allocations
    */
   static batchGeometricProduct(a_batch: Float64Array, b_batch: Float64Array): Float64Array;
   /**
@@ -89,6 +90,30 @@ export class InfoGeomUtils {
    */
   static randomSimplex(dimension: number): Float64Array;
 }
+/**
+ * High-performance WASM operations with memory pooling
+ */
+export class PerformanceOperations {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Fast geometric product for hot paths with memory pooling
+   */
+  static fastGeometricProduct(lhs: Float64Array, rhs: Float64Array): Float64Array;
+  /**
+   * Optimized vector operations for 3D space
+   */
+  static vectorCrossProduct(v1: Float64Array, v2: Float64Array): Float64Array;
+  /**
+   * Optimized vector dot product
+   */
+  static vectorDotProduct(v1: Float64Array, v2: Float64Array): number;
+  /**
+   * Batch normalize vectors for efficiency
+   */
+  static batchNormalize(vectors: Float64Array, vector_size: number): Float64Array;
+}
 /**
  * Batch operations for tropical numbers
  */
@@ -669,6 +694,10 @@ export interface InitOutput {
   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 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 performanceoperations_batchNormalize: (a: number, b: number, c: number) => [number, number];
   readonly init: () => void;
   readonly wasmtropicalnumber_new: (a: number) => number;
   readonly wasmmultivector_norm: (a: number) => number;
@@ -683,6 +712,7 @@ export interface InitOutput {
   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 __wbg_performanceoperations_free: (a: number, b: number) => void;
   readonly wasmrotor_inverse: (a: number) => number;
   readonly __wbg_wasmrotor_free: (a: number, b: number) => void;
   readonly __wbindgen_exn_store: (a: number) => void;

package/amari_wasm.js

@@ -168,6 +168,7 @@ export class BatchOperations {
     }
     /**
      * Batch geometric product: compute a[i] * b[i] for all i
+     * Optimized for WebAssembly performance with reduced allocations
      * @param {Float64Array} a_batch
      * @param {Float64Array} b_batch
      * @returns {Float64Array}
@@ -390,6 +391,88 @@ export class InfoGeomUtils {
 }
 if (Symbol.dispose) InfoGeomUtils.prototype[Symbol.dispose] = InfoGeomUtils.prototype.free;
 
+const PerformanceOperationsFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_performanceoperations_free(ptr >>> 0, 1));
+/**
+ * High-performance WASM operations with memory pooling
+ */
+export class PerformanceOperations {
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        PerformanceOperationsFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_performanceoperations_free(ptr, 0);
+    }
+    /**
+     * Fast geometric product for hot paths with memory pooling
+     * @param {Float64Array} lhs
+     * @param {Float64Array} rhs
+     * @returns {Float64Array}
+     */
+    static fastGeometricProduct(lhs, rhs) {
+        const ptr0 = passArrayF64ToWasm0(lhs, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArrayF64ToWasm0(rhs, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.performanceoperations_fastGeometricProduct(ptr0, len0, ptr1, len1);
+        var v3 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v3;
+    }
+    /**
+     * Optimized vector operations for 3D space
+     * @param {Float64Array} v1
+     * @param {Float64Array} v2
+     * @returns {Float64Array}
+     */
+    static vectorCrossProduct(v1, v2) {
+        const ptr0 = passArrayF64ToWasm0(v1, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArrayF64ToWasm0(v2, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.performanceoperations_vectorCrossProduct(ptr0, len0, ptr1, len1);
+        var v3 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v3;
+    }
+    /**
+     * Optimized vector dot product
+     * @param {Float64Array} v1
+     * @param {Float64Array} v2
+     * @returns {number}
+     */
+    static vectorDotProduct(v1, v2) {
+        const ptr0 = passArrayF64ToWasm0(v1, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArrayF64ToWasm0(v2, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.performanceoperations_vectorDotProduct(ptr0, len0, ptr1, len1);
+        return ret;
+    }
+    /**
+     * Batch normalize vectors for efficiency
+     * @param {Float64Array} vectors
+     * @param {number} vector_size
+     * @returns {Float64Array}
+     */
+    static batchNormalize(vectors, vector_size) {
+        const ptr0 = passArrayF64ToWasm0(vectors, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.performanceoperations_batchNormalize(ptr0, len0, vector_size);
+        var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v2;
+    }
+}
+if (Symbol.dispose) PerformanceOperations.prototype[Symbol.dispose] = PerformanceOperations.prototype.free;
+
 const TropicalBatchFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_tropicalbatch_free(ptr >>> 0, 1));
@@ -1697,7 +1780,7 @@ function __wbg_get_imports() {
         const ret = arg0.apply(arg1, arg2);
         return ret;
     }, arguments) };
-    imports.wbg.__wbg_log_7d5bd3f05c55b7ed = function(arg0, arg1) {
+    imports.wbg.__wbg_log_2855aa4ea73e1eff = function(arg0, arg1) {
         console.log(getStringFromWasm0(arg0, arg1));
     };
     imports.wbg.__wbg_new_1f3a344cf3123716 = function() {

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.4.0",
+  "version": "0.7.0",
   "license": "MIT OR Apache-2.0",
   "repository": {
     "type": "git",