@iyulab/u-numflow 0.2.1 → 0.3.1

package/README.md

@@ -80,6 +80,19 @@ cargo test
 
 MIT License — see [LICENSE](LICENSE).
 
+## npm (WebAssembly)
+
+```bash
+npm install @iyulab/u-numflow
+```
+
+The package resolves per environment via a conditional `exports` map:
+
+| Environment | Entry |
+|---|---|
+| Bundlers (webpack, Vite, …) | ESM + WebAssembly ESM-integration (`default` condition) |
+| Node.js — `require()`, ESM `import`, CJS TS runners (`tsx`, `ts-node`) | CJS glue loading the wasm from the filesystem (`node` condition) — no loader hooks or flags |
+
 ## Related
 
 - [u-metaheur](https://github.com/iyulab/u-metaheur) — Metaheuristic optimization (GA, SA, ALNS, CP)

package/node/u_numflow.cjs

@@ -0,0 +1,186 @@
+/* @ts-self-types="./u_numflow.d.cts" */
+
+/**
+ * Apply the Box-Cox power transformation to positive data.
+ *
+ * All values in `data` must be strictly positive.
+ *
+ * # Errors
+ * Returns a `JsValue` error string if data contains non-positive values or
+ * has fewer than 2 elements.
+ * @param {Float64Array} data
+ * @param {number} lambda
+ * @returns {Float64Array}
+ */
+function box_cox(data, lambda) {
+    const ptr0 = passArrayF64ToWasm0(data, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.box_cox(ptr0, len0, lambda);
+    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;
+}
+exports.box_cox = box_cox;
+
+/**
+ * Estimate the optimal Box-Cox lambda via profile maximum likelihood.
+ *
+ * Searches in the range `[lambda_min, lambda_max]` using golden-section search.
+ *
+ * # Errors
+ * Returns a `JsValue` error string if data contains non-positive values,
+ * has fewer than 2 elements, or `lambda_min >= lambda_max`.
+ * @param {Float64Array} data
+ * @param {number} lambda_min
+ * @param {number} lambda_max
+ * @returns {number}
+ */
+function estimate_lambda(data, lambda_min, lambda_max) {
+    const ptr0 = passArrayF64ToWasm0(data, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.estimate_lambda(ptr0, len0, lambda_min, lambda_max);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return ret[0];
+}
+exports.estimate_lambda = estimate_lambda;
+
+/**
+ * Arithmetic mean of `data` using Kahan compensated summation.
+ *
+ * Returns `NaN` if `data` is empty or contains non-finite values.
+ * @param {Float64Array} data
+ * @returns {number}
+ */
+function mean(data) {
+    const ptr0 = passArrayF64ToWasm0(data, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.mean(ptr0, len0);
+    return ret;
+}
+exports.mean = mean;
+
+/**
+ * Standard normal CDF Φ(x) = P(Z ≤ x) for Z ~ N(0, 1).
+ *
+ * To evaluate a general normal N(μ, σ), pass `(x - μ) / σ`.
+ *
+ * Uses Abramowitz & Stegun formula 26.2.17 (max abs error < 7.5 × 10⁻⁸).
+ * @param {number} x
+ * @returns {number}
+ */
+function normal_cdf(x) {
+    const ret = wasm.normal_cdf(x);
+    return ret;
+}
+exports.normal_cdf = normal_cdf;
+
+/**
+ * Sample standard deviation of `data` (Bessel-corrected, denominator n−1).
+ *
+ * Returns `NaN` if `data` has fewer than 2 elements or contains non-finite values.
+ * @param {Float64Array} data
+ * @returns {number}
+ */
+function std_dev(data) {
+    const ptr0 = passArrayF64ToWasm0(data, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.std_dev(ptr0, len0);
+    return ret;
+}
+exports.std_dev = std_dev;
+
+/**
+ * Sample variance of `data` (Bessel-corrected, denominator n−1).
+ *
+ * Returns `NaN` if `data` has fewer than 2 elements or contains non-finite values.
+ * @param {Float64Array} data
+ * @returns {number}
+ */
+function variance(data) {
+    const ptr0 = passArrayF64ToWasm0(data, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.variance(ptr0, len0);
+    return ret;
+}
+exports.variance = variance;
+function __wbg_get_imports() {
+    const import0 = {
+        __proto__: null,
+        __wbindgen_cast_0000000000000001: function(arg0, arg1) {
+            // Cast intrinsic for `Ref(String) -> Externref`.
+            const ret = getStringFromWasm0(arg0, arg1);
+            return ret;
+        },
+        __wbindgen_init_externref_table: function() {
+            const table = wasm.__wbindgen_externrefs;
+            const offset = table.grow(4);
+            table.set(0, undefined);
+            table.set(offset + 0, undefined);
+            table.set(offset + 1, null);
+            table.set(offset + 2, true);
+            table.set(offset + 3, false);
+        },
+    };
+    return {
+        __proto__: null,
+        "./u_numflow_bg.js": import0,
+    };
+}
+
+function getArrayF64FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getFloat64ArrayMemory0().subarray(ptr / 8, ptr / 8 + len);
+}
+
+let cachedFloat64ArrayMemory0 = null;
+function getFloat64ArrayMemory0() {
+    if (cachedFloat64ArrayMemory0 === null || cachedFloat64ArrayMemory0.byteLength === 0) {
+        cachedFloat64ArrayMemory0 = new Float64Array(wasm.memory.buffer);
+    }
+    return cachedFloat64ArrayMemory0;
+}
+
+function getStringFromWasm0(ptr, len) {
+    return decodeText(ptr >>> 0, len);
+}
+
+let cachedUint8ArrayMemory0 = null;
+function getUint8ArrayMemory0() {
+    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8ArrayMemory0;
+}
+
+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;
+}
+
+let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+cachedTextDecoder.decode();
+function decodeText(ptr, len) {
+    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+
+let WASM_VECTOR_LEN = 0;
+
+const wasmPath = `${__dirname}/u_numflow_bg.wasm`;
+const wasmBytes = require('fs').readFileSync(wasmPath);
+const wasmModule = new WebAssembly.Module(wasmBytes);
+let wasmInstance = new WebAssembly.Instance(wasmModule, __wbg_get_imports());
+let wasm = wasmInstance.exports;
+wasm.__wbindgen_start();

package/node/u_numflow.d.cts

@@ -0,0 +1,54 @@
+/* tslint:disable */
+/* eslint-disable */
+
+/**
+ * Apply the Box-Cox power transformation to positive data.
+ *
+ * All values in `data` must be strictly positive.
+ *
+ * # Errors
+ * Returns a `JsValue` error string if data contains non-positive values or
+ * has fewer than 2 elements.
+ */
+export function box_cox(data: Float64Array, lambda: number): Float64Array;
+
+/**
+ * Estimate the optimal Box-Cox lambda via profile maximum likelihood.
+ *
+ * Searches in the range `[lambda_min, lambda_max]` using golden-section search.
+ *
+ * # Errors
+ * Returns a `JsValue` error string if data contains non-positive values,
+ * has fewer than 2 elements, or `lambda_min >= lambda_max`.
+ */
+export function estimate_lambda(data: Float64Array, lambda_min: number, lambda_max: number): number;
+
+/**
+ * Arithmetic mean of `data` using Kahan compensated summation.
+ *
+ * Returns `NaN` if `data` is empty or contains non-finite values.
+ */
+export function mean(data: Float64Array): number;
+
+/**
+ * Standard normal CDF Φ(x) = P(Z ≤ x) for Z ~ N(0, 1).
+ *
+ * To evaluate a general normal N(μ, σ), pass `(x - μ) / σ`.
+ *
+ * Uses Abramowitz & Stegun formula 26.2.17 (max abs error < 7.5 × 10⁻⁸).
+ */
+export function normal_cdf(x: number): number;
+
+/**
+ * Sample standard deviation of `data` (Bessel-corrected, denominator n−1).
+ *
+ * Returns `NaN` if `data` has fewer than 2 elements or contains non-finite values.
+ */
+export function std_dev(data: Float64Array): number;
+
+/**
+ * Sample variance of `data` (Bessel-corrected, denominator n−1).
+ *
+ * Returns `NaN` if `data` has fewer than 2 elements or contains non-finite values.
+ */
+export function variance(data: Float64Array): number;

package/package.json

@@ -5,7 +5,7 @@
     "iyulab"
   ],
   "description": "Mathematical primitives for the U-Engine ecosystem: statistics, probability, random sampling, and collections.",
-  "version": "0.2.1",
+  "version": "0.3.1",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -15,18 +15,31 @@
     "u_numflow_bg.wasm",
     "u_numflow.js",
     "u_numflow_bg.js",
-    "u_numflow.d.ts"
+    "u_numflow.d.ts",
+    "node"
   ],
   "main": "u_numflow.js",
   "types": "u_numflow.d.ts",
   "sideEffects": [
     "./u_numflow.js",
-    "./snippets/*"
+    "./snippets/*",
+    "./node/u_numflow.cjs"
   ],
   "keywords": [
     "statistics",
     "probability",
     "optimization",
     "mathematics"
-  ]
-}
+  ],
+  "exports": {
+    ".": {
+      "node": {
+        "types": "./node/u_numflow.d.cts",
+        "default": "./node/u_numflow.cjs"
+      },
+      "types": "./u_numflow.d.ts",
+      "default": "./u_numflow.js"
+    },
+    "./package.json": "./package.json"
+  }
+}

package/u_numflow.js

@@ -1,7 +1,7 @@
 /* @ts-self-types="./u_numflow.d.ts" */
-
 import * as wasm from "./u_numflow_bg.wasm";
 import { __wbg_set_wasm } from "./u_numflow_bg.js";
+
 __wbg_set_wasm(wasm);
 wasm.__wbindgen_start();
 export {

package/u_numflow_bg.js

@@ -128,8 +128,7 @@ function getFloat64ArrayMemory0() {
 }
 
 function getStringFromWasm0(ptr, len) {
-    ptr = ptr >>> 0;
-    return decodeText(ptr, len);
+    return decodeText(ptr >>> 0, len);
 }
 
 let cachedUint8ArrayMemory0 = null;