@justinelliottcobb/amari-wasm 0.9.9 → 0.10.0

package/amari_wasm.js

@@ -222,39 +222,19 @@ 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}`);
-    }
-}
-
-let cachedUint32ArrayMemory0 = null;
-
-function getUint32ArrayMemory0() {
-    if (cachedUint32ArrayMemory0 === null || cachedUint32ArrayMemory0.byteLength === 0) {
-        cachedUint32ArrayMemory0 = new Uint32Array(wasm.memory.buffer);
-    }
-    return cachedUint32ArrayMemory0;
+/**
+ * Initialize the WASM module
+ */
+export function init() {
+    wasm.init();
 }
 
-function passArray32ToWasm0(arg, malloc) {
-    const ptr = malloc(arg.length * 4, 4) >>> 0;
-    getUint32ArrayMemory0().set(arg, ptr / 4);
+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_externrefs.get(idx);
-    wasm.__externref_table_dealloc(idx);
-    return value;
-}
-
-function getArrayU32FromWasm0(ptr, len) {
-    ptr = ptr >>> 0;
-    return getUint32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
-}
 /**
  * Initialize the enumerative geometry module
  */
@@ -262,21 +242,22 @@ export function initEnumerative() {
     wasm.initEnumerative();
 }
 
-function passArrayF64ToWasm0(arg, malloc) {
-    const ptr = malloc(arg.length * 8, 8) >>> 0;
-    getFloat64ArrayMemory0().set(arg, ptr / 8);
-    WASM_VECTOR_LEN = arg.length;
-    return ptr;
-}
 /**
- * Validate that this module loaded correctly
- * @returns {boolean}
+ * Calculate light deflection angle for photon grazing massive object
+ * @param {number} impact_parameter
+ * @param {number} mass
+ * @returns {number}
  */
-export function validate_relativistic_module() {
-    const ret = wasm.validate_relativistic_module();
-    return ret !== 0;
+export function light_deflection_angle(impact_parameter, mass) {
+    const ret = wasm.light_deflection_angle(impact_parameter, mass);
+    return ret;
 }
 
+function takeFromExternrefTable0(idx) {
+    const value = wasm.__wbindgen_externrefs.get(idx);
+    wasm.__externref_table_dealloc(idx);
+    return value;
+}
 /**
  * Convert velocity to Lorentz factor
  * @param {number} velocity_magnitude
@@ -290,17 +271,6 @@ export function velocity_to_gamma(velocity_magnitude) {
     return ret[0];
 }
 
-/**
- * Calculate light deflection angle for photon grazing massive object
- * @param {number} impact_parameter
- * @param {number} mass
- * @returns {number}
- */
-export function light_deflection_angle(impact_parameter, mass) {
-    const ret = wasm.light_deflection_angle(impact_parameter, mass);
-    return ret;
-}
-
 /**
  * Convert Lorentz factor to velocity
  * @param {number} gamma
@@ -315,10 +285,12 @@ export function gamma_to_velocity(gamma) {
 }
 
 /**
- * Initialize the WASM module
+ * Validate that this module loaded correctly
+ * @returns {boolean}
  */
-export function init() {
-    wasm.init();
+export function validate_relativistic_module() {
+    const ret = wasm.validate_relativistic_module();
+    return ret !== 0;
 }
 
 /**
@@ -328,6 +300,94 @@ export function initFusion() {
     wasm.initFusion();
 }
 
+/**
+ * Integrate a JavaScript function over an interval
+ *
+ * This function provides numerical integration capabilities to JavaScript.
+ *
+ * # Arguments
+ * * `f` - JavaScript function to integrate (must accept a number and return a number)
+ * * `a` - Lower bound of integration
+ * * `b` - Upper bound of integration
+ * * `points` - Number of sample points to use
+ * * `method` - Integration method to use
+ *
+ * # Returns
+ * Approximate value of the integral ∫_a^b f(x) dx
+ * @param {Function} f
+ * @param {number} a
+ * @param {number} b
+ * @param {number} points
+ * @param {WasmIntegrationMethod} method
+ * @returns {number}
+ */
+export function integrate(f, a, b, points, method) {
+    const ret = wasm.integrate(f, a, b, points, method);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return ret[0];
+}
+
+/**
+ * Compute expectation E[f(X)] for uniform distribution on [a, b]
+ *
+ * # Arguments
+ * * `f` - JavaScript function (must accept a number and return a number)
+ * * `a` - Lower bound
+ * * `b` - Upper bound
+ * * `samples` - Number of Monte Carlo samples
+ * @param {Function} f
+ * @param {number} a
+ * @param {number} b
+ * @param {number} samples
+ * @returns {number}
+ */
+export function expectation(f, a, b, samples) {
+    const ret = wasm.expectation(f, a, b, samples);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return ret[0];
+}
+
+function _assertClass(instance, klass) {
+    if (!(instance instanceof klass)) {
+        throw new Error(`expected instance of ${klass.name}`);
+    }
+}
+/**
+ * Compute KL divergence D_KL(P||Q) between two distributions
+ *
+ * # Arguments
+ * * `p_density` - First distribution
+ * * `q_density` - Second distribution
+ * * `p_params` - Parameters for P
+ * * `q_params` - Parameters for Q
+ * * `sample_points` - Points to evaluate at
+ * @param {WasmParametricDensity} p_density
+ * @param {WasmParametricDensity} q_density
+ * @param {Float64Array} p_params
+ * @param {Float64Array} q_params
+ * @param {Float64Array} sample_points
+ * @returns {number}
+ */
+export function klDivergence(p_density, q_density, p_params, q_params, sample_points) {
+    _assertClass(p_density, WasmParametricDensity);
+    _assertClass(q_density, WasmParametricDensity);
+    const ptr0 = passArrayF64ToWasm0(p_params, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArrayF64ToWasm0(q_params, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ptr2 = passArrayF64ToWasm0(sample_points, wasm.__wbindgen_malloc);
+    const len2 = WASM_VECTOR_LEN;
+    const ret = wasm.klDivergence(p_density.__wbg_ptr, q_density.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return ret[0];
+}
+
 /**
  * Initialize the automata module
  */
@@ -335,18 +395,66 @@ export function initAutomata() {
     wasm.initAutomata();
 }
 
+let cachedUint32ArrayMemory0 = null;
+
+function getUint32ArrayMemory0() {
+    if (cachedUint32ArrayMemory0 === null || cachedUint32ArrayMemory0.byteLength === 0) {
+        cachedUint32ArrayMemory0 = new Uint32Array(wasm.memory.buffer);
+    }
+    return cachedUint32ArrayMemory0;
+}
+
+function getArrayU32FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
+}
+
 function getArrayU8FromWasm0(ptr, len) {
     ptr = ptr >>> 0;
     return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
 }
-function wasm_bindgen__convert__closures_____invoke__h79d0d9c6410c14e7(arg0, arg1, arg2) {
-    wasm.wasm_bindgen__convert__closures_____invoke__h79d0d9c6410c14e7(arg0, arg1, arg2);
+
+function passArray32ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 4, 4) >>> 0;
+    getUint32ArrayMemory0().set(arg, ptr / 4);
+    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__convert__closures_____invoke__h0bb870c532b1b216(arg0, arg1, arg2, arg3) {
-    wasm.wasm_bindgen__convert__closures_____invoke__h0bb870c532b1b216(arg0, arg1, arg2, arg3);
+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);
 }
 
+/**
+ * Integration methods available in WASM
+ * @enum {0 | 1 | 2 | 3 | 4}
+ */
+export const WasmIntegrationMethod = Object.freeze({
+    /**
+     * Riemann sum approximation
+     */
+    Riemann: 0, "0": "Riemann",
+    /**
+     * Monte Carlo integration
+     */
+    MonteCarlo: 1, "1": "MonteCarlo",
+    /**
+     * Trapezoidal rule
+     */
+    Trapezoidal: 2, "2": "Trapezoidal",
+    /**
+     * Simpson's rule
+     */
+    Simpson: 3, "3": "Simpson",
+    /**
+     * Adaptive quadrature
+     */
+    Adaptive: 4, "4": "Adaptive",
+});
+
 const AutoDiffFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_autodiff_free(ptr >>> 0, 1));
@@ -1825,6 +1933,60 @@ export class WasmCommunity {
 }
 if (Symbol.dispose) WasmCommunity.prototype[Symbol.dispose] = WasmCommunity.prototype.free;
 
+const WasmCountingMeasureFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmcountingmeasure_free(ptr >>> 0, 1));
+/**
+ * WASM wrapper for counting measure
+ *
+ * The counting measure assigns to each set the number of elements it contains.
+ */
+export class WasmCountingMeasure {
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmCountingMeasureFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmcountingmeasure_free(ptr, 0);
+    }
+    /**
+     * Check if a set is measurable under counting measure
+     * (all sets are measurable under counting measure)
+     * @returns {boolean}
+     */
+    isMeasurable() {
+        const ret = wasm.wasmcountingmeasure_isMeasurable(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Measure a finite set (returns its cardinality)
+     *
+     * # Arguments
+     * * `set_size` - The number of elements in the set
+     * @param {number} set_size
+     * @returns {number}
+     */
+    measureFiniteSet(set_size) {
+        const ret = wasm.wasmcountingmeasure_measureFiniteSet(this.__wbg_ptr, set_size);
+        return ret;
+    }
+    /**
+     * Create a new counting measure
+     */
+    constructor() {
+        const ret = wasm.wasmcountingmeasure_new();
+        this.__wbg_ptr = ret >>> 0;
+        WasmCountingMeasureFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+}
+if (Symbol.dispose) WasmCountingMeasure.prototype[Symbol.dispose] = WasmCountingMeasure.prototype.free;
+
 const WasmDualNumberFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_wasmdualnumber_free(ptr >>> 0, 1));
@@ -2329,6 +2491,83 @@ export class WasmFisherInformationMatrix {
 }
 if (Symbol.dispose) WasmFisherInformationMatrix.prototype[Symbol.dispose] = WasmFisherInformationMatrix.prototype.free;
 
+const WasmFisherMeasureFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmfishermeasure_free(ptr >>> 0, 1));
+/**
+ * Fisher-Riemannian geometry on statistical manifolds
+ */
+export class WasmFisherMeasure {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(WasmFisherMeasure.prototype);
+        obj.__wbg_ptr = ptr;
+        WasmFisherMeasureFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmFisherMeasureFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmfishermeasure_free(ptr, 0);
+    }
+    /**
+     * Create Fisher measure from a parametric density
+     * @param {WasmParametricDensity} density
+     * @returns {WasmFisherMeasure}
+     */
+    static fromDensity(density) {
+        _assertClass(density, WasmParametricDensity);
+        var ptr0 = density.__destroy_into_raw();
+        const ret = wasm.wasmfishermeasure_fromDensity(ptr0);
+        return WasmFisherMeasure.__wrap(ret);
+    }
+    /**
+     * Compute the Fisher information metric at parameter point θ
+     * @param {Float64Array} data
+     * @param {Float64Array} params
+     * @returns {Float64Array}
+     */
+    fisherMetric(data, params) {
+        const ptr0 = passArrayF64ToWasm0(data, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArrayF64ToWasm0(params, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmfishermeasure_fisherMetric(this.__wbg_ptr, 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;
+    }
+    /**
+     * Compute the Riemannian volume element √det(g(θ))
+     * @param {Float64Array} data
+     * @param {Float64Array} params
+     * @returns {number}
+     */
+    volumeElement(data, params) {
+        const ptr0 = passArrayF64ToWasm0(data, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArrayF64ToWasm0(params, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmfishermeasure_volumeElement(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0];
+    }
+}
+if (Symbol.dispose) WasmFisherMeasure.prototype[Symbol.dispose] = WasmFisherMeasure.prototype.free;
+
 const WasmFourVelocityFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_wasmfourvelocity_free(ptr >>> 0, 1));
@@ -3031,14 +3270,6 @@ export class WasmGpuOptimizer {
         const ret = wasm.wasmgpuoptimizer_optimizeBatch(this.__wbg_ptr, ptr0, len0, problem_size, num_problems, max_iterations, tolerance);
         return ret;
     }
-    /**
-     * Check if GPU acceleration is available
-     * @returns {boolean}
-     */
-    isGpuAvailable() {
-        const ret = wasm.wasmgpuoptimizer_isGpuAvailable(this.__wbg_ptr);
-        return ret !== 0;
-    }
     /**
      * Optimize a quadratic function with GPU acceleration
      * @param {Float64Array} coefficients
@@ -3055,11 +3286,19 @@ export class WasmGpuOptimizer {
         const ret = wasm.wasmgpuoptimizer_optimizeQuadraticGpu(this.__wbg_ptr, ptr0, len0, ptr1, len1, max_iterations, tolerance);
         return ret;
     }
+    /**
+     * Check if GPU acceleration is available
+     * @returns {boolean}
+     */
+    isGpuAvailable() {
+        const ret = wasm.wasmgpuoptimizer_isGpuAvailable(this.__wbg_ptr);
+        return ret !== 0;
+    }
     /**
      * Create a new GPU optimizer
      */
     constructor() {
-        const ret = wasm.wasmgpuoptimizer_new();
+        const ret = wasm.wasmcountingmeasure_new();
         this.__wbg_ptr = ret >>> 0;
         WasmGpuOptimizerFinalization.register(this, this.__wbg_ptr, this);
         return this;
@@ -3195,6 +3434,89 @@ export class WasmInverseCADesigner {
 }
 if (Symbol.dispose) WasmInverseCADesigner.prototype[Symbol.dispose] = WasmInverseCADesigner.prototype.free;
 
+const WasmLebesgueMeasureFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmlebesguemeasure_free(ptr >>> 0, 1));
+/**
+ * WASM wrapper for Lebesgue measure
+ *
+ * The Lebesgue measure generalizes the notion of length, area, and volume
+ * to higher dimensions and more complex sets.
+ */
+export class WasmLebesgueMeasure {
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmLebesgueMeasureFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmlebesguemeasure_free(ptr, 0);
+    }
+    /**
+     * Compute the measure of a box (hyper-rectangle) with given side lengths
+     * @param {Float64Array} sides
+     * @returns {number}
+     */
+    measureBox(sides) {
+        const ptr0 = passArrayF64ToWasm0(sides, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmlebesguemeasure_measureBox(this.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0];
+    }
+    /**
+     * Get the dimension of this measure
+     * @returns {number}
+     */
+    getDimension() {
+        const ret = wasm.wasmlebesguemeasure_getDimension(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Compute the measure of an interval [a, b]
+     *
+     * For 1D: returns length (b - a)
+     * For higher dimensions: returns the product of interval lengths
+     * @param {Float64Array} lower
+     * @param {Float64Array} upper
+     * @returns {number}
+     */
+    measureInterval(lower, upper) {
+        const ptr0 = passArrayF64ToWasm0(lower, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArrayF64ToWasm0(upper, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmlebesguemeasure_measureInterval(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0];
+    }
+    /**
+     * Create a new Lebesgue measure for the specified dimension
+     *
+     * # Arguments
+     * * `dimension` - The dimension of the space (1 for length, 2 for area, 3 for volume, etc.)
+     * @param {number} dimension
+     */
+    constructor(dimension) {
+        const ret = wasm.wasmlebesguemeasure_new(dimension);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0] >>> 0;
+        WasmLebesgueMeasureFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+}
+if (Symbol.dispose) WasmLebesgueMeasure.prototype[Symbol.dispose] = WasmLebesgueMeasure.prototype.free;
+
 const WasmModuliSpaceFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_wasmmodulispace_free(ptr >>> 0, 1));
@@ -3253,7 +3575,7 @@ export class WasmModuliSpace {
      * @returns {number}
      */
     getGenus() {
-        const ret = wasm.wasmmodulispace_getGenus(this.__wbg_ptr);
+        const ret = wasm.wasmlebesguemeasure_getDimension(this.__wbg_ptr);
         return ret >>> 0;
     }
     /**
@@ -3454,7 +3776,7 @@ export class WasmMultiObjectiveOptimizer {
      * Create a new multi-objective optimizer
      */
     constructor() {
-        const ret = wasm.wasmgpuoptimizer_new();
+        const ret = wasm.wasmcountingmeasure_new();
         this.__wbg_ptr = ret >>> 0;
         WasmMultiObjectiveOptimizerFinalization.register(this, this.__wbg_ptr, this);
         return this;
@@ -3964,6 +4286,220 @@ export class WasmOptimizationUtils {
 }
 if (Symbol.dispose) WasmOptimizationUtils.prototype[Symbol.dispose] = WasmOptimizationUtils.prototype.free;
 
+const WasmParametricDensityFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmparametricdensity_free(ptr >>> 0, 1));
+/**
+ * Parametric probability density families
+ */
+export class WasmParametricDensity {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(WasmParametricDensity.prototype);
+        obj.__wbg_ptr = ptr;
+        WasmParametricDensityFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmParametricDensityFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmparametricdensity_free(ptr, 0);
+    }
+    /**
+     * Create an Exponential density Exp(λ)
+     * @returns {WasmParametricDensity}
+     */
+    static exponential() {
+        const ret = wasm.wasmparametricdensity_exponential();
+        return WasmParametricDensity.__wrap(ret);
+    }
+    /**
+     * Compute log-density log p(x|θ)
+     * @param {number} x
+     * @param {Float64Array} params
+     * @returns {number}
+     */
+    logDensity(x, params) {
+        const ptr0 = passArrayF64ToWasm0(params, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmparametricdensity_logDensity(this.__wbg_ptr, x, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0];
+    }
+    /**
+     * Compute Fisher information matrix from data samples
+     * @param {Float64Array} data
+     * @param {Float64Array} params
+     * @returns {Float64Array}
+     */
+    fisherInformation(data, params) {
+        const ptr0 = passArrayF64ToWasm0(data, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArrayF64ToWasm0(params, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmparametricdensity_fisherInformation(this.__wbg_ptr, 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;
+    }
+    /**
+     * Create a Cauchy density Cauchy(x₀, γ)
+     * @returns {WasmParametricDensity}
+     */
+    static cauchy() {
+        const ret = wasm.wasmparametricdensity_cauchy();
+        return WasmParametricDensity.__wrap(ret);
+    }
+    /**
+     * Create a Laplace density Laplace(μ, b)
+     * @returns {WasmParametricDensity}
+     */
+    static laplace() {
+        const ret = wasm.wasmparametricdensity_laplace();
+        return WasmParametricDensity.__wrap(ret);
+    }
+    /**
+     * Evaluate density at point x with parameters
+     *
+     * # Arguments
+     * * `x` - Point to evaluate
+     * * `params` - Parameters (Gaussian: [μ, σ], Exponential: [λ], etc.)
+     * @param {number} x
+     * @param {Float64Array} params
+     * @returns {number}
+     */
+    evaluate(x, params) {
+        const ptr0 = passArrayF64ToWasm0(params, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmparametricdensity_evaluate(this.__wbg_ptr, x, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0];
+    }
+    /**
+     * Create a Gaussian density N(μ, σ²)
+     * @returns {WasmParametricDensity}
+     */
+    static gaussian() {
+        const ret = wasm.wasmparametricdensity_gaussian();
+        return WasmParametricDensity.__wrap(ret);
+    }
+    /**
+     * Compute numerical gradient ∇_θ p(x|θ)
+     * @param {number} x
+     * @param {Float64Array} params
+     * @returns {Float64Array}
+     */
+    gradient(x, params) {
+        const ptr0 = passArrayF64ToWasm0(params, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmparametricdensity_gradient(this.__wbg_ptr, x, 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) WasmParametricDensity.prototype[Symbol.dispose] = WasmParametricDensity.prototype.free;
+
+const WasmProbabilityMeasureFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmprobabilitymeasure_free(ptr >>> 0, 1));
+/**
+ * WASM wrapper for probability measures
+ *
+ * A probability measure assigns total measure 1 to the entire space.
+ */
+export class WasmProbabilityMeasure {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(WasmProbabilityMeasure.prototype);
+        obj.__wbg_ptr = ptr;
+        WasmProbabilityMeasureFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmProbabilityMeasureFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmprobabilitymeasure_free(ptr, 0);
+    }
+    /**
+     * Get a description of this probability measure
+     * @returns {string}
+     */
+    getDescription() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.wasmprobabilitymeasure_getDescription(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Compute P(X ∈ [a, b]) for uniform distribution
+     * @param {number} a
+     * @param {number} b
+     * @param {number} lower
+     * @param {number} upper
+     * @returns {number}
+     */
+    probabilityInterval(a, b, lower, upper) {
+        const ret = wasm.wasmprobabilitymeasure_probabilityInterval(this.__wbg_ptr, a, b, lower, upper);
+        return ret;
+    }
+    /**
+     * Create a new uniform probability measure on [0, 1]
+     */
+    constructor() {
+        const ret = wasm.wasmprobabilitymeasure_new();
+        this.__wbg_ptr = ret >>> 0;
+        WasmProbabilityMeasureFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Create a uniform probability measure on [a, b]
+     * @param {number} a
+     * @param {number} b
+     * @returns {WasmProbabilityMeasure}
+     */
+    static uniform(a, b) {
+        const ret = wasm.wasmprobabilitymeasure_uniform(a, b);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmProbabilityMeasure.__wrap(ret[0]);
+    }
+}
+if (Symbol.dispose) WasmProbabilityMeasure.prototype[Symbol.dispose] = WasmProbabilityMeasure.prototype.free;
+
 const WasmProjectiveSpaceFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_wasmprojectivespace_free(ptr >>> 0, 1));
@@ -3988,7 +4524,7 @@ export class WasmProjectiveSpace {
      * @returns {number}
      */
     getDimension() {
-        const ret = wasm.wasmmodulispace_getGenus(this.__wbg_ptr);
+        const ret = wasm.wasmlebesguemeasure_getDimension(this.__wbg_ptr);
         return ret >>> 0;
     }
     /**
@@ -4607,7 +5143,7 @@ export class WasmSimpleOptimizer {
      * Create a new simple optimizer
      */
     constructor() {
-        const ret = wasm.wasmgpuoptimizer_new();
+        const ret = wasm.wasmcountingmeasure_new();
         this.__wbg_ptr = ret >>> 0;
         WasmSimpleOptimizerFinalization.register(this, this.__wbg_ptr, this);
         return this;
@@ -4787,14 +5323,6 @@ export class WasmTrajectoryPoint {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_wasmtrajectorypoint_free(ptr, 0);
     }
-    /**
-     * Get position
-     * @returns {WasmSpacetimeVector}
-     */
-    get position() {
-        const ret = wasm.wasmfourvelocity_as_spacetime_vector(this.__wbg_ptr);
-        return WasmSpacetimeVector.__wrap(ret);
-    }
     /**
      * Time coordinate
      * @returns {number}
@@ -4810,6 +5338,14 @@ export class WasmTrajectoryPoint {
     set time(arg0) {
         wasm.__wbg_set_wasmtrajectorypoint_time(this.__wbg_ptr, arg0);
     }
+    /**
+     * Get position
+     * @returns {WasmSpacetimeVector}
+     */
+    get position() {
+        const ret = wasm.wasmfourvelocity_as_spacetime_vector(this.__wbg_ptr);
+        return WasmSpacetimeVector.__wrap(ret);
+    }
 }
 if (Symbol.dispose) WasmTrajectoryPoint.prototype[Symbol.dispose] = WasmTrajectoryPoint.prototype.free;
 
@@ -5187,6 +5723,90 @@ export class WasmTropicalDualDistribution {
 }
 if (Symbol.dispose) WasmTropicalDualDistribution.prototype[Symbol.dispose] = WasmTropicalDualDistribution.prototype.free;
 
+const WasmTropicalMeasureFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmtropicalmeasure_free(ptr >>> 0, 1));
+/**
+ * Tropical (max-plus) algebra operations for optimization
+ */
+export class WasmTropicalMeasure {
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmTropicalMeasureFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmtropicalmeasure_free(ptr, 0);
+    }
+    /**
+     * Tropical integration (supremum over region)
+     * @param {Function} f
+     * @param {number} a
+     * @param {number} b
+     * @param {number} samples
+     * @returns {number}
+     */
+    tropicalIntegrate(f, a, b, samples) {
+        const ret = wasm.wasmtropicalmeasure_tropicalIntegrate(this.__wbg_ptr, f, a, b, samples);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0];
+    }
+    /**
+     * Create a new tropical measure
+     */
+    constructor() {
+        const ret = wasm.wasmcountingmeasure_new();
+        this.__wbg_ptr = ret >>> 0;
+        WasmTropicalMeasureFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Compute tropical infimum (minimum) of function over sample points
+     *
+     * Returns the minimum value and the point where it occurs
+     * @param {Function} f
+     * @param {Float64Array} points
+     * @returns {Float64Array}
+     */
+    infimum(f, points) {
+        const ptr0 = passArrayF64ToWasm0(points, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmtropicalmeasure_infimum(this.__wbg_ptr, f, 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 tropical supremum (maximum) of function over sample points
+     *
+     * Returns the maximum value and the point where it occurs
+     * @param {Function} f
+     * @param {Float64Array} points
+     * @returns {Float64Array}
+     */
+    supremum(f, points) {
+        const ptr0 = passArrayF64ToWasm0(points, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmtropicalmeasure_supremum(this.__wbg_ptr, f, 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) WasmTropicalMeasure.prototype[Symbol.dispose] = WasmTropicalMeasure.prototype.free;
+
 const WasmTropicalNetworkFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_wasmtropicalnetwork_free(ptr >>> 0, 1));
@@ -5680,12 +6300,12 @@ function __wbg_get_imports() {
         const ret = arg0.length;
         return ret;
     };
-    imports.wbg.__wbg_log_78aa79d721d10880 = function(arg0, arg1) {
-        console.log(getStringFromWasm0(arg0, arg1));
-    };
     imports.wbg.__wbg_log_8cec76766b8c0e33 = function(arg0) {
         console.log(arg0);
     };
+    imports.wbg.__wbg_log_b51718ac10a384d9 = function(arg0, arg1) {
+        console.log(getStringFromWasm0(arg0, arg1));
+    };
     imports.wbg.__wbg_new_1acc0b6eea89d040 = function() {
         const ret = new Object();
         return ret;
@@ -5697,7 +6317,7 @@ function __wbg_get_imports() {
                 const a = state0.a;
                 state0.a = 0;
                 try {
-                    return wasm_bindgen__convert__closures_____invoke__h0bb870c532b1b216(a, state0.b, arg0, arg1);
+                    return wasm_bindgen_83f782f110bf2942___convert__closures_____invoke___wasm_bindgen_83f782f110bf2942___JsValue__wasm_bindgen_83f782f110bf2942___JsValue_____(a, state0.b, arg0, arg1);
                 } finally {
                     state0.a = a;
                 }
@@ -5800,7 +6420,7 @@ function __wbg_get_imports() {
     };
     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__closure__destroy__h1dd832fb828dedcc, wasm_bindgen__convert__closures_____invoke__h79d0d9c6410c14e7);
+        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) {