@justinelliottcobb/amari-wasm 0.3.2

package/README.md

@@ -0,0 +1,202 @@
+# @amari/core
+
+🚀 **Advanced Mathematical Computing Library for JavaScript/TypeScript**
+
+[![npm version](https://badge.fury.io/js/%40amari%2Fcore.svg)](https://www.npmjs.com/package/@amari/core)
+[![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.
+
+## ✨ Features
+
+- **🔢 Geometric Algebra (Clifford Algebra)**: Multivectors, rotors, and geometric products for 3D rotations and spatial transformations
+- **🌴 Tropical Algebra**: Max-plus semiring operations for optimization and neural network applications
+- **📈 Automatic Differentiation**: Forward-mode AD with dual numbers for exact derivatives
+- **🔲 Cellular Automata**: Geometric cellular automata with multivector states
+- **⚡ WebGPU Acceleration**: Optional GPU acceleration for large-scale operations
+- **🦀 Pure Rust Implementation**: Memory-safe, high-performance core with WASM bindings
+- **📦 TypeScript Support**: Full TypeScript definitions included
+
+## 📦 Installation
+
+```bash
+npm install @amari/core
+```
+
+Or with yarn:
+
+```bash
+yarn add @amari/core
+```
+
+## 🚀 Quick Start
+
+```typescript
+import init, { WasmMultivector, WasmRotor } from '@amari/core';
+
+async function main() {
+  // Initialize the WASM module
+  await init();
+
+  // Create basis vectors
+  const e1 = WasmMultivector.basis_vector(0);
+  const e2 = WasmMultivector.basis_vector(1);
+
+  // Compute geometric product
+  const product = e1.geometric_product(e2);
+  console.log(product.to_string()); // e12 (bivector)
+
+  // Create a rotor for 90-degree rotation
+  const rotor = WasmRotor.from_axis_angle(
+    WasmMultivector.basis_vector(2), // z-axis
+    Math.PI / 2
+  );
+
+  // Rotate a vector
+  const vector = WasmMultivector.from_coefficients(
+    new Float64Array([1, 0, 0, 0, 0, 0, 0, 0])
+  );
+  const rotated = rotor.rotate_vector(vector);
+
+  // Clean up WASM memory
+  e1.free();
+  e2.free();
+  product.free();
+  rotor.free();
+  vector.free();
+  rotated.free();
+}
+
+main();
+```
+
+## 📚 Core Concepts
+
+### Geometric Algebra
+
+Geometric algebra extends linear algebra with the geometric product, enabling intuitive representation of rotations, reflections, and other transformations:
+
+```typescript
+// Multivector operations
+const v1 = WasmMultivector.from_coefficients(coeffs);
+const v2 = WasmMultivector.random();
+
+const sum = v1.add(v2);
+const product = v1.geometric_product(v2);
+const wedge = v1.wedge_product(v2);
+const inner = v1.inner_product(v2);
+```
+
+### Tropical Algebra
+
+Tropical algebra replaces addition with max and multiplication with addition, useful for optimization:
+
+```typescript
+import { tropical_add, tropical_multiply } from '@amari/core';
+
+// Tropical operations: add = max, multiply = add
+const a = 5.0, b = 3.0;
+const trop_sum = tropical_add(a, b); // max(5, 3) = 5
+const trop_prod = tropical_multiply(a, b); // 5 + 3 = 8
+```
+
+### Cellular Automata
+
+Create and evolve cellular automata with geometric algebra states:
+
+```typescript
+const ca = WasmGeometricCA.new(100, 100);
+
+// Set initial configuration
+ca.set_cell(50, 50, WasmMultivector.basis_vector(0));
+
+// Evolve the system
+for (let i = 0; i < 100; i++) {
+  ca.step();
+}
+
+console.log(`Generation: ${ca.generation()}`);
+```
+
+## 🎯 Use Cases
+
+- **Computer Graphics**: 3D rotations and transformations using rotors
+- **Physics Simulations**: Geometric algebra for electromagnetic fields
+- **Machine Learning**: Tropical neural networks and automatic differentiation
+- **Optimization**: Tropical algebra for shortest path and scheduling problems
+- **Scientific Computing**: High-performance mathematical operations
+- **Game Development**: Efficient spatial transformations and physics
+
+## 🔧 API Reference
+
+### Multivector Operations
+
+- `WasmMultivector.basis_vector(index)`: Create a basis vector
+- `WasmMultivector.scalar(value)`: Create a scalar multivector
+- `WasmMultivector.from_coefficients(array)`: Create from coefficients
+- `geometric_product(a, b)`: Compute geometric product
+- `wedge_product(a, b)`: Compute wedge (outer) product
+- `inner_product(a, b)`: Compute inner product
+
+### Rotor Operations
+
+- `WasmRotor.from_axis_angle(axis, angle)`: Create rotation rotor
+- `WasmRotor.from_bivector(bivector, angle)`: Create from bivector
+- `rotate_vector(vector)`: Apply rotation to vector
+- `compose(other)`: Compose rotations
+
+### Tropical Operations
+
+- `tropical_add(a, b)`: Tropical addition (max)
+- `tropical_multiply(a, b)`: Tropical multiplication (addition)
+- `tropical_power(base, exp)`: Tropical exponentiation
+
+## 🔍 Examples
+
+Check out the [examples directory](https://github.com/justinelliottcobb/Amari/tree/master/examples) for more detailed usage:
+
+- [Basic Geometric Algebra](https://github.com/justinelliottcobb/Amari/blob/master/examples/typescript/geometric.ts)
+- [3D Rotations with Rotors](https://github.com/justinelliottcobb/Amari/blob/master/examples/typescript/rotations.ts)
+- [Tropical Neural Networks](https://github.com/justinelliottcobb/Amari/blob/master/examples/typescript/tropical.ts)
+- [Cellular Automata](https://github.com/justinelliottcobb/Amari/blob/master/examples/typescript/cellular.ts)
+
+## 🏗️ Building from Source
+
+```bash
+# Clone the repository
+git clone https://github.com/justinelliottcobb/Amari.git
+cd Amari/amari-wasm
+
+# Install dependencies
+npm install
+
+# Build WASM module
+npm run build
+
+# Run tests
+npm test
+```
+
+## 🤝 Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request. See [CONTRIBUTING.md](https://github.com/justinelliottcobb/Amari/blob/master/CONTRIBUTING.md) for details.
+
+## 📄 License
+
+MIT License - see [LICENSE](https://github.com/justinelliottcobb/Amari/blob/master/LICENSE) for details.
+
+## 🙏 Acknowledgments
+
+- Built with Rust and wasm-bindgen
+- Inspired by geometric algebra libraries like GAViewer and Ganja.js
+- Tropical algebra concepts from discrete mathematics
+
+## 📬 Contact
+
+- GitHub: [@justinelliottcobb](https://github.com/justinelliottcobb)
+- NPM: [@amari/core](https://www.npmjs.com/package/@amari/core)
+
+---
+
+**Made with ❤️ and 🦀 by the Amari team**

package/amari_wasm.d.ts

@@ -0,0 +1,200 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * Initialize the WASM module
+ */
+export function init(): void;
+/**
+ * Batch operations for performance
+ */
+export class BatchOperations {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Batch geometric product: compute a[i] * b[i] for all i
+   */
+  static batchGeometricProduct(a_batch: Float64Array, b_batch: Float64Array): Float64Array;
+  /**
+   * Batch addition
+   */
+  static batchAdd(a_batch: Float64Array, b_batch: Float64Array): Float64Array;
+}
+/**
+ * WASM wrapper for Multivector with TypedArray support
+ */
+export class WasmMultivector {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Create a new zero multivector
+   */
+  constructor();
+  /**
+   * Create from a Float64Array of coefficients
+   */
+  static fromCoefficients(coefficients: Float64Array): WasmMultivector;
+  /**
+   * Create a scalar multivector
+   */
+  static scalar(value: number): WasmMultivector;
+  /**
+   * Create a basis vector (0-indexed)
+   */
+  static basisVector(index: number): WasmMultivector;
+  /**
+   * Get coefficients as a Float64Array
+   */
+  getCoefficients(): Float64Array;
+  /**
+   * Get a specific coefficient
+   */
+  getCoefficient(index: number): number;
+  /**
+   * Set a specific coefficient
+   */
+  setCoefficient(index: number, value: number): void;
+  /**
+   * Geometric product
+   */
+  geometricProduct(other: WasmMultivector): WasmMultivector;
+  /**
+   * Inner product (dot product for vectors)
+   */
+  innerProduct(other: WasmMultivector): WasmMultivector;
+  /**
+   * Outer product (wedge product)
+   */
+  outerProduct(other: WasmMultivector): WasmMultivector;
+  /**
+   * Scalar product
+   */
+  scalarProduct(other: WasmMultivector): number;
+  /**
+   * Reverse
+   */
+  reverse(): WasmMultivector;
+  /**
+   * Grade projection
+   */
+  gradeProjection(grade: number): WasmMultivector;
+  /**
+   * Exponential (for bivectors to create rotors)
+   */
+  exp(): WasmMultivector;
+  /**
+   * Compute magnitude
+   */
+  magnitude(): number;
+  /**
+   * Compute norm (alias for magnitude, maintained for compatibility)
+   */
+  norm(): number;
+  /**
+   * Normalize
+   */
+  normalize(): WasmMultivector;
+  /**
+   * Compute inverse
+   */
+  inverse(): WasmMultivector;
+  /**
+   * Add two multivectors
+   */
+  add(other: WasmMultivector): WasmMultivector;
+  /**
+   * Subtract two multivectors
+   */
+  sub(other: WasmMultivector): WasmMultivector;
+  /**
+   * Scale by a scalar
+   */
+  scale(scalar: number): WasmMultivector;
+}
+/**
+ * Rotor operations for WASM
+ */
+export class WasmRotor {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Create a rotor from a bivector and angle
+   */
+  static fromBivector(bivector: WasmMultivector, angle: number): WasmRotor;
+  /**
+   * Apply rotor to a multivector
+   */
+  apply(mv: WasmMultivector): WasmMultivector;
+  /**
+   * Compose two rotors
+   */
+  compose(other: WasmRotor): WasmRotor;
+  /**
+   * Get inverse rotor
+   */
+  inverse(): WasmRotor;
+}
+
+export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
+
+export interface InitOutput {
+  readonly memory: WebAssembly.Memory;
+  readonly __wbg_wasmmultivector_free: (a: number, b: number) => void;
+  readonly wasmmultivector_new: () => number;
+  readonly wasmmultivector_fromCoefficients: (a: number, b: number) => [number, number, number];
+  readonly wasmmultivector_scalar: (a: number) => number;
+  readonly wasmmultivector_basisVector: (a: number) => [number, number, number];
+  readonly wasmmultivector_getCoefficients: (a: number) => [number, number];
+  readonly wasmmultivector_getCoefficient: (a: number, b: number) => number;
+  readonly wasmmultivector_setCoefficient: (a: number, b: number, c: number) => void;
+  readonly wasmmultivector_geometricProduct: (a: number, b: number) => number;
+  readonly wasmmultivector_innerProduct: (a: number, b: number) => number;
+  readonly wasmmultivector_outerProduct: (a: number, b: number) => number;
+  readonly wasmmultivector_scalarProduct: (a: number, b: number) => number;
+  readonly wasmmultivector_reverse: (a: number) => number;
+  readonly wasmmultivector_gradeProjection: (a: number, b: number) => number;
+  readonly wasmmultivector_exp: (a: number) => number;
+  readonly wasmmultivector_magnitude: (a: number) => number;
+  readonly wasmmultivector_normalize: (a: number) => [number, number, number];
+  readonly wasmmultivector_inverse: (a: number) => [number, number, number];
+  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 wasmmultivector_norm: (a: number) => number;
+  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 __externref_table_dealloc: (a: number) => void;
+  readonly __wbindgen_free: (a: number, b: number, c: number) => void;
+  readonly __wbindgen_start: () => void;
+}
+
+export type SyncInitInput = BufferSource | WebAssembly.Module;
+/**
+* Instantiates the given `module`, which can either be bytes or
+* a precompiled `WebAssembly.Module`.
+*
+* @param {{ module: SyncInitInput }} module - Passing `SyncInitInput` directly is deprecated.
+*
+* @returns {InitOutput}
+*/
+export function initSync(module: { module: SyncInitInput } | SyncInitInput): InitOutput;
+
+/**
+* If `module_or_path` is {RequestInfo} or {URL}, makes a request and
+* for everything else, calls `WebAssembly.instantiate` directly.
+*
+* @param {{ module_or_path: InitInput | Promise<InitInput> }} module_or_path - Passing `InitInput` directly is deprecated.
+*
+* @returns {Promise<InitOutput>}
+*/
+export default function __wbg_init (module_or_path?: { module_or_path: InitInput | Promise<InitInput> } | InitInput | Promise<InitInput>): Promise<InitOutput>;

package/amari_wasm.js

@@ -0,0 +1,568 @@
+let wasm;
+
+let cachedUint8ArrayMemory0 = null;
+
+function getUint8ArrayMemory0() {
+    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8ArrayMemory0;
+}
+
+let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+
+cachedTextDecoder.decode();
+
+const MAX_SAFARI_DECODE_BYTES = 2146435072;
+let numBytesDecoded = 0;
+function decodeText(ptr, len) {
+    numBytesDecoded += len;
+    if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
+        cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+        cachedTextDecoder.decode();
+        numBytesDecoded = len;
+    }
+    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+
+function getStringFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return decodeText(ptr, len);
+}
+
+let cachedFloat64ArrayMemory0 = null;
+
+function getFloat64ArrayMemory0() {
+    if (cachedFloat64ArrayMemory0 === null || cachedFloat64ArrayMemory0.byteLength === 0) {
+        cachedFloat64ArrayMemory0 = new Float64Array(wasm.memory.buffer);
+    }
+    return cachedFloat64ArrayMemory0;
+}
+
+let WASM_VECTOR_LEN = 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;
+}
+
+function takeFromExternrefTable0(idx) {
+    const value = wasm.__wbindgen_export_0.get(idx);
+    wasm.__externref_table_dealloc(idx);
+    return value;
+}
+
+function getArrayF64FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getFloat64ArrayMemory0().subarray(ptr / 8, ptr / 8 + len);
+}
+
+function _assertClass(instance, klass) {
+    if (!(instance instanceof klass)) {
+        throw new Error(`expected instance of ${klass.name}`);
+    }
+}
+/**
+ * Initialize the WASM module
+ */
+export function init() {
+    wasm.init();
+}
+
+const BatchOperationsFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_batchoperations_free(ptr >>> 0, 1));
+/**
+ * Batch operations for performance
+ */
+export class BatchOperations {
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        BatchOperationsFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_batchoperations_free(ptr, 0);
+    }
+    /**
+     * Batch geometric product: compute a[i] * b[i] for all i
+     * @param {Float64Array} a_batch
+     * @param {Float64Array} b_batch
+     * @returns {Float64Array}
+     */
+    static batchGeometricProduct(a_batch, b_batch) {
+        const ptr0 = passArrayF64ToWasm0(a_batch, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArrayF64ToWasm0(b_batch, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.batchoperations_batchGeometricProduct(ptr0, len0, ptr1, len1);
+        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;
+    }
+    /**
+     * Batch addition
+     * @param {Float64Array} a_batch
+     * @param {Float64Array} b_batch
+     * @returns {Float64Array}
+     */
+    static batchAdd(a_batch, b_batch) {
+        const ptr0 = passArrayF64ToWasm0(a_batch, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArrayF64ToWasm0(b_batch, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.batchoperations_batchAdd(ptr0, len0, ptr1, len1);
+        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;
+    }
+}
+if (Symbol.dispose) BatchOperations.prototype[Symbol.dispose] = BatchOperations.prototype.free;
+
+const WasmMultivectorFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmmultivector_free(ptr >>> 0, 1));
+/**
+ * WASM wrapper for Multivector with TypedArray support
+ */
+export class WasmMultivector {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(WasmMultivector.prototype);
+        obj.__wbg_ptr = ptr;
+        WasmMultivectorFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmMultivectorFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmmultivector_free(ptr, 0);
+    }
+    /**
+     * Create a new zero multivector
+     */
+    constructor() {
+        const ret = wasm.wasmmultivector_new();
+        this.__wbg_ptr = ret >>> 0;
+        WasmMultivectorFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Create from a Float64Array of coefficients
+     * @param {Float64Array} coefficients
+     * @returns {WasmMultivector}
+     */
+    static fromCoefficients(coefficients) {
+        const ptr0 = passArrayF64ToWasm0(coefficients, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmmultivector_fromCoefficients(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmMultivector.__wrap(ret[0]);
+    }
+    /**
+     * Create a scalar multivector
+     * @param {number} value
+     * @returns {WasmMultivector}
+     */
+    static scalar(value) {
+        const ret = wasm.wasmmultivector_scalar(value);
+        return WasmMultivector.__wrap(ret);
+    }
+    /**
+     * Create a basis vector (0-indexed)
+     * @param {number} index
+     * @returns {WasmMultivector}
+     */
+    static basisVector(index) {
+        const ret = wasm.wasmmultivector_basisVector(index);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmMultivector.__wrap(ret[0]);
+    }
+    /**
+     * Get coefficients as a Float64Array
+     * @returns {Float64Array}
+     */
+    getCoefficients() {
+        const ret = wasm.wasmmultivector_getCoefficients(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * Get a specific coefficient
+     * @param {number} index
+     * @returns {number}
+     */
+    getCoefficient(index) {
+        const ret = wasm.wasmmultivector_getCoefficient(this.__wbg_ptr, index);
+        return ret;
+    }
+    /**
+     * Set a specific coefficient
+     * @param {number} index
+     * @param {number} value
+     */
+    setCoefficient(index, value) {
+        wasm.wasmmultivector_setCoefficient(this.__wbg_ptr, index, value);
+    }
+    /**
+     * Geometric product
+     * @param {WasmMultivector} other
+     * @returns {WasmMultivector}
+     */
+    geometricProduct(other) {
+        _assertClass(other, WasmMultivector);
+        const ret = wasm.wasmmultivector_geometricProduct(this.__wbg_ptr, other.__wbg_ptr);
+        return WasmMultivector.__wrap(ret);
+    }
+    /**
+     * Inner product (dot product for vectors)
+     * @param {WasmMultivector} other
+     * @returns {WasmMultivector}
+     */
+    innerProduct(other) {
+        _assertClass(other, WasmMultivector);
+        const ret = wasm.wasmmultivector_innerProduct(this.__wbg_ptr, other.__wbg_ptr);
+        return WasmMultivector.__wrap(ret);
+    }
+    /**
+     * Outer product (wedge product)
+     * @param {WasmMultivector} other
+     * @returns {WasmMultivector}
+     */
+    outerProduct(other) {
+        _assertClass(other, WasmMultivector);
+        const ret = wasm.wasmmultivector_outerProduct(this.__wbg_ptr, other.__wbg_ptr);
+        return WasmMultivector.__wrap(ret);
+    }
+    /**
+     * Scalar product
+     * @param {WasmMultivector} other
+     * @returns {number}
+     */
+    scalarProduct(other) {
+        _assertClass(other, WasmMultivector);
+        const ret = wasm.wasmmultivector_scalarProduct(this.__wbg_ptr, other.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Reverse
+     * @returns {WasmMultivector}
+     */
+    reverse() {
+        const ret = wasm.wasmmultivector_reverse(this.__wbg_ptr);
+        return WasmMultivector.__wrap(ret);
+    }
+    /**
+     * Grade projection
+     * @param {number} grade
+     * @returns {WasmMultivector}
+     */
+    gradeProjection(grade) {
+        const ret = wasm.wasmmultivector_gradeProjection(this.__wbg_ptr, grade);
+        return WasmMultivector.__wrap(ret);
+    }
+    /**
+     * Exponential (for bivectors to create rotors)
+     * @returns {WasmMultivector}
+     */
+    exp() {
+        const ret = wasm.wasmmultivector_exp(this.__wbg_ptr);
+        return WasmMultivector.__wrap(ret);
+    }
+    /**
+     * Compute magnitude
+     * @returns {number}
+     */
+    magnitude() {
+        const ret = wasm.wasmmultivector_magnitude(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Compute norm (alias for magnitude, maintained for compatibility)
+     * @returns {number}
+     */
+    norm() {
+        const ret = wasm.wasmmultivector_magnitude(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Normalize
+     * @returns {WasmMultivector}
+     */
+    normalize() {
+        const ret = wasm.wasmmultivector_normalize(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmMultivector.__wrap(ret[0]);
+    }
+    /**
+     * Compute inverse
+     * @returns {WasmMultivector}
+     */
+    inverse() {
+        const ret = wasm.wasmmultivector_inverse(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmMultivector.__wrap(ret[0]);
+    }
+    /**
+     * Add two multivectors
+     * @param {WasmMultivector} other
+     * @returns {WasmMultivector}
+     */
+    add(other) {
+        _assertClass(other, WasmMultivector);
+        const ret = wasm.wasmmultivector_add(this.__wbg_ptr, other.__wbg_ptr);
+        return WasmMultivector.__wrap(ret);
+    }
+    /**
+     * Subtract two multivectors
+     * @param {WasmMultivector} other
+     * @returns {WasmMultivector}
+     */
+    sub(other) {
+        _assertClass(other, WasmMultivector);
+        const ret = wasm.wasmmultivector_sub(this.__wbg_ptr, other.__wbg_ptr);
+        return WasmMultivector.__wrap(ret);
+    }
+    /**
+     * Scale by a scalar
+     * @param {number} scalar
+     * @returns {WasmMultivector}
+     */
+    scale(scalar) {
+        const ret = wasm.wasmmultivector_scale(this.__wbg_ptr, scalar);
+        return WasmMultivector.__wrap(ret);
+    }
+}
+if (Symbol.dispose) WasmMultivector.prototype[Symbol.dispose] = WasmMultivector.prototype.free;
+
+const WasmRotorFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmrotor_free(ptr >>> 0, 1));
+/**
+ * Rotor operations for WASM
+ */
+export class WasmRotor {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(WasmRotor.prototype);
+        obj.__wbg_ptr = ptr;
+        WasmRotorFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmRotorFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmrotor_free(ptr, 0);
+    }
+    /**
+     * Create a rotor from a bivector and angle
+     * @param {WasmMultivector} bivector
+     * @param {number} angle
+     * @returns {WasmRotor}
+     */
+    static fromBivector(bivector, angle) {
+        _assertClass(bivector, WasmMultivector);
+        const ret = wasm.wasmrotor_fromBivector(bivector.__wbg_ptr, angle);
+        return WasmRotor.__wrap(ret);
+    }
+    /**
+     * Apply rotor to a multivector
+     * @param {WasmMultivector} mv
+     * @returns {WasmMultivector}
+     */
+    apply(mv) {
+        _assertClass(mv, WasmMultivector);
+        const ret = wasm.wasmrotor_apply(this.__wbg_ptr, mv.__wbg_ptr);
+        return WasmMultivector.__wrap(ret);
+    }
+    /**
+     * Compose two rotors
+     * @param {WasmRotor} other
+     * @returns {WasmRotor}
+     */
+    compose(other) {
+        _assertClass(other, WasmRotor);
+        const ret = wasm.wasmrotor_compose(this.__wbg_ptr, other.__wbg_ptr);
+        return WasmRotor.__wrap(ret);
+    }
+    /**
+     * Get inverse rotor
+     * @returns {WasmRotor}
+     */
+    inverse() {
+        const ret = wasm.wasmmultivector_reverse(this.__wbg_ptr);
+        return WasmRotor.__wrap(ret);
+    }
+}
+if (Symbol.dispose) WasmRotor.prototype[Symbol.dispose] = WasmRotor.prototype.free;
+
+const EXPECTED_RESPONSE_TYPES = new Set(['basic', 'cors', 'default']);
+
+async function __wbg_load(module, imports) {
+    if (typeof Response === 'function' && module instanceof Response) {
+        if (typeof WebAssembly.instantiateStreaming === 'function') {
+            try {
+                return await WebAssembly.instantiateStreaming(module, imports);
+
+            } catch (e) {
+                const validResponse = module.ok && EXPECTED_RESPONSE_TYPES.has(module.type);
+
+                if (validResponse && module.headers.get('Content-Type') !== 'application/wasm') {
+                    console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve Wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e);
+
+                } else {
+                    throw e;
+                }
+            }
+        }
+
+        const bytes = await module.arrayBuffer();
+        return await WebAssembly.instantiate(bytes, imports);
+
+    } else {
+        const instance = await WebAssembly.instantiate(module, imports);
+
+        if (instance instanceof WebAssembly.Instance) {
+            return { instance, module };
+
+        } else {
+            return instance;
+        }
+    }
+}
+
+function __wbg_get_imports() {
+    const imports = {};
+    imports.wbg = {};
+    imports.wbg.__wbg_log_6123108905c49def = function(arg0, arg1) {
+        console.log(getStringFromWasm0(arg0, arg1));
+    };
+    imports.wbg.__wbg_wbindgenthrow_451ec1a8469d7eb6 = function(arg0, arg1) {
+        throw new Error(getStringFromWasm0(arg0, arg1));
+    };
+    imports.wbg.__wbindgen_cast_2241b6af4c4b2941 = function(arg0, arg1) {
+        // Cast intrinsic for `Ref(String) -> Externref`.
+        const ret = getStringFromWasm0(arg0, arg1);
+        return ret;
+    };
+    imports.wbg.__wbindgen_init_externref_table = function() {
+        const table = wasm.__wbindgen_export_0;
+        const offset = table.grow(4);
+        table.set(0, undefined);
+        table.set(offset + 0, undefined);
+        table.set(offset + 1, null);
+        table.set(offset + 2, true);
+        table.set(offset + 3, false);
+        ;
+    };
+
+    return imports;
+}
+
+function __wbg_init_memory(imports, memory) {
+
+}
+
+function __wbg_finalize_init(instance, module) {
+    wasm = instance.exports;
+    __wbg_init.__wbindgen_wasm_module = module;
+    cachedFloat64ArrayMemory0 = null;
+    cachedUint8ArrayMemory0 = null;
+
+
+    wasm.__wbindgen_start();
+    return wasm;
+}
+
+function initSync(module) {
+    if (wasm !== undefined) return wasm;
+
+
+    if (typeof module !== 'undefined') {
+        if (Object.getPrototypeOf(module) === Object.prototype) {
+            ({module} = module)
+        } else {
+            console.warn('using deprecated parameters for `initSync()`; pass a single object instead')
+        }
+    }
+
+    const imports = __wbg_get_imports();
+
+    __wbg_init_memory(imports);
+
+    if (!(module instanceof WebAssembly.Module)) {
+        module = new WebAssembly.Module(module);
+    }
+
+    const instance = new WebAssembly.Instance(module, imports);
+
+    return __wbg_finalize_init(instance, module);
+}
+
+async function __wbg_init(module_or_path) {
+    if (wasm !== undefined) return wasm;
+
+
+    if (typeof module_or_path !== 'undefined') {
+        if (Object.getPrototypeOf(module_or_path) === Object.prototype) {
+            ({module_or_path} = module_or_path)
+        } else {
+            console.warn('using deprecated parameters for the initialization function; pass a single object instead')
+        }
+    }
+
+    if (typeof module_or_path === 'undefined') {
+        module_or_path = new URL('amari_wasm_bg.wasm', import.meta.url);
+    }
+    const imports = __wbg_get_imports();
+
+    if (typeof module_or_path === 'string' || (typeof Request === 'function' && module_or_path instanceof Request) || (typeof URL === 'function' && module_or_path instanceof URL)) {
+        module_or_path = fetch(module_or_path);
+    }
+
+    __wbg_init_memory(imports);
+
+    const { instance, module } = await __wbg_load(await module_or_path, imports);
+
+    return __wbg_finalize_init(instance, module);
+}
+
+export { initSync };
+export default __wbg_init;

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@justinelliottcobb/amari-wasm",
+  "type": "module",
+  "collaborators": [
+    "Amari Contributors"
+  ],
+  "description": "WebAssembly bindings for Amari mathematical computing library",
+  "version": "0.3.2",
+  "license": "MIT OR Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/justinelliottcobb/Amari"
+  },
+  "files": [
+    "amari_wasm_bg.wasm",
+    "amari_wasm.js",
+    "amari_wasm.d.ts"
+  ],
+  "main": "amari_wasm.js",
+  "homepage": "https://github.com/justinelliottcobb/Amari",
+  "types": "amari_wasm.d.ts",
+  "sideEffects": [
+    "./snippets/*"
+  ],
+  "keywords": [
+    "wasm",
+    "webassembly",
+    "geometric-algebra",
+    "mathematics",
+    "javascript"
+  ]
+}