@justinelliottcobb/amari-wasm 0.10.0 → 0.11.0

package/amari_wasm.d.ts

@@ -340,6 +340,58 @@ export class InfoGeomUtils {
    */
   static normalize(values: Float64Array): Float64Array;
 }
+/**
+ * Numerical integration operations
+ *
+ * Provides definite integrals, line integrals, and surface integrals
+ * using adaptive quadrature.
+ */
+export class Integration {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Compute 1D definite integral using Simpson's rule
+   *
+   * ∫[a,b] f(x) dx
+   *
+   * # Arguments
+   *
+   * * `func` - JavaScript function to integrate
+   * * `a` - Lower bound
+   * * `b` - Upper bound
+   * * `n` - Number of subdivisions (must be even)
+   *
+   * # Returns
+   *
+   * Integral value
+   *
+   * # JavaScript Example
+   *
+   * ```javascript
+   * // Integrate x^2 from 0 to 1
+   * const result = Integration.integrate1D(x => x*x, 0, 1, 100);
+   * // Returns approximately 0.333...
+   * ```
+   */
+  static integrate1D(func: Function, a: number, b: number, n: number): number;
+  /**
+   * Compute 2D integral over a rectangle using Simpson's rule
+   *
+   * ∫∫[a,b]×[c,d] f(x,y) dx dy
+   *
+   * # Arguments
+   *
+   * * `func` - JavaScript function (x, y) => f(x, y)
+   * * `ax` - Lower x bound
+   * * `bx` - Upper x bound
+   * * `ay` - Lower y bound
+   * * `by` - Upper y bound
+   * * `nx` - Number of x subdivisions (must be even)
+   * * `ny` - Number of y subdivisions (must be even)
+   */
+  static integrate2D(func: Function, ax: number, bx: number, ay: number, by: number, nx: number, ny: number): number;
+}
 /**
  * Advanced machine learning operations using dual numbers
  */
@@ -384,6 +436,92 @@ export class NetworkUtils {
    */
   static createSmallWorldNetwork(num_nodes: number, k: number, beta: number): WasmGeometricNetwork;
 }
+/**
+ * Numerical derivative operations
+ *
+ * Provides gradient, divergence, curl, and Laplacian computations
+ * using centered finite differences.
+ */
+export class NumericalDerivative {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Compute divergence of a vector field at a point
+   *
+   * ∇·F = ∂Fx/∂x + ∂Fy/∂y + ∂Fz/∂z
+   *
+   * # Arguments
+   *
+   * * `field` - Vector field
+   * * `point` - Evaluation point
+   *
+   * # Returns
+   *
+   * Divergence (scalar)
+   */
+  divergence(field: VectorField, point: Float64Array): number;
+  /**
+   * Create a new numerical derivative computer
+   *
+   * # Arguments
+   *
+   * * `step_size` - Optional step size for finite differences (default: 1e-5)
+   */
+  constructor(step_size?: number | null);
+  /**
+   * Compute curl of a 3D vector field at a point
+   *
+   * ∇×F = [∂Fz/∂y - ∂Fy/∂z, ∂Fx/∂z - ∂Fz/∂x, ∂Fy/∂x - ∂Fx/∂y]
+   *
+   * # Arguments
+   *
+   * * `field` - 3D vector field
+   * * `point` - Evaluation point [x, y, z]
+   *
+   * # Returns
+   *
+   * Curl vector [cx, cy, cz]
+   */
+  curl(field: VectorField, point: Float64Array): Float64Array;
+  /**
+   * Compute gradient of a scalar field at a point
+   *
+   * ∇f = [∂f/∂x, ∂f/∂y, ∂f/∂z]
+   *
+   * # Arguments
+   *
+   * * `field` - Scalar field
+   * * `point` - Evaluation point
+   *
+   * # Returns
+   *
+   * Gradient vector
+   *
+   * # JavaScript Example
+   *
+   * ```javascript
+   * const field = ScalarField.fromFunction2D((x, y) => x*x + y*y);
+   * const derivative = new NumericalDerivative();
+   * const grad = derivative.gradient(field, [1.0, 2.0]); // Returns [2.0, 4.0]
+   * ```
+   */
+  gradient(field: ScalarField, point: Float64Array): Float64Array;
+  /**
+   * Compute Laplacian of a scalar field at a point
+   *
+   * ∇²f = ∂²f/∂x² + ∂²f/∂y² + ∂²f/∂z²
+   *
+   * # Arguments
+   *
+   * * `field` - Scalar field
+   * * `point` - Evaluation point
+   *
+   * # Returns
+   *
+   * Laplacian (scalar)
+   */
+  laplacian(field: ScalarField, point: Float64Array): number;
+}
 /**
  * High-performance WASM operations with memory pooling
  */
@@ -408,6 +546,184 @@ export class PerformanceOperations {
    */
   static fastGeometricProduct(lhs: Float64Array, rhs: Float64Array): Float64Array;
 }
+/**
+ * Riemannian manifold with metric tensor
+ *
+ * Represents a curved space with a metric that defines distances and angles.
+ *
+ * # JavaScript Example
+ *
+ * ```javascript
+ * // Create a 2D sphere of radius 1
+ * const sphere = RiemannianManifold.sphere(1.0);
+ *
+ * // Compute scalar curvature at the north pole
+ * const R = sphere.scalarCurvature([0.0, 0.0]); // Returns 2.0 for unit sphere
+ * ```
+ */
+export class RiemannianManifold {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Create a 2D hyperbolic plane (Poincaré half-plane model)
+   *
+   * Metric: ds² = (dx² + dy²) / y²
+   */
+  static hyperbolic(): RiemannianManifold;
+  /**
+   * Compute Christoffel symbol Γ^k_ij at a point
+   *
+   * # Arguments
+   *
+   * * `k` - Upper index
+   * * `i` - First lower index
+   * * `j` - Second lower index
+   * * `coords` - Coordinates
+   */
+  christoffel(k: number, i: number, j: number, coords: Float64Array): number;
+  /**
+   * Compute Ricci tensor component R_ij
+   *
+   * # Arguments
+   *
+   * * `i` - First index
+   * * `j` - Second index
+   * * `coords` - Coordinates
+   */
+  ricciTensor(i: number, j: number, coords: Float64Array): number;
+  /**
+   * Compute Riemann curvature tensor component R^i_jkl
+   *
+   * # Arguments
+   *
+   * * `i` - Upper index
+   * * `j` - First lower index
+   * * `k` - Second lower index
+   * * `l` - Third lower index
+   * * `coords` - Coordinates
+   */
+  riemannTensor(i: number, j: number, k: number, l: number, coords: Float64Array): number;
+  /**
+   * Compute scalar curvature R
+   *
+   * # Arguments
+   *
+   * * `coords` - Coordinates
+   *
+   * # Returns
+   *
+   * Scalar curvature value
+   */
+  scalarCurvature(coords: Float64Array): number;
+  /**
+   * Create a 2D sphere of given radius
+   *
+   * Metric: ds² = dθ² + sin²θ dφ²
+   *
+   * # Arguments
+   *
+   * * `radius` - Sphere radius
+   */
+  static sphere(radius: number): RiemannianManifold;
+  /**
+   * Compute geodesic trajectory
+   *
+   * Solves the geodesic equations using RK4 integration.
+   *
+   * # Arguments
+   *
+   * * `initial_pos` - Initial position
+   * * `initial_vel` - Initial velocity
+   * * `t_max` - Maximum time
+   * * `dt` - Time step
+   *
+   * # Returns
+   *
+   * Flat array of trajectory points and velocities:
+   * [x0, y0, vx0, vy0, x1, y1, vx1, vy1, ...]
+   */
+  geodesic(initial_pos: Float64Array, initial_vel: Float64Array, t_max: number, dt: number): Float64Array;
+  /**
+   * Create a Euclidean (flat) manifold
+   *
+   * # Arguments
+   *
+   * * `dimension` - Dimension (2 or 3)
+   */
+  static euclidean(dimension: number): RiemannianManifold;
+  /**
+   * Get the dimension of the manifold
+   */
+  readonly dimension: number;
+}
+/**
+ * Scalar field f: ℝⁿ → ℝ
+ *
+ * Represents a function that maps points in n-dimensional space to real numbers.
+ *
+ * # JavaScript Example
+ *
+ * ```javascript
+ * // Create a scalar field f(x, y) = x² + y²
+ * const field = WasmScalarField.fromFunction2D((x, y) => x*x + y*y);
+ *
+ * // Evaluate at a point
+ * const value = field.evaluate([1.0, 2.0]); // Returns 5.0
+ * ```
+ */
+export class ScalarField {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Batch evaluate the field at multiple points
+   *
+   * # Arguments
+   *
+   * * `points` - Array of points as flat array [x1, y1, x2, y2, ...]
+   *
+   * # Returns
+   *
+   * Array of field values
+   */
+  batchEvaluate(points: Float64Array): Float64Array;
+  /**
+   * Create a 2D scalar field from a JavaScript function
+   *
+   * # Arguments
+   *
+   * * `func` - JavaScript function (x, y) => f(x, y)
+   */
+  static fromFunction2D(func: Function): ScalarField;
+  /**
+   * Create a 3D scalar field from a JavaScript function
+   *
+   * # Arguments
+   *
+   * * `func` - JavaScript function (x, y, z) => f(x, y, z)
+   */
+  static fromFunction3D(func: Function): ScalarField;
+  /**
+   * Create a 2D scalar field from a JavaScript function
+   *
+   * # Arguments
+   *
+   * * `func` - JavaScript function (x, y) => f(x, y)
+   */
+  constructor(func: Function, dimension: number);
+  /**
+   * Evaluate the scalar field at a point
+   *
+   * # Arguments
+   *
+   * * `point` - Coordinates [x, y] or [x, y, z]
+   *
+   * # Returns
+   *
+   * Field value at the point
+   */
+  evaluate(point: Float64Array): number;
+}
 /**
  * Batch operations for tropical numbers
  */
@@ -452,6 +768,57 @@ export class TropicalMLOps {
    */
   static convexCombination(values: Float64Array, weights: Float64Array): number;
 }
+/**
+ * Vector field F: ℝⁿ → ℝⁿ
+ *
+ * Represents a function that maps points to vectors.
+ *
+ * # JavaScript Example
+ *
+ * ```javascript
+ * // Create a 2D vector field F(x, y) = [y, -x] (rotation)
+ * const field = WasmVectorField.fromFunction2D((x, y) => [y, -x]);
+ *
+ * // Evaluate at a point
+ * const vector = field.evaluate([1.0, 2.0]); // Returns [2.0, -1.0]
+ * ```
+ */
+export class VectorField {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Create a 2D vector field from a JavaScript function
+   *
+   * # Arguments
+   *
+   * * `func` - JavaScript function (x, y) => [fx, fy]
+   */
+  static fromFunction2D(func: Function): VectorField;
+  /**
+   * Create a 3D vector field from a JavaScript function
+   *
+   * # Arguments
+   *
+   * * `func` - JavaScript function (x, y, z) => [fx, fy, fz]
+   */
+  static fromFunction3D(func: Function): VectorField;
+  /**
+   * Create a vector field from a JavaScript function
+   */
+  constructor(func: Function, dimension: number);
+  /**
+   * Evaluate the vector field at a point
+   *
+   * # Arguments
+   *
+   * * `point` - Coordinates [x, y] or [x, y, z]
+   *
+   * # Returns
+   *
+   * Vector at the point
+   */
+  evaluate(point: Float64Array): Float64Array;
+}
 /**
  * WASM wrapper for AlphaConnection
  */
@@ -2085,8 +2452,10 @@ export interface InitOutput {
   readonly memory: WebAssembly.Memory;
   readonly __wbg_autodiff_free: (a: number, b: number) => void;
   readonly __wbg_get_wasmtrajectorypoint_time: (a: number) => number;
+  readonly __wbg_numericalderivative_free: (a: number, b: number) => void;
+  readonly __wbg_riemannianmanifold_free: (a: number, b: number) => void;
+  readonly __wbg_scalarfield_free: (a: number, b: number) => void;
   readonly __wbg_set_wasmtrajectorypoint_time: (a: number, b: number) => void;
-  readonly __wbg_wasmalphaconnection_free: (a: number, b: number) => void;
   readonly __wbg_wasmchowclass_free: (a: number, b: number) => void;
   readonly __wbg_wasmcommunity_free: (a: number, b: number) => void;
   readonly __wbg_wasmduallyflatmanifold_free: (a: number, b: number) => void;
@@ -2163,6 +2532,8 @@ export interface InitOutput {
   readonly initEnumerative: () => void;
   readonly initFusion: () => void;
   readonly integrate: (a: any, b: number, c: number, d: number, e: number) => [number, number, number];
+  readonly integration_integrate1D: (a: any, b: number, c: number, d: number) => [number, number, number];
+  readonly integration_integrate2D: (a: any, b: number, c: number, d: number, e: number, f: number, g: number) => [number, number, number];
   readonly klDivergence: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => [number, number, number];
   readonly light_deflection_angle: (a: number, b: number) => number;
   readonly mlops_batchActivation: (a: number, b: number, c: number, d: number) => [number, number, number, number];
@@ -2172,10 +2543,29 @@ export interface InitOutput {
   readonly networkutils_clusteringCoefficient: (a: number) => number;
   readonly networkutils_createRandomNetwork: (a: number, b: number) => [number, number, number];
   readonly networkutils_createSmallWorldNetwork: (a: number, b: number, c: number) => [number, number, number];
+  readonly numericalderivative_curl: (a: number, b: number, c: number, d: number) => [number, number, number, number];
+  readonly numericalderivative_divergence: (a: number, b: number, c: number, d: number) => [number, number, number];
+  readonly numericalderivative_gradient: (a: number, b: number, c: number, d: number) => [number, number, number, number];
+  readonly numericalderivative_laplacian: (a: number, b: number, c: number, d: number) => [number, number, number];
+  readonly numericalderivative_new: (a: number, b: number) => number;
   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 riemannianmanifold_christoffel: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number, number];
+  readonly riemannianmanifold_dimension: (a: number) => number;
+  readonly riemannianmanifold_euclidean: (a: number) => [number, number, number];
+  readonly riemannianmanifold_geodesic: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => [number, number, number, number];
+  readonly riemannianmanifold_hyperbolic: () => number;
+  readonly riemannianmanifold_ricciTensor: (a: number, b: number, c: number, d: number, e: number) => [number, number, number];
+  readonly riemannianmanifold_riemannTensor: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => [number, number, number];
+  readonly riemannianmanifold_scalarCurvature: (a: number, b: number, c: number) => [number, number, number];
+  readonly riemannianmanifold_sphere: (a: number) => [number, number, number];
+  readonly scalarfield_batchEvaluate: (a: number, b: number, c: number) => [number, number, number, number];
+  readonly scalarfield_evaluate: (a: number, b: number, c: number) => [number, number, number];
+  readonly scalarfield_fromFunction2D: (a: any) => number;
+  readonly scalarfield_fromFunction3D: (a: any) => number;
+  readonly scalarfield_new: (a: any, b: number) => number;
   readonly tropicalbatch_batchTropicalAdd: (a: number, b: number) => number;
   readonly tropicalbatch_batchTropicalMul: (a: number, b: number) => number;
   readonly tropicalbatch_maxLogProb: (a: number, b: number) => number;
@@ -2184,6 +2574,7 @@ export interface InitOutput {
   readonly tropicalmlops_matrixMultiply: (a: any, b: any) => [number, number, number];
   readonly tropicalmlops_shortestPaths: (a: any) => [number, number, number];
   readonly validate_relativistic_module: () => number;
+  readonly vectorfield_evaluate: (a: number, b: number, c: number) => [number, number, number, number];
   readonly velocity_to_gamma: (a: number) => [number, number, number];
   readonly wasmalphaconnection_getAlpha: (a: number) => number;
   readonly wasmalphaconnection_isExponential: (a: number) => number;
@@ -2351,7 +2742,6 @@ export interface InitOutput {
   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];
@@ -2468,6 +2858,8 @@ export interface InitOutput {
   readonly wasmtropicalviterbi_forward_probabilities: (a: number, b: number, c: number) => [number, number, number];
   readonly wasmtropicalviterbi_new: (a: any, b: any) => [number, number, number];
   readonly wasmtropicalnumber_new: (a: number) => number;
+  readonly vectorfield_fromFunction2D: (a: any) => number;
+  readonly vectorfield_fromFunction3D: (a: any) => number;
   readonly wasmmultivector_norm: (a: number) => number;
   readonly wasmspacetimevector_t: (a: number) => number;
   readonly wasmtropicalnumber_tropicalMul: (a: number, b: number) => number;
@@ -2475,6 +2867,8 @@ export interface InitOutput {
   readonly wasmtropicalpolynomial_coefficients_count: (a: number) => number;
   readonly __wbg_wasmparametricdensity_free: (a: number, b: number) => void;
   readonly __wbg_wasmprobabilitymeasure_free: (a: number, b: number) => void;
+  readonly __wbg_vectorfield_free: (a: number, b: number) => void;
+  readonly vectorfield_new: (a: any, b: number) => number;
   readonly wasmtropicalnumber_tropicalAdd: (a: number, b: number) => number;
   readonly wasmcommunity_cohesion_score: (a: number) => number;
   readonly wasmdualnumber_getReal: (a: number) => number;
@@ -2483,6 +2877,7 @@ export interface InitOutput {
   readonly wasmgeometricedge_weight: (a: number) => number;
   readonly wasmmodulispace_getGenus: (a: number) => number;
   readonly wasmmultidualnumber_getReal: (a: number) => number;
+  readonly wasmoptimizationresult_iterations: (a: number) => number;
   readonly wasmoptimizationresult_objective_value: (a: number) => number;
   readonly wasmprojectivespace_getDimension: (a: number) => number;
   readonly wasmpropagationanalysis_convergence_time: (a: number) => number;
@@ -2502,11 +2897,13 @@ export interface InitOutput {
   readonly __wbg_fusionbatchoperations_free: (a: number, b: number) => void;
   readonly __wbg_fusionutils_free: (a: number, b: number) => void;
   readonly __wbg_infogeomutils_free: (a: number, b: number) => void;
+  readonly __wbg_integration_free: (a: number, b: number) => void;
   readonly __wbg_mlops_free: (a: number, b: number) => void;
   readonly __wbg_networkutils_free: (a: number, b: number) => void;
   readonly __wbg_performanceoperations_free: (a: number, b: number) => void;
   readonly __wbg_tropicalbatch_free: (a: number, b: number) => void;
   readonly __wbg_tropicalmlops_free: (a: number, b: number) => void;
+  readonly __wbg_wasmalphaconnection_free: (a: number, b: number) => void;
   readonly __wbg_wasmcountingmeasure_free: (a: number, b: number) => void;
   readonly __wbg_wasmdualnumber_free: (a: number, b: number) => void;
   readonly __wbg_wasmfourvelocity_free: (a: number, b: number) => void;
@@ -2528,9 +2925,9 @@ export interface InitOutput {
   readonly wasmmultiobjectiveoptimizer_new: () => number;
   readonly wasmsimpleoptimizer_new: () => number;
   readonly wasmtropicalmeasure_new: () => number;
-  readonly wasm_bindgen_83f782f110bf2942___convert__closures_____invoke___wasm_bindgen_83f782f110bf2942___JsValue_____: (a: number, b: number, c: any) => void;
-  readonly wasm_bindgen_83f782f110bf2942___closure__destroy___dyn_core_f622c628fd7f704e___ops__function__FnMut__wasm_bindgen_83f782f110bf2942___JsValue____Output_______: (a: number, b: number) => void;
-  readonly wasm_bindgen_83f782f110bf2942___convert__closures_____invoke___wasm_bindgen_83f782f110bf2942___JsValue__wasm_bindgen_83f782f110bf2942___JsValue_____: (a: number, b: number, c: any, d: any) => void;
+  readonly wasm_bindgen_e07ba2a7d21574bf___convert__closures_____invoke___wasm_bindgen_e07ba2a7d21574bf___JsValue_____: (a: number, b: number, c: any) => void;
+  readonly wasm_bindgen_e07ba2a7d21574bf___closure__destroy___dyn_core_a2b7f04d45112077___ops__function__FnMut__wasm_bindgen_e07ba2a7d21574bf___JsValue____Output_______: (a: number, b: number) => void;
+  readonly wasm_bindgen_e07ba2a7d21574bf___convert__closures_____invoke___wasm_bindgen_e07ba2a7d21574bf___JsValue__wasm_bindgen_e07ba2a7d21574bf___JsValue_____: (a: number, b: number, c: any, d: any) => void;
   readonly __wbindgen_malloc: (a: number, b: number) => number;
   readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
   readonly __wbindgen_exn_store: (a: number) => void;

package/amari_wasm.js

@@ -177,6 +177,20 @@ function handleError(f, args) {
     }
 }
 
+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);
+}
+
 const CLOSURE_DTORS = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(state => state.dtor(state.a, state.b));
@@ -208,20 +222,6 @@ function makeMutClosure(arg0, arg1, dtor, f) {
     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);
-}
 /**
  * Initialize the WASM module
  */
@@ -420,12 +420,12 @@ function passArray32ToWasm0(arg, malloc) {
     WASM_VECTOR_LEN = arg.length;
     return ptr;
 }
-function wasm_bindgen_83f782f110bf2942___convert__closures_____invoke___wasm_bindgen_83f782f110bf2942___JsValue_____(arg0, arg1, arg2) {
-    wasm.wasm_bindgen_83f782f110bf2942___convert__closures_____invoke___wasm_bindgen_83f782f110bf2942___JsValue_____(arg0, arg1, arg2);
+function wasm_bindgen_e07ba2a7d21574bf___convert__closures_____invoke___wasm_bindgen_e07ba2a7d21574bf___JsValue_____(arg0, arg1, arg2) {
+    wasm.wasm_bindgen_e07ba2a7d21574bf___convert__closures_____invoke___wasm_bindgen_e07ba2a7d21574bf___JsValue_____(arg0, arg1, arg2);
 }
 
-function wasm_bindgen_83f782f110bf2942___convert__closures_____invoke___wasm_bindgen_83f782f110bf2942___JsValue__wasm_bindgen_83f782f110bf2942___JsValue_____(arg0, arg1, arg2, arg3) {
-    wasm.wasm_bindgen_83f782f110bf2942___convert__closures_____invoke___wasm_bindgen_83f782f110bf2942___JsValue__wasm_bindgen_83f782f110bf2942___JsValue_____(arg0, arg1, arg2, arg3);
+function wasm_bindgen_e07ba2a7d21574bf___convert__closures_____invoke___wasm_bindgen_e07ba2a7d21574bf___JsValue__wasm_bindgen_e07ba2a7d21574bf___JsValue_____(arg0, arg1, arg2, arg3) {
+    wasm.wasm_bindgen_e07ba2a7d21574bf___convert__closures_____invoke___wasm_bindgen_e07ba2a7d21574bf___JsValue__wasm_bindgen_e07ba2a7d21574bf___JsValue_____(arg0, arg1, arg2, arg3);
 }
 
 /**
@@ -1324,6 +1324,97 @@ export class InfoGeomUtils {
 }
 if (Symbol.dispose) InfoGeomUtils.prototype[Symbol.dispose] = InfoGeomUtils.prototype.free;
 
+const IntegrationFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_integration_free(ptr >>> 0, 1));
+/**
+ * Numerical integration operations
+ *
+ * Provides definite integrals, line integrals, and surface integrals
+ * using adaptive quadrature.
+ */
+export class Integration {
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        IntegrationFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_integration_free(ptr, 0);
+    }
+    /**
+     * Compute 1D definite integral using Simpson's rule
+     *
+     * ∫[a,b] f(x) dx
+     *
+     * # Arguments
+     *
+     * * `func` - JavaScript function to integrate
+     * * `a` - Lower bound
+     * * `b` - Upper bound
+     * * `n` - Number of subdivisions (must be even)
+     *
+     * # Returns
+     *
+     * Integral value
+     *
+     * # JavaScript Example
+     *
+     * ```javascript
+     * // Integrate x^2 from 0 to 1
+     * const result = Integration.integrate1D(x => x*x, 0, 1, 100);
+     * // Returns approximately 0.333...
+     * ```
+     * @param {Function} func
+     * @param {number} a
+     * @param {number} b
+     * @param {number} n
+     * @returns {number}
+     */
+    static integrate1D(func, a, b, n) {
+        const ret = wasm.integration_integrate1D(func, a, b, n);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0];
+    }
+    /**
+     * Compute 2D integral over a rectangle using Simpson's rule
+     *
+     * ∫∫[a,b]×[c,d] f(x,y) dx dy
+     *
+     * # Arguments
+     *
+     * * `func` - JavaScript function (x, y) => f(x, y)
+     * * `ax` - Lower x bound
+     * * `bx` - Upper x bound
+     * * `ay` - Lower y bound
+     * * `by` - Upper y bound
+     * * `nx` - Number of x subdivisions (must be even)
+     * * `ny` - Number of y subdivisions (must be even)
+     * @param {Function} func
+     * @param {number} ax
+     * @param {number} bx
+     * @param {number} ay
+     * @param {number} by
+     * @param {number} nx
+     * @param {number} ny
+     * @returns {number}
+     */
+    static integrate2D(func, ax, bx, ay, by, nx, ny) {
+        const ret = wasm.integration_integrate2D(func, ax, bx, ay, by, nx, ny);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0];
+    }
+}
+if (Symbol.dispose) Integration.prototype[Symbol.dispose] = Integration.prototype.free;
+
 const MLOpsFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_mlops_free(ptr >>> 0, 1));
@@ -1474,6 +1565,165 @@ export class NetworkUtils {
 }
 if (Symbol.dispose) NetworkUtils.prototype[Symbol.dispose] = NetworkUtils.prototype.free;
 
+const NumericalDerivativeFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_numericalderivative_free(ptr >>> 0, 1));
+/**
+ * Numerical derivative operations
+ *
+ * Provides gradient, divergence, curl, and Laplacian computations
+ * using centered finite differences.
+ */
+export class NumericalDerivative {
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        NumericalDerivativeFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_numericalderivative_free(ptr, 0);
+    }
+    /**
+     * Compute divergence of a vector field at a point
+     *
+     * ∇·F = ∂Fx/∂x + ∂Fy/∂y + ∂Fz/∂z
+     *
+     * # Arguments
+     *
+     * * `field` - Vector field
+     * * `point` - Evaluation point
+     *
+     * # Returns
+     *
+     * Divergence (scalar)
+     * @param {VectorField} field
+     * @param {Float64Array} point
+     * @returns {number}
+     */
+    divergence(field, point) {
+        _assertClass(field, VectorField);
+        const ptr0 = passArrayF64ToWasm0(point, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.numericalderivative_divergence(this.__wbg_ptr, field.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0];
+    }
+    /**
+     * Create a new numerical derivative computer
+     *
+     * # Arguments
+     *
+     * * `step_size` - Optional step size for finite differences (default: 1e-5)
+     * @param {number | null} [step_size]
+     */
+    constructor(step_size) {
+        const ret = wasm.numericalderivative_new(!isLikeNone(step_size), isLikeNone(step_size) ? 0 : step_size);
+        this.__wbg_ptr = ret >>> 0;
+        NumericalDerivativeFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Compute curl of a 3D vector field at a point
+     *
+     * ∇×F = [∂Fz/∂y - ∂Fy/∂z, ∂Fx/∂z - ∂Fz/∂x, ∂Fy/∂x - ∂Fx/∂y]
+     *
+     * # Arguments
+     *
+     * * `field` - 3D vector field
+     * * `point` - Evaluation point [x, y, z]
+     *
+     * # Returns
+     *
+     * Curl vector [cx, cy, cz]
+     * @param {VectorField} field
+     * @param {Float64Array} point
+     * @returns {Float64Array}
+     */
+    curl(field, point) {
+        _assertClass(field, VectorField);
+        const ptr0 = passArrayF64ToWasm0(point, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.numericalderivative_curl(this.__wbg_ptr, field.__wbg_ptr, ptr0, len0);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v2;
+    }
+    /**
+     * Compute gradient of a scalar field at a point
+     *
+     * ∇f = [∂f/∂x, ∂f/∂y, ∂f/∂z]
+     *
+     * # Arguments
+     *
+     * * `field` - Scalar field
+     * * `point` - Evaluation point
+     *
+     * # Returns
+     *
+     * Gradient vector
+     *
+     * # JavaScript Example
+     *
+     * ```javascript
+     * const field = ScalarField.fromFunction2D((x, y) => x*x + y*y);
+     * const derivative = new NumericalDerivative();
+     * const grad = derivative.gradient(field, [1.0, 2.0]); // Returns [2.0, 4.0]
+     * ```
+     * @param {ScalarField} field
+     * @param {Float64Array} point
+     * @returns {Float64Array}
+     */
+    gradient(field, point) {
+        _assertClass(field, ScalarField);
+        const ptr0 = passArrayF64ToWasm0(point, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.numericalderivative_gradient(this.__wbg_ptr, field.__wbg_ptr, ptr0, len0);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v2;
+    }
+    /**
+     * Compute Laplacian of a scalar field at a point
+     *
+     * ∇²f = ∂²f/∂x² + ∂²f/∂y² + ∂²f/∂z²
+     *
+     * # Arguments
+     *
+     * * `field` - Scalar field
+     * * `point` - Evaluation point
+     *
+     * # Returns
+     *
+     * Laplacian (scalar)
+     * @param {ScalarField} field
+     * @param {Float64Array} point
+     * @returns {number}
+     */
+    laplacian(field, point) {
+        _assertClass(field, ScalarField);
+        const ptr0 = passArrayF64ToWasm0(point, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.numericalderivative_laplacian(this.__wbg_ptr, field.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0];
+    }
+}
+if (Symbol.dispose) NumericalDerivative.prototype[Symbol.dispose] = NumericalDerivative.prototype.free;
+
 const PerformanceOperationsFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_performanceoperations_free(ptr >>> 0, 1));
@@ -1556,6 +1806,358 @@ export class PerformanceOperations {
 }
 if (Symbol.dispose) PerformanceOperations.prototype[Symbol.dispose] = PerformanceOperations.prototype.free;
 
+const RiemannianManifoldFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_riemannianmanifold_free(ptr >>> 0, 1));
+/**
+ * Riemannian manifold with metric tensor
+ *
+ * Represents a curved space with a metric that defines distances and angles.
+ *
+ * # JavaScript Example
+ *
+ * ```javascript
+ * // Create a 2D sphere of radius 1
+ * const sphere = RiemannianManifold.sphere(1.0);
+ *
+ * // Compute scalar curvature at the north pole
+ * const R = sphere.scalarCurvature([0.0, 0.0]); // Returns 2.0 for unit sphere
+ * ```
+ */
+export class RiemannianManifold {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(RiemannianManifold.prototype);
+        obj.__wbg_ptr = ptr;
+        RiemannianManifoldFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        RiemannianManifoldFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_riemannianmanifold_free(ptr, 0);
+    }
+    /**
+     * Create a 2D hyperbolic plane (Poincaré half-plane model)
+     *
+     * Metric: ds² = (dx² + dy²) / y²
+     * @returns {RiemannianManifold}
+     */
+    static hyperbolic() {
+        const ret = wasm.riemannianmanifold_hyperbolic();
+        return RiemannianManifold.__wrap(ret);
+    }
+    /**
+     * Compute Christoffel symbol Γ^k_ij at a point
+     *
+     * # Arguments
+     *
+     * * `k` - Upper index
+     * * `i` - First lower index
+     * * `j` - Second lower index
+     * * `coords` - Coordinates
+     * @param {number} k
+     * @param {number} i
+     * @param {number} j
+     * @param {Float64Array} coords
+     * @returns {number}
+     */
+    christoffel(k, i, j, coords) {
+        const ptr0 = passArrayF64ToWasm0(coords, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.riemannianmanifold_christoffel(this.__wbg_ptr, k, i, j, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0];
+    }
+    /**
+     * Compute Ricci tensor component R_ij
+     *
+     * # Arguments
+     *
+     * * `i` - First index
+     * * `j` - Second index
+     * * `coords` - Coordinates
+     * @param {number} i
+     * @param {number} j
+     * @param {Float64Array} coords
+     * @returns {number}
+     */
+    ricciTensor(i, j, coords) {
+        const ptr0 = passArrayF64ToWasm0(coords, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.riemannianmanifold_ricciTensor(this.__wbg_ptr, i, j, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0];
+    }
+    /**
+     * Compute Riemann curvature tensor component R^i_jkl
+     *
+     * # Arguments
+     *
+     * * `i` - Upper index
+     * * `j` - First lower index
+     * * `k` - Second lower index
+     * * `l` - Third lower index
+     * * `coords` - Coordinates
+     * @param {number} i
+     * @param {number} j
+     * @param {number} k
+     * @param {number} l
+     * @param {Float64Array} coords
+     * @returns {number}
+     */
+    riemannTensor(i, j, k, l, coords) {
+        const ptr0 = passArrayF64ToWasm0(coords, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.riemannianmanifold_riemannTensor(this.__wbg_ptr, i, j, k, l, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0];
+    }
+    /**
+     * Compute scalar curvature R
+     *
+     * # Arguments
+     *
+     * * `coords` - Coordinates
+     *
+     * # Returns
+     *
+     * Scalar curvature value
+     * @param {Float64Array} coords
+     * @returns {number}
+     */
+    scalarCurvature(coords) {
+        const ptr0 = passArrayF64ToWasm0(coords, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.riemannianmanifold_scalarCurvature(this.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0];
+    }
+    /**
+     * Create a 2D sphere of given radius
+     *
+     * Metric: ds² = dθ² + sin²θ dφ²
+     *
+     * # Arguments
+     *
+     * * `radius` - Sphere radius
+     * @param {number} radius
+     * @returns {RiemannianManifold}
+     */
+    static sphere(radius) {
+        const ret = wasm.riemannianmanifold_sphere(radius);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return RiemannianManifold.__wrap(ret[0]);
+    }
+    /**
+     * Compute geodesic trajectory
+     *
+     * Solves the geodesic equations using RK4 integration.
+     *
+     * # Arguments
+     *
+     * * `initial_pos` - Initial position
+     * * `initial_vel` - Initial velocity
+     * * `t_max` - Maximum time
+     * * `dt` - Time step
+     *
+     * # Returns
+     *
+     * Flat array of trajectory points and velocities:
+     * [x0, y0, vx0, vy0, x1, y1, vx1, vy1, ...]
+     * @param {Float64Array} initial_pos
+     * @param {Float64Array} initial_vel
+     * @param {number} t_max
+     * @param {number} dt
+     * @returns {Float64Array}
+     */
+    geodesic(initial_pos, initial_vel, t_max, dt) {
+        const ptr0 = passArrayF64ToWasm0(initial_pos, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArrayF64ToWasm0(initial_vel, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.riemannianmanifold_geodesic(this.__wbg_ptr, ptr0, len0, ptr1, len1, t_max, dt);
+        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;
+    }
+    /**
+     * Get the dimension of the manifold
+     * @returns {number}
+     */
+    get dimension() {
+        const ret = wasm.riemannianmanifold_dimension(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Create a Euclidean (flat) manifold
+     *
+     * # Arguments
+     *
+     * * `dimension` - Dimension (2 or 3)
+     * @param {number} dimension
+     * @returns {RiemannianManifold}
+     */
+    static euclidean(dimension) {
+        const ret = wasm.riemannianmanifold_euclidean(dimension);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return RiemannianManifold.__wrap(ret[0]);
+    }
+}
+if (Symbol.dispose) RiemannianManifold.prototype[Symbol.dispose] = RiemannianManifold.prototype.free;
+
+const ScalarFieldFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_scalarfield_free(ptr >>> 0, 1));
+/**
+ * Scalar field f: ℝⁿ → ℝ
+ *
+ * Represents a function that maps points in n-dimensional space to real numbers.
+ *
+ * # JavaScript Example
+ *
+ * ```javascript
+ * // Create a scalar field f(x, y) = x² + y²
+ * const field = WasmScalarField.fromFunction2D((x, y) => x*x + y*y);
+ *
+ * // Evaluate at a point
+ * const value = field.evaluate([1.0, 2.0]); // Returns 5.0
+ * ```
+ */
+export class ScalarField {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(ScalarField.prototype);
+        obj.__wbg_ptr = ptr;
+        ScalarFieldFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        ScalarFieldFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_scalarfield_free(ptr, 0);
+    }
+    /**
+     * Batch evaluate the field at multiple points
+     *
+     * # Arguments
+     *
+     * * `points` - Array of points as flat array [x1, y1, x2, y2, ...]
+     *
+     * # Returns
+     *
+     * Array of field values
+     * @param {Float64Array} points
+     * @returns {Float64Array}
+     */
+    batchEvaluate(points) {
+        const ptr0 = passArrayF64ToWasm0(points, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.scalarfield_batchEvaluate(this.__wbg_ptr, ptr0, len0);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v2;
+    }
+    /**
+     * Create a 2D scalar field from a JavaScript function
+     *
+     * # Arguments
+     *
+     * * `func` - JavaScript function (x, y) => f(x, y)
+     * @param {Function} func
+     * @returns {ScalarField}
+     */
+    static fromFunction2D(func) {
+        const ret = wasm.scalarfield_fromFunction2D(func);
+        return ScalarField.__wrap(ret);
+    }
+    /**
+     * Create a 3D scalar field from a JavaScript function
+     *
+     * # Arguments
+     *
+     * * `func` - JavaScript function (x, y, z) => f(x, y, z)
+     * @param {Function} func
+     * @returns {ScalarField}
+     */
+    static fromFunction3D(func) {
+        const ret = wasm.scalarfield_fromFunction3D(func);
+        return ScalarField.__wrap(ret);
+    }
+    /**
+     * Create a 2D scalar field from a JavaScript function
+     *
+     * # Arguments
+     *
+     * * `func` - JavaScript function (x, y) => f(x, y)
+     * @param {Function} func
+     * @param {number} dimension
+     */
+    constructor(func, dimension) {
+        const ret = wasm.scalarfield_new(func, dimension);
+        this.__wbg_ptr = ret >>> 0;
+        ScalarFieldFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Evaluate the scalar field at a point
+     *
+     * # Arguments
+     *
+     * * `point` - Coordinates [x, y] or [x, y, z]
+     *
+     * # Returns
+     *
+     * Field value at the point
+     * @param {Float64Array} point
+     * @returns {number}
+     */
+    evaluate(point) {
+        const ptr0 = passArrayF64ToWasm0(point, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.scalarfield_evaluate(this.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0];
+    }
+}
+if (Symbol.dispose) ScalarField.prototype[Symbol.dispose] = ScalarField.prototype.free;
+
 const TropicalBatchFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_tropicalbatch_free(ptr >>> 0, 1));
@@ -1698,6 +2300,109 @@ export class TropicalMLOps {
 }
 if (Symbol.dispose) TropicalMLOps.prototype[Symbol.dispose] = TropicalMLOps.prototype.free;
 
+const VectorFieldFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_vectorfield_free(ptr >>> 0, 1));
+/**
+ * Vector field F: ℝⁿ → ℝⁿ
+ *
+ * Represents a function that maps points to vectors.
+ *
+ * # JavaScript Example
+ *
+ * ```javascript
+ * // Create a 2D vector field F(x, y) = [y, -x] (rotation)
+ * const field = WasmVectorField.fromFunction2D((x, y) => [y, -x]);
+ *
+ * // Evaluate at a point
+ * const vector = field.evaluate([1.0, 2.0]); // Returns [2.0, -1.0]
+ * ```
+ */
+export class VectorField {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(VectorField.prototype);
+        obj.__wbg_ptr = ptr;
+        VectorFieldFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        VectorFieldFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_vectorfield_free(ptr, 0);
+    }
+    /**
+     * Create a 2D vector field from a JavaScript function
+     *
+     * # Arguments
+     *
+     * * `func` - JavaScript function (x, y) => [fx, fy]
+     * @param {Function} func
+     * @returns {VectorField}
+     */
+    static fromFunction2D(func) {
+        const ret = wasm.vectorfield_fromFunction2D(func);
+        return VectorField.__wrap(ret);
+    }
+    /**
+     * Create a 3D vector field from a JavaScript function
+     *
+     * # Arguments
+     *
+     * * `func` - JavaScript function (x, y, z) => [fx, fy, fz]
+     * @param {Function} func
+     * @returns {VectorField}
+     */
+    static fromFunction3D(func) {
+        const ret = wasm.vectorfield_fromFunction3D(func);
+        return VectorField.__wrap(ret);
+    }
+    /**
+     * Create a vector field from a JavaScript function
+     * @param {Function} func
+     * @param {number} dimension
+     */
+    constructor(func, dimension) {
+        const ret = wasm.vectorfield_new(func, dimension);
+        this.__wbg_ptr = ret >>> 0;
+        VectorFieldFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Evaluate the vector field at a point
+     *
+     * # Arguments
+     *
+     * * `point` - Coordinates [x, y] or [x, y, z]
+     *
+     * # Returns
+     *
+     * Vector at the point
+     * @param {Float64Array} point
+     * @returns {Float64Array}
+     */
+    evaluate(point) {
+        const ptr0 = passArrayF64ToWasm0(point, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.vectorfield_evaluate(this.__wbg_ptr, ptr0, len0);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v2;
+    }
+}
+if (Symbol.dispose) VectorField.prototype[Symbol.dispose] = VectorField.prototype.free;
+
 const WasmAlphaConnectionFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_wasmalphaconnection_free(ptr >>> 0, 1));
@@ -4198,7 +4903,7 @@ export class WasmOptimizationResult {
      * @returns {number}
      */
     get iterations() {
-        const ret = wasm.wasmoptimizationresult_iterations(this.__wbg_ptr);
+        const ret = wasm.riemannianmanifold_dimension(this.__wbg_ptr);
         return ret >>> 0;
     }
     /**
@@ -4591,7 +5296,7 @@ export class WasmPropagationAnalysis {
      * @returns {number}
      */
     get convergenceTime() {
-        const ret = wasm.wasmoptimizationresult_iterations(this.__wbg_ptr);
+        const ret = wasm.riemannianmanifold_dimension(this.__wbg_ptr);
         return ret >>> 0;
     }
     /**
@@ -6269,10 +6974,18 @@ function __wbg_get_imports() {
         const ret = arg0.apply(arg1, arg2);
         return ret;
     }, arguments) };
+    imports.wbg.__wbg_call_357bb72daee10695 = function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
+        const ret = arg0.call(arg1, arg2, arg3, arg4);
+        return ret;
+    }, arguments) };
     imports.wbg.__wbg_call_525440f72fbfc0ea = function() { return handleError(function (arg0, arg1, arg2) {
         const ret = arg0.call(arg1, arg2);
         return ret;
     }, arguments) };
+    imports.wbg.__wbg_call_e45d2cf9fc925fcf = function() { return handleError(function (arg0, arg1, arg2, arg3) {
+        const ret = arg0.call(arg1, arg2, arg3);
+        return ret;
+    }, arguments) };
     imports.wbg.__wbg_call_e762c39fa8ea36bf = function() { return handleError(function (arg0, arg1) {
         const ret = arg0.call(arg1);
         return ret;
@@ -6303,7 +7016,7 @@ function __wbg_get_imports() {
     imports.wbg.__wbg_log_8cec76766b8c0e33 = function(arg0) {
         console.log(arg0);
     };
-    imports.wbg.__wbg_log_b51718ac10a384d9 = function(arg0, arg1) {
+    imports.wbg.__wbg_log_bf0922dbf69432a1 = function(arg0, arg1) {
         console.log(getStringFromWasm0(arg0, arg1));
     };
     imports.wbg.__wbg_new_1acc0b6eea89d040 = function() {
@@ -6317,7 +7030,7 @@ function __wbg_get_imports() {
                 const a = state0.a;
                 state0.a = 0;
                 try {
-                    return wasm_bindgen_83f782f110bf2942___convert__closures_____invoke___wasm_bindgen_83f782f110bf2942___JsValue__wasm_bindgen_83f782f110bf2942___JsValue_____(a, state0.b, arg0, arg1);
+                    return wasm_bindgen_e07ba2a7d21574bf___convert__closures_____invoke___wasm_bindgen_e07ba2a7d21574bf___JsValue__wasm_bindgen_e07ba2a7d21574bf___JsValue_____(a, state0.b, arg0, arg1);
                 } finally {
                     state0.a = a;
                 }
@@ -6418,11 +7131,6 @@ 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, wasm.wasm_bindgen_83f782f110bf2942___closure__destroy___dyn_core_f622c628fd7f704e___ops__function__FnMut__wasm_bindgen_83f782f110bf2942___JsValue____Output_______, wasm_bindgen_83f782f110bf2942___convert__closures_____invoke___wasm_bindgen_83f782f110bf2942___JsValue_____);
-        return ret;
-    };
     imports.wbg.__wbindgen_cast_b63aeb0d85365734 = function(arg0, arg1) {
         var v0 = getArrayF64FromWasm0(arg0, arg1).slice();
         wasm.__wbindgen_free(arg0, arg1 * 8, 8);
@@ -6430,6 +7138,11 @@ function __wbg_get_imports() {
         const ret = v0;
         return ret;
     };
+    imports.wbg.__wbindgen_cast_d2d0cc24b1b6ed59 = function(arg0, arg1) {
+        // Cast intrinsic for `Closure(Closure { dtor_idx: 42, function: Function { arguments: [Externref], shim_idx: 43, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+        const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen_e07ba2a7d21574bf___closure__destroy___dyn_core_a2b7f04d45112077___ops__function__FnMut__wasm_bindgen_e07ba2a7d21574bf___JsValue____Output_______, wasm_bindgen_e07ba2a7d21574bf___convert__closures_____invoke___wasm_bindgen_e07ba2a7d21574bf___JsValue_____);
+        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, measure theory, fusion systems, and information geometry",
-  "version": "0.10.0",
+  "version": "0.11.0",
   "license": "MIT OR Apache-2.0",
   "repository": {
     "type": "git",