@justinelliottcobb/amari-wasm 0.8.7 → 0.9.1

package/README.md

@@ -1,24 +1,32 @@
-# @justinelliottcobb/amari-wasm v0.4.0
+# @justinelliottcobb/amari-wasm v0.9.0
 
-🚀 **Unified Mathematical Computing Library for JavaScript/TypeScript**
+**Unified Mathematical Computing Library with High-Precision WebAssembly Support**
 
 [![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 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.
+Amari is a comprehensive mathematical computing library that brings advanced algebraic systems to JavaScript/TypeScript through WebAssembly, now with full high-precision arithmetic support for spacecraft orbital mechanics and relativistic physics calculations. Features pure Rust implementation with no native dependencies for universal deployment.
 
-## ✨ Features
+## 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
+### New in v0.9.0: High-Precision WebAssembly
+- **Spacecraft Orbital Mechanics**: Full-precision trajectory calculations now available in browsers
+- **Relativistic Physics**: Spacetime algebra (Cl(1,3)) with WebAssembly-compatible precision
+- **Pure Rust Backend**: dashu-powered arithmetic with no native dependencies
+- **Universal Deployment**: Same precision guarantees across desktop, web, and edge environments
+- **WebAssembly 3.0 Ready**: Leverages latest WASM features for enhanced mathematical computing
 
-## 📦 Installation
+### Core Mathematical Systems
+- **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
@@ -30,7 +38,7 @@ Or with yarn:
 yarn add @amari/core
 ```
 
-## 🚀 Quick Start
+## Quick Start
 
 ```typescript
 import init, { WasmMultivector, WasmRotor } from '@amari/core';
@@ -71,7 +79,63 @@ async function main() {
 main();
 ```
 
-## 📚 Core Concepts
+## High-Precision Orbital Mechanics (New in v0.9.0)
+
+```typescript
+import init, {
+  WasmSpacetimeVector,
+  WasmFourVelocity,
+  WasmRelativisticParticle,
+  WasmSchwarzschildMetric
+} from '@amari/core';
+
+async function spacecraftSimulation() {
+  await init();
+
+  // Create Earth's gravitational field
+  const earth = WasmSchwarzschildMetric.earth();
+
+  // Spacecraft at 400km altitude (ISS orbit)
+  const altitude = 400e3; // 400 km
+  const earthRadius = 6.371e6; // Earth radius in meters
+  const position = new Float64Array([earthRadius + altitude, 0.0, 0.0]);
+  const velocity = new Float64Array([0.0, 7.67e3, 0.0]); // ~7.67 km/s orbital velocity
+
+  // Create spacecraft with high-precision arithmetic
+  const spacecraft = WasmRelativisticParticle.new(
+    position,
+    velocity,
+    0.0,    // No charge
+    1000.0, // 1000 kg spacecraft
+    0.0     // No magnetic charge
+  );
+
+  // Propagate orbit for one complete period with high precision
+  const orbitalPeriod = 5580.0; // ~93 minutes
+  const timeStep = 60.0; // 1-minute time steps
+
+  // High-precision geodesic integration using dashu backend
+  const trajectory = spacecraft.propagate_trajectory(
+    earth,
+    orbitalPeriod,
+    timeStep
+  );
+
+  console.log(`Orbital trajectory computed with ${trajectory.length} points`);
+  console.log(`Final position deviation: ${spacecraft.position_error()} meters`);
+
+  // WebAssembly precision matches native accuracy!
+
+  // Clean up WASM memory
+  earth.free();
+  spacecraft.free();
+  trajectory.forEach(point => point.free());
+}
+
+spacecraftSimulation();
+```
+
+## Core Concepts
 
 ### Geometric Algebra
 
@@ -119,7 +183,7 @@ for (let i = 0; i < 100; i++) {
 console.log(`Generation: ${ca.generation()}`);
 ```
 
-## 🎯 Use Cases
+## Use Cases
 
 - **Computer Graphics**: 3D rotations and transformations using rotors
 - **Physics Simulations**: Geometric algebra for electromagnetic fields
@@ -128,7 +192,7 @@ console.log(`Generation: ${ca.generation()}`);
 - **Scientific Computing**: High-performance mathematical operations
 - **Game Development**: Efficient spatial transformations and physics
 
-## 🔧 API Reference
+## API Reference
 
 ### Multivector Operations
 
@@ -199,4 +263,4 @@ MIT License - see [LICENSE](https://github.com/justinelliottcobb/Amari/blob/mast
 
 ---
 
-**Made with ❤️ and 🦀 by the Amari team**
+**Made with Rust by the Amari team**

package/amari_wasm.d.ts

@@ -29,21 +29,21 @@ export class PerformanceOperations {
   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
+   * Batch normalize vectors for efficiency
    */
-  static vectorCrossProduct(v1: Float64Array, v2: Float64Array): Float64Array;
+  static batchNormalize(vectors: Float64Array, vector_size: number): Float64Array;
   /**
    * Optimized vector dot product
    */
   static vectorDotProduct(v1: Float64Array, v2: Float64Array): number;
   /**
-   * Batch normalize vectors for efficiency
+   * Optimized vector operations for 3D space
    */
-  static batchNormalize(vectors: Float64Array, vector_size: number): Float64Array;
+  static vectorCrossProduct(v1: Float64Array, v2: Float64Array): Float64Array;
+  /**
+   * Fast geometric product for hot paths with memory pooling
+   */
+  static fastGeometricProduct(lhs: Float64Array, rhs: Float64Array): Float64Array;
 }
 /**
  * WASM wrapper for Multivector with TypedArray support
@@ -52,25 +52,21 @@ export class WasmMultivector {
   free(): void;
   [Symbol.dispose](): void;
   /**
-   * Create a new zero multivector
-   */
-  constructor();
-  /**
-   * Create from a Float64Array of coefficients
+   * Create a basis vector (0-indexed)
    */
-  static fromCoefficients(coefficients: Float64Array): WasmMultivector;
+  static basisVector(index: number): WasmMultivector;
   /**
-   * Create a scalar multivector
+   * Inner product (dot product for vectors)
    */
-  static scalar(value: number): WasmMultivector;
+  innerProduct(other: WasmMultivector): WasmMultivector;
   /**
-   * Create a basis vector (0-indexed)
+   * Outer product (wedge product)
    */
-  static basisVector(index: number): WasmMultivector;
+  outerProduct(other: WasmMultivector): WasmMultivector;
   /**
-   * Get coefficients as a Float64Array
+   * Scalar product
    */
-  getCoefficients(): Float64Array;
+  scalarProduct(other: WasmMultivector): number;
   /**
    * Get a specific coefficient
    */
@@ -80,61 +76,65 @@ export class WasmMultivector {
    */
   setCoefficient(index: number, value: number): void;
   /**
-   * Geometric product
-   */
-  geometricProduct(other: WasmMultivector): WasmMultivector;
-  /**
-   * Inner product (dot product for vectors)
+   * Get coefficients as a Float64Array
    */
-  innerProduct(other: WasmMultivector): WasmMultivector;
+  getCoefficients(): Float64Array;
   /**
-   * Outer product (wedge product)
+   * Grade projection
    */
-  outerProduct(other: WasmMultivector): WasmMultivector;
+  gradeProjection(grade: number): WasmMultivector;
   /**
-   * Scalar product
+   * Create from a Float64Array of coefficients
    */
-  scalarProduct(other: WasmMultivector): number;
+  static fromCoefficients(coefficients: Float64Array): WasmMultivector;
   /**
-   * Reverse
+   * Geometric product
    */
-  reverse(): WasmMultivector;
+  geometricProduct(other: WasmMultivector): WasmMultivector;
   /**
-   * Grade projection
+   * Add two multivectors
    */
-  gradeProjection(grade: number): WasmMultivector;
+  add(other: WasmMultivector): WasmMultivector;
   /**
    * Exponential (for bivectors to create rotors)
    */
   exp(): WasmMultivector;
   /**
-   * Compute magnitude
+   * Create a new zero multivector
    */
-  magnitude(): number;
+  constructor();
+  /**
+   * Subtract two multivectors
+   */
+  sub(other: WasmMultivector): WasmMultivector;
   /**
    * Compute norm (alias for magnitude, maintained for compatibility)
    */
   norm(): number;
   /**
-   * Normalize
+   * Scale by a scalar
    */
-  normalize(): WasmMultivector;
+  scale(scalar: number): WasmMultivector;
+  /**
+   * Create a scalar multivector
+   */
+  static scalar(value: number): WasmMultivector;
   /**
    * Compute inverse
    */
   inverse(): WasmMultivector;
   /**
-   * Add two multivectors
+   * Reverse
    */
-  add(other: WasmMultivector): WasmMultivector;
+  reverse(): WasmMultivector;
   /**
-   * Subtract two multivectors
+   * Compute magnitude
    */
-  sub(other: WasmMultivector): WasmMultivector;
+  magnitude(): number;
   /**
-   * Scale by a scalar
+   * Normalize
    */
-  scale(scalar: number): WasmMultivector;
+  normalize(): WasmMultivector;
 }
 /**
  * Rotor operations for WASM
@@ -165,38 +165,38 @@ export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembl
 
 export interface InitOutput {
   readonly memory: WebAssembly.Memory;
+  readonly __wbg_batchoperations_free: (a: number, b: number) => void;
   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 batchoperations_batchAdd: (a: number, b: number, c: number, d: number) => [number, number, number, number];
+  readonly batchoperations_batchGeometricProduct: (a: number, b: number, c: number, d: number) => [number, number, number, number];
+  readonly init: () => void;
+  readonly performanceoperations_batchNormalize: (a: number, b: number, c: number) => [number, number];
+  readonly performanceoperations_fastGeometricProduct: (a: number, b: number, c: number, d: number) => [number, number];
+  readonly performanceoperations_vectorCrossProduct: (a: number, b: number, c: number, d: number) => [number, number];
+  readonly performanceoperations_vectorDotProduct: (a: number, b: number, c: number, d: number) => number;
+  readonly wasmmultivector_add: (a: number, b: 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_exp: (a: number) => number;
+  readonly wasmmultivector_fromCoefficients: (a: number, b: number) => [number, number, number];
   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_getCoefficient: (a: number, b: number) => number;
+  readonly wasmmultivector_getCoefficients: (a: number) => [number, number];
   readonly wasmmultivector_gradeProjection: (a: number, b: number) => number;
-  readonly wasmmultivector_exp: (a: number) => number;
+  readonly wasmmultivector_innerProduct: (a: number, b: number) => number;
+  readonly wasmmultivector_inverse: (a: number) => [number, number, number];
   readonly wasmmultivector_magnitude: (a: number) => number;
+  readonly wasmmultivector_new: () => 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_outerProduct: (a: number, b: number) => number;
+  readonly wasmmultivector_reverse: (a: number) => number;
+  readonly wasmmultivector_scalar: (a: number) => number;
+  readonly wasmmultivector_scalarProduct: (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 wasmmultivector_setCoefficient: (a: number, b: number, c: number) => void;
+  readonly wasmmultivector_sub: (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 wasmrotor_fromBivector: (a: number, b: number) => number;
   readonly wasmmultivector_norm: (a: number) => number;
   readonly __wbg_performanceoperations_free: (a: number, b: number) => void;
   readonly wasmrotor_inverse: (a: number) => number;

package/amari_wasm.js

@@ -152,64 +152,64 @@ export class PerformanceOperations {
         wasm.__wbg_performanceoperations_free(ptr, 0);
     }
     /**
-     * Fast geometric product for hot paths with memory pooling
-     * @param {Float64Array} lhs
-     * @param {Float64Array} rhs
+     * Batch normalize vectors for efficiency
+     * @param {Float64Array} vectors
+     * @param {number} vector_size
      * @returns {Float64Array}
      */
-    static fastGeometricProduct(lhs, rhs) {
-        const ptr0 = passArrayF64ToWasm0(lhs, wasm.__wbindgen_malloc);
+    static batchNormalize(vectors, vector_size) {
+        const ptr0 = passArrayF64ToWasm0(vectors, 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();
+        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 v3;
+        return v2;
     }
     /**
-     * Optimized vector operations for 3D space
+     * Optimized vector dot product
      * @param {Float64Array} v1
      * @param {Float64Array} v2
-     * @returns {Float64Array}
+     * @returns {number}
      */
-    static vectorCrossProduct(v1, v2) {
+    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_vectorCrossProduct(ptr0, len0, ptr1, len1);
-        var v3 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
-        return v3;
+        const ret = wasm.performanceoperations_vectorDotProduct(ptr0, len0, ptr1, len1);
+        return ret;
     }
     /**
-     * Optimized vector dot product
+     * Optimized vector operations for 3D space
      * @param {Float64Array} v1
      * @param {Float64Array} v2
-     * @returns {number}
+     * @returns {Float64Array}
      */
-    static vectorDotProduct(v1, v2) {
+    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_vectorDotProduct(ptr0, len0, ptr1, len1);
-        return ret;
+        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;
     }
     /**
-     * Batch normalize vectors for efficiency
-     * @param {Float64Array} vectors
-     * @param {number} vector_size
+     * Fast geometric product for hot paths with memory pooling
+     * @param {Float64Array} lhs
+     * @param {Float64Array} rhs
      * @returns {Float64Array}
      */
-    static batchNormalize(vectors, vector_size) {
-        const ptr0 = passArrayF64ToWasm0(vectors, wasm.__wbindgen_malloc);
+    static fastGeometricProduct(lhs, rhs) {
+        const ptr0 = passArrayF64ToWasm0(lhs, 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();
+        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 v2;
+        return v3;
     }
 }
 if (Symbol.dispose) PerformanceOperations.prototype[Symbol.dispose] = PerformanceOperations.prototype.free;
@@ -242,58 +242,46 @@ export class WasmMultivector {
         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
+     * Create a basis vector (0-indexed)
+     * @param {number} index
      * @returns {WasmMultivector}
      */
-    static fromCoefficients(coefficients) {
-        const ptr0 = passArrayF64ToWasm0(coefficients, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.wasmmultivector_fromCoefficients(ptr0, len0);
+    static basisVector(index) {
+        const ret = wasm.wasmmultivector_basisVector(index);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
         return WasmMultivector.__wrap(ret[0]);
     }
     /**
-     * Create a scalar multivector
-     * @param {number} value
+     * Inner product (dot product for vectors)
+     * @param {WasmMultivector} other
      * @returns {WasmMultivector}
      */
-    static scalar(value) {
-        const ret = wasm.wasmmultivector_scalar(value);
+    innerProduct(other) {
+        _assertClass(other, WasmMultivector);
+        const ret = wasm.wasmmultivector_innerProduct(this.__wbg_ptr, other.__wbg_ptr);
         return WasmMultivector.__wrap(ret);
     }
     /**
-     * Create a basis vector (0-indexed)
-     * @param {number} index
+     * Outer product (wedge product)
+     * @param {WasmMultivector} other
      * @returns {WasmMultivector}
      */
-    static basisVector(index) {
-        const ret = wasm.wasmmultivector_basisVector(index);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return WasmMultivector.__wrap(ret[0]);
+    outerProduct(other) {
+        _assertClass(other, WasmMultivector);
+        const ret = wasm.wasmmultivector_outerProduct(this.__wbg_ptr, other.__wbg_ptr);
+        return WasmMultivector.__wrap(ret);
     }
     /**
-     * Get coefficients as a Float64Array
-     * @returns {Float64Array}
+     * Scalar product
+     * @param {WasmMultivector} other
+     * @returns {number}
      */
-    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;
+    scalarProduct(other) {
+        _assertClass(other, WasmMultivector);
+        const ret = wasm.wasmmultivector_scalarProduct(this.__wbg_ptr, other.__wbg_ptr);
+        return ret;
     }
     /**
      * Get a specific coefficient
@@ -313,96 +301,110 @@ export class WasmMultivector {
         wasm.wasmmultivector_setCoefficient(this.__wbg_ptr, index, value);
     }
     /**
-     * Geometric product
-     * @param {WasmMultivector} other
+     * 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;
+    }
+    /**
+     * Grade projection
+     * @param {number} grade
      * @returns {WasmMultivector}
      */
-    geometricProduct(other) {
-        _assertClass(other, WasmMultivector);
-        const ret = wasm.wasmmultivector_geometricProduct(this.__wbg_ptr, other.__wbg_ptr);
+    gradeProjection(grade) {
+        const ret = wasm.wasmmultivector_gradeProjection(this.__wbg_ptr, grade);
         return WasmMultivector.__wrap(ret);
     }
     /**
-     * Inner product (dot product for vectors)
-     * @param {WasmMultivector} other
+     * Create from a Float64Array of coefficients
+     * @param {Float64Array} coefficients
      * @returns {WasmMultivector}
      */
-    innerProduct(other) {
-        _assertClass(other, WasmMultivector);
-        const ret = wasm.wasmmultivector_innerProduct(this.__wbg_ptr, other.__wbg_ptr);
-        return WasmMultivector.__wrap(ret);
+    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]);
     }
     /**
-     * Outer product (wedge product)
+     * Geometric product
      * @param {WasmMultivector} other
      * @returns {WasmMultivector}
      */
-    outerProduct(other) {
+    geometricProduct(other) {
         _assertClass(other, WasmMultivector);
-        const ret = wasm.wasmmultivector_outerProduct(this.__wbg_ptr, other.__wbg_ptr);
+        const ret = wasm.wasmmultivector_geometricProduct(this.__wbg_ptr, other.__wbg_ptr);
         return WasmMultivector.__wrap(ret);
     }
     /**
-     * Scalar product
+     * Add two multivectors
      * @param {WasmMultivector} other
-     * @returns {number}
+     * @returns {WasmMultivector}
      */
-    scalarProduct(other) {
+    add(other) {
         _assertClass(other, WasmMultivector);
-        const ret = wasm.wasmmultivector_scalarProduct(this.__wbg_ptr, other.__wbg_ptr);
-        return ret;
+        const ret = wasm.wasmmultivector_add(this.__wbg_ptr, other.__wbg_ptr);
+        return WasmMultivector.__wrap(ret);
     }
     /**
-     * Reverse
+     * Exponential (for bivectors to create rotors)
      * @returns {WasmMultivector}
      */
-    reverse() {
-        const ret = wasm.wasmmultivector_reverse(this.__wbg_ptr);
+    exp() {
+        const ret = wasm.wasmmultivector_exp(this.__wbg_ptr);
         return WasmMultivector.__wrap(ret);
     }
     /**
-     * Grade projection
-     * @param {number} grade
-     * @returns {WasmMultivector}
+     * Create a new zero multivector
      */
-    gradeProjection(grade) {
-        const ret = wasm.wasmmultivector_gradeProjection(this.__wbg_ptr, grade);
-        return WasmMultivector.__wrap(ret);
+    constructor() {
+        const ret = wasm.wasmmultivector_new();
+        this.__wbg_ptr = ret >>> 0;
+        WasmMultivectorFinalization.register(this, this.__wbg_ptr, this);
+        return this;
     }
     /**
-     * Exponential (for bivectors to create rotors)
+     * Subtract two multivectors
+     * @param {WasmMultivector} other
      * @returns {WasmMultivector}
      */
-    exp() {
-        const ret = wasm.wasmmultivector_exp(this.__wbg_ptr);
+    sub(other) {
+        _assertClass(other, WasmMultivector);
+        const ret = wasm.wasmmultivector_sub(this.__wbg_ptr, other.__wbg_ptr);
         return WasmMultivector.__wrap(ret);
     }
     /**
-     * Compute magnitude
+     * Compute norm (alias for magnitude, maintained for compatibility)
      * @returns {number}
      */
-    magnitude() {
+    norm() {
         const ret = wasm.wasmmultivector_magnitude(this.__wbg_ptr);
         return ret;
     }
     /**
-     * Compute norm (alias for magnitude, maintained for compatibility)
-     * @returns {number}
+     * Scale by a scalar
+     * @param {number} scalar
+     * @returns {WasmMultivector}
      */
-    norm() {
-        const ret = wasm.wasmmultivector_magnitude(this.__wbg_ptr);
-        return ret;
+    scale(scalar) {
+        const ret = wasm.wasmmultivector_scale(this.__wbg_ptr, scalar);
+        return WasmMultivector.__wrap(ret);
     }
     /**
-     * Normalize
+     * Create a scalar multivector
+     * @param {number} value
      * @returns {WasmMultivector}
      */
-    normalize() {
-        const ret = wasm.wasmmultivector_normalize(this.__wbg_ptr);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return WasmMultivector.__wrap(ret[0]);
+    static scalar(value) {
+        const ret = wasm.wasmmultivector_scalar(value);
+        return WasmMultivector.__wrap(ret);
     }
     /**
      * Compute inverse
@@ -416,33 +418,31 @@ export class WasmMultivector {
         return WasmMultivector.__wrap(ret[0]);
     }
     /**
-     * Add two multivectors
-     * @param {WasmMultivector} other
+     * Reverse
      * @returns {WasmMultivector}
      */
-    add(other) {
-        _assertClass(other, WasmMultivector);
-        const ret = wasm.wasmmultivector_add(this.__wbg_ptr, other.__wbg_ptr);
+    reverse() {
+        const ret = wasm.wasmmultivector_reverse(this.__wbg_ptr);
         return WasmMultivector.__wrap(ret);
     }
     /**
-     * Subtract two multivectors
-     * @param {WasmMultivector} other
-     * @returns {WasmMultivector}
+     * Compute magnitude
+     * @returns {number}
      */
-    sub(other) {
-        _assertClass(other, WasmMultivector);
-        const ret = wasm.wasmmultivector_sub(this.__wbg_ptr, other.__wbg_ptr);
-        return WasmMultivector.__wrap(ret);
+    magnitude() {
+        const ret = wasm.wasmmultivector_magnitude(this.__wbg_ptr);
+        return ret;
     }
     /**
-     * Scale by a scalar
-     * @param {number} scalar
+     * Normalize
      * @returns {WasmMultivector}
      */
-    scale(scalar) {
-        const ret = wasm.wasmmultivector_scale(this.__wbg_ptr, scalar);
-        return WasmMultivector.__wrap(ret);
+    normalize() {
+        const ret = wasm.wasmmultivector_normalize(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmMultivector.__wrap(ret[0]);
     }
 }
 if (Symbol.dispose) WasmMultivector.prototype[Symbol.dispose] = WasmMultivector.prototype.free;
@@ -554,7 +554,7 @@ async function __wbg_load(module, imports) {
 function __wbg_get_imports() {
     const imports = {};
     imports.wbg = {};
-    imports.wbg.__wbg_log_525d713278963643 = function(arg0, arg1) {
+    imports.wbg.__wbg_log_fb67a0d730fc146e = function(arg0, arg1) {
         console.log(getStringFromWasm0(arg0, arg1));
     };
     imports.wbg.__wbg_wbindgenthrow_451ec1a8469d7eb6 = function(arg0, arg1) {

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