@iyulab/u-numflow 0.6.4 → 0.8.0

package/README.md

@@ -34,7 +34,7 @@ u-numflow provides foundational mathematical, statistical, and probabilistic bui
 
 ```toml
 [dependencies]
-u-numflow = "0.2"
+u-numflow = "0.8"
 ```
 
 ```rust
@@ -103,12 +103,23 @@ The package resolves per environment via a conditional `exports` map:
 | 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 |
 
+A browser **without** a bundler is not supported: the package loads its `.wasm`
+file with an ES module import, which browsers refuse (`application/wasm` is not a
+module script type), so `<script type="module">` from a CDN fails, and CDN
+re-bundling services fail on the same import. Use a bundler or Node.
+
 Exported functions: `mean`, `std_dev`, `variance`, `normal_cdf`, `normal_sf` (upper tail `P(Z > x)`, computed directly so tail probabilities keep ~15 significant digits), `box_cox`, `estimate_lambda` (returns `{ lambda, at_bound }` — `at_bound` is `true` when the likelihood was still rising at an end of the search range, so `lambda` is that limit), and
 `rfft(data) -> Float64Array` — the DFT of a real sequence of any length, interleaved as
 `[re0, im0, re1, im1, …]` (bins `k` and `n − k` are conjugates, so `0..=n/2` describes the spectrum).
 
+Every `data` argument is a `number[]` or a `Float64Array`, read exactly as sent: an
+element that is not a number (`null`, `undefined`, a string) throws `malformed_input`
+and a NaN or ±Infinity throws `value_not_finite`, each with the element's `index` —
+`mean([1, null, 3])` throws rather than averaging the `null` as 0. `mean` of no values
+throws `empty_input`; `std_dev` and `variance` of fewer than 2 throw `insufficient_data`.
+
 Distribution functions for critical values and p-values — each returns a `number` and
-**throws** (a message naming the argument) when an argument is outside the domain,
+**throws** (an `Error` naming the argument — see *Errors* below) when an argument is outside the domain,
 rather than returning `NaN`:
 
 | Function | Returns |
@@ -126,6 +137,29 @@ const { t_distribution_quantile } = require("@iyulab/u-numflow");
 t_distribution_quantile(0.975, 10); // 2.2281…
 ```
 
+**Errors.** A refusal throws an `Error` whose `message` is readable text and which
+carries a `code` naming the reason, next to the values behind it:
+
+```js
+const { t_distribution_quantile } = require("@iyulab/u-numflow");
+try {
+  t_distribution_quantile(1.5, 10);
+} catch (err) {
+  console.log(err.code, err.parameter, err.min, err.max, err.got); // parameter_out_of_range p 0 1 1.5
+}
+```
+
+| `code` | Fields | Meaning |
+|---|---|---|
+| `parameter_out_of_range` | `parameter`, `min`, `max` (or `null`), `got` | `p` not strictly inside (0, 1), or a degrees of freedom that is not a finite number `> 0` (both bounds excluded) |
+| `malformed_input` | `parameter`, `index` (or absent) | A `data` argument that is not an array or `Float64Array`, or an element that is not a number |
+| `value_not_finite` | `parameter`, `index` for an array element | A NaN argument, or a NaN or infinity in any `data` array |
+| `empty_input` | `parameter` | `mean` of no values |
+| `non_positive_data` | — | Box-Cox data with a value `≤ 0` |
+| `insufficient_data` | `parameter`, `min`, `got` for `std_dev`/`variance`; — for Box-Cox | Fewer values than the function needs (`std_dev`/`variance` 2, Box-Cox 2) |
+| `invalid_transform` | — | A Box-Cox result that is not finite |
+| `invalid_lambda_range` | — | `estimate_lambda` bounds that are not finite with `lambda_min < lambda_max` |
+
 ### TypeScript
 
 Every exported function declares its parameter and return types, and the
@@ -133,17 +167,18 @@ declarations are generated from the same structs the binding reads and
 serialises, so they cannot drift from what it actually accepts and returns:
 
 ```ts
-export function estimate_lambda(data: Float64Array, lambda_min: number, lambda_max: number): LambdaEstimateDto;
+export function mean(data: number[] | Float64Array): number;
+export function estimate_lambda(data: number[] | Float64Array, lambda_min: number, lambda_max: number): LambdaEstimateDto;
 ```
 
 An absent optional value is declared `T | undefined`, which is what the binding
 sends. Nothing needs an `as` cast -- and a wrong assumption about a result's
 shape is a compile error rather than something that fails at run time.
 
-Every parameter is a number or a `Float64Array`, so there is nothing to
-declare beyond what wasm-bindgen already does; the publishing workflow keeps it
-that way. The binding still validates every input at the boundary, and a
-rejected one says what was wrong.
+A `data` parameter is declared `number[] | Float64Array` and read by the
+binding itself rather than copied into a typed array by the generated glue, so
+a value the declaration does not allow is refused where it sits instead of
+being converted. The publishing workflow keeps every declaration free of `any`.
 
 ## Related
 

package/node/u_numflow.cjs

@@ -6,22 +6,21 @@
  * 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
+ * Throws `non_positive_data`, `value_not_finite` or `insufficient_data` when
+ * data contains a value ≤ 0, a NaN or infinity, or fewer than 2 elements, and
+ * `invalid_transform` when a result is not finite.
+ * @param {number[] | 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);
+    const ret = wasm.box_cox(data, lambda);
     if (ret[3]) {
         throw takeFromExternrefTable0(ret[2]);
     }
-    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
     wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
-    return v2;
+    return v1;
 }
 exports.box_cox = box_cox;
 
@@ -72,18 +71,15 @@ exports.chi_squared_quantile = chi_squared_quantile;
  * interior estimate; widen the range to find the unconstrained optimum.
  *
  * # Errors
- * Returns a `JsValue` error string if data contains non-positive values,
- * has fewer than 2 elements, or the range is not finite with
- * `lambda_min < lambda_max`.
- * @param {Float64Array} data
+ * Throws as [`box_cox`] does for the data, and `invalid_lambda_range` when the
+ * range is not finite with `lambda_min < lambda_max`.
+ * @param {number[] | Float64Array} data
  * @param {number} lambda_min
  * @param {number} lambda_max
  * @returns {LambdaEstimateDto}
  */
 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);
+    const ret = wasm.estimate_lambda(data, lambda_min, lambda_max);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
@@ -150,15 +146,18 @@ exports.inverse_normal_cdf = inverse_normal_cdf;
 /**
  * Arithmetic mean of `data` using Kahan compensated summation.
  *
- * Returns `NaN` if `data` is empty or contains non-finite values.
- * @param {Float64Array} data
+ * # Errors
+ * Throws `empty_input` when `data` is empty, and as every `data` argument
+ * does for an element that is not a finite number.
+ * @param {number[] | 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;
+    const ret = wasm.mean(data);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return ret[0];
 }
 exports.mean = mean;
 
@@ -199,31 +198,38 @@ exports.normal_sf = normal_sf;
  * Returns the `n` complex bins interleaved as `[re0, im0, re1, im1, …]`
  * (length `2n`). Bins `k` and `n − k` are conjugates, so the spectrum of a
  * real signal is fully described by bins `0..=n/2`.
- * @param {Float64Array} data
+ *
+ * # Errors
+ * Throws as every `data` argument does for an element that is not a finite
+ * number.
+ * @param {number[] | Float64Array} data
  * @returns {Float64Array}
  */
 function rfft(data) {
-    const ptr0 = passArrayF64ToWasm0(data, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.rfft(ptr0, len0);
-    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    const ret = wasm.rfft(data);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
     wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
-    return v2;
+    return v1;
 }
 exports.rfft = rfft;
 
 /**
  * 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
+ * # Errors
+ * Throws `insufficient_data` below 2 values.
+ * @param {number[] | 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;
+    const ret = wasm.std_dev(data);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return ret[0];
 }
 exports.std_dev = std_dev;
 
@@ -268,15 +274,17 @@ exports.t_distribution_quantile = t_distribution_quantile;
 /**
  * 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
+ * # Errors
+ * Throws `insufficient_data` below 2 values.
+ * @param {number[] | 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;
+    const ret = wasm.variance(data);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return ret[0];
 }
 exports.variance = variance;
 function __wbg_get_imports() {
@@ -289,13 +297,72 @@ function __wbg_get_imports() {
             getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
             getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
         },
+        __wbg___wbindgen_is_null_e343b7d08827ba72: function(arg0) {
+            const ret = arg0 === null;
+            return ret;
+        },
+        __wbg___wbindgen_number_get_2e0e7dee9f701a71: function(arg0, arg1) {
+            const obj = arg1;
+            const ret = typeof(obj) === 'number' ? obj : undefined;
+            getDataViewMemory0().setFloat64(arg0 + 8 * 1, isLikeNone(ret) ? 0 : ret, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
+        },
+        __wbg___wbindgen_string_get_0380ccaa2f57f0d9: function(arg0, arg1) {
+            const obj = arg1;
+            const ret = typeof(obj) === 'string' ? obj : undefined;
+            var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            var len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        },
         __wbg___wbindgen_throw_41e9ee4f547fc59a: function(arg0, arg1) {
             throw new Error(getStringFromWasm0(arg0, arg1));
         },
+        __wbg___wbindgen_typeof_e777a26e115d416b: function(arg0) {
+            const ret = typeof arg0;
+            return ret;
+        },
+        __wbg_get_unchecked_288889d017702237: function(arg0, arg1) {
+            const ret = arg0[arg1 >>> 0];
+            return ret;
+        },
+        __wbg_instanceof_Float64Array_8a59377f9eec1b8b: function(arg0) {
+            let result;
+            try {
+                result = arg0 instanceof Float64Array;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
+        __wbg_isArray_e15a2ff68ffdbef2: function(arg0) {
+            const ret = Array.isArray(arg0);
+            return ret;
+        },
+        __wbg_length_b5f0008bbf60cf59: function(arg0) {
+            const ret = arg0.length;
+            return ret;
+        },
+        __wbg_length_d4bdea10311bd9cf: function(arg0) {
+            const ret = arg0.length;
+            return ret;
+        },
+        __wbg_new_343a093a3c2ffb4e: function(arg0, arg1) {
+            const ret = new Error(getStringFromWasm0(arg0, arg1));
+            return ret;
+        },
         __wbg_new_617a8cdb8bb1130e: function() {
             const ret = new Object();
             return ret;
         },
+        __wbg_prototypesetcall_d49a4fab5ca427bc: function(arg0, arg1, arg2) {
+            Float64Array.prototype.set.call(getArrayF64FromWasm0(arg0, arg1), arg2);
+        },
+        __wbg_set_145a351398b48c65: function() { return handleError(function (arg0, arg1, arg2) {
+            const ret = Reflect.set(arg0, arg1, arg2);
+            return ret;
+        }, arguments); },
         __wbg_set_6be42768c690e380: function(arg0, arg1, arg2) {
             arg0[arg1] = arg2;
         },
@@ -325,6 +392,12 @@ function __wbg_get_imports() {
     };
 }
 
+function addToExternrefTable0(obj) {
+    const idx = wasm.__externref_table_alloc();
+    wasm.__wbindgen_externrefs.set(idx, obj);
+    return idx;
+}
+
 function getArrayF64FromWasm0(ptr, len) {
     ptr = ptr >>> 0;
     return getFloat64ArrayMemory0().subarray(ptr / 8, ptr / 8 + len);
@@ -358,11 +431,17 @@ function getUint8ArrayMemory0() {
     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 handleError(f, args) {
+    try {
+        return f.apply(this, args);
+    } catch (e) {
+        const idx = addToExternrefTable0(e);
+        wasm.__wbindgen_exn_store(idx);
+    }
+}
+
+function isLikeNone(x) {
+    return x === undefined || x === null;
 }
 
 function passStringToWasm0(arg, malloc, realloc) {

package/node/u_numflow.d.cts

@@ -15,10 +15,11 @@ export interface LambdaEstimateDto {
  * 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.
+ * Throws `non_positive_data`, `value_not_finite` or `insufficient_data` when
+ * data contains a value ≤ 0, a NaN or infinity, or fewer than 2 elements, and
+ * `invalid_transform` when a result is not finite.
  */
-export function box_cox(data: Float64Array, lambda: number): Float64Array;
+export function box_cox(data: number[] | Float64Array, lambda: number): Float64Array;
 
 /**
  * Chi-squared CDF: `P(X ≤ x)` for `X ~ χ²(k)` (`0` for `x ≤ 0`).
@@ -47,11 +48,10 @@ export function chi_squared_quantile(p: number, k: number): number;
  * interior estimate; widen the range to find the unconstrained optimum.
  *
  * # Errors
- * Returns a `JsValue` error string if data contains non-positive values,
- * has fewer than 2 elements, or the range is not finite with
- * `lambda_min < lambda_max`.
+ * Throws as [`box_cox`] does for the data, and `invalid_lambda_range` when the
+ * range is not finite with `lambda_min < lambda_max`.
  */
-export function estimate_lambda(data: Float64Array, lambda_min: number, lambda_max: number): LambdaEstimateDto;
+export function estimate_lambda(data: number[] | Float64Array, lambda_min: number, lambda_max: number): LambdaEstimateDto;
 
 /**
  * F CDF: `P(X ≤ x)` for `X ~ F(df1, df2)` (`0` for `x ≤ 0`).
@@ -81,9 +81,11 @@ export function inverse_normal_cdf(p: number): number;
 /**
  * Arithmetic mean of `data` using Kahan compensated summation.
  *
- * Returns `NaN` if `data` is empty or contains non-finite values.
+ * # Errors
+ * Throws `empty_input` when `data` is empty, and as every `data` argument
+ * does for an element that is not a finite number.
  */
-export function mean(data: Float64Array): number;
+export function mean(data: number[] | Float64Array): number;
 
 /**
  * Standard normal CDF Φ(x) = P(Z ≤ x) for Z ~ N(0, 1).
@@ -110,15 +112,20 @@ export function normal_sf(x: number): number;
  * Returns the `n` complex bins interleaved as `[re0, im0, re1, im1, …]`
  * (length `2n`). Bins `k` and `n − k` are conjugates, so the spectrum of a
  * real signal is fully described by bins `0..=n/2`.
+ *
+ * # Errors
+ * Throws as every `data` argument does for an element that is not a finite
+ * number.
  */
-export function rfft(data: Float64Array): Float64Array;
+export function rfft(data: number[] | Float64Array): Float64Array;
 
 /**
  * Sample standard deviation of `data` (Bessel-corrected, denominator n−1).
  *
- * Returns `NaN` if `data` has fewer than 2 elements or contains non-finite values.
+ * # Errors
+ * Throws `insufficient_data` below 2 values.
  */
-export function std_dev(data: Float64Array): number;
+export function std_dev(data: number[] | Float64Array): number;
 
 /**
  * Student's t CDF: `P(T ≤ t)` for `T ~ t(df)`. `df` may be fractional.
@@ -141,6 +148,7 @@ export function t_distribution_quantile(p: number, df: number): number;
 /**
  * Sample variance of `data` (Bessel-corrected, denominator n−1).
  *
- * Returns `NaN` if `data` has fewer than 2 elements or contains non-finite values.
+ * # Errors
+ * Throws `insufficient_data` below 2 values.
  */
-export function variance(data: Float64Array): number;
+export function variance(data: number[] | Float64Array): number;

package/package.json

@@ -5,7 +5,7 @@
     "iyulab"
   ],
   "description": "Foundational mathematical primitives: statistics, probability distributions, random sampling, and collections.",
-  "version": "0.6.4",
+  "version": "0.8.0",
   "license": "MIT",
   "repository": {
     "type": "git",

package/u_numflow.d.ts

@@ -15,10 +15,11 @@ export interface LambdaEstimateDto {
  * 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.
+ * Throws `non_positive_data`, `value_not_finite` or `insufficient_data` when
+ * data contains a value ≤ 0, a NaN or infinity, or fewer than 2 elements, and
+ * `invalid_transform` when a result is not finite.
  */
-export function box_cox(data: Float64Array, lambda: number): Float64Array;
+export function box_cox(data: number[] | Float64Array, lambda: number): Float64Array;
 
 /**
  * Chi-squared CDF: `P(X ≤ x)` for `X ~ χ²(k)` (`0` for `x ≤ 0`).
@@ -47,11 +48,10 @@ export function chi_squared_quantile(p: number, k: number): number;
  * interior estimate; widen the range to find the unconstrained optimum.
  *
  * # Errors
- * Returns a `JsValue` error string if data contains non-positive values,
- * has fewer than 2 elements, or the range is not finite with
- * `lambda_min < lambda_max`.
+ * Throws as [`box_cox`] does for the data, and `invalid_lambda_range` when the
+ * range is not finite with `lambda_min < lambda_max`.
  */
-export function estimate_lambda(data: Float64Array, lambda_min: number, lambda_max: number): LambdaEstimateDto;
+export function estimate_lambda(data: number[] | Float64Array, lambda_min: number, lambda_max: number): LambdaEstimateDto;
 
 /**
  * F CDF: `P(X ≤ x)` for `X ~ F(df1, df2)` (`0` for `x ≤ 0`).
@@ -81,9 +81,11 @@ export function inverse_normal_cdf(p: number): number;
 /**
  * Arithmetic mean of `data` using Kahan compensated summation.
  *
- * Returns `NaN` if `data` is empty or contains non-finite values.
+ * # Errors
+ * Throws `empty_input` when `data` is empty, and as every `data` argument
+ * does for an element that is not a finite number.
  */
-export function mean(data: Float64Array): number;
+export function mean(data: number[] | Float64Array): number;
 
 /**
  * Standard normal CDF Φ(x) = P(Z ≤ x) for Z ~ N(0, 1).
@@ -110,15 +112,20 @@ export function normal_sf(x: number): number;
  * Returns the `n` complex bins interleaved as `[re0, im0, re1, im1, …]`
  * (length `2n`). Bins `k` and `n − k` are conjugates, so the spectrum of a
  * real signal is fully described by bins `0..=n/2`.
+ *
+ * # Errors
+ * Throws as every `data` argument does for an element that is not a finite
+ * number.
  */
-export function rfft(data: Float64Array): Float64Array;
+export function rfft(data: number[] | Float64Array): Float64Array;
 
 /**
  * Sample standard deviation of `data` (Bessel-corrected, denominator n−1).
  *
- * Returns `NaN` if `data` has fewer than 2 elements or contains non-finite values.
+ * # Errors
+ * Throws `insufficient_data` below 2 values.
  */
-export function std_dev(data: Float64Array): number;
+export function std_dev(data: number[] | Float64Array): number;
 
 /**
  * Student's t CDF: `P(T ≤ t)` for `T ~ t(df)`. `df` may be fractional.
@@ -141,6 +148,7 @@ export function t_distribution_quantile(p: number, df: number): number;
 /**
  * Sample variance of `data` (Bessel-corrected, denominator n−1).
  *
- * Returns `NaN` if `data` has fewer than 2 elements or contains non-finite values.
+ * # Errors
+ * Throws `insufficient_data` below 2 values.
  */
-export function variance(data: Float64Array): number;
+export function variance(data: number[] | Float64Array): number;

package/u_numflow_bg.js

@@ -4,22 +4,21 @@
  * 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
+ * Throws `non_positive_data`, `value_not_finite` or `insufficient_data` when
+ * data contains a value ≤ 0, a NaN or infinity, or fewer than 2 elements, and
+ * `invalid_transform` when a result is not finite.
+ * @param {number[] | Float64Array} data
  * @param {number} lambda
  * @returns {Float64Array}
  */
 export 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);
+    const ret = wasm.box_cox(data, lambda);
     if (ret[3]) {
         throw takeFromExternrefTable0(ret[2]);
     }
-    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
     wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
-    return v2;
+    return v1;
 }
 
 /**
@@ -67,18 +66,15 @@ export function chi_squared_quantile(p, k) {
  * interior estimate; widen the range to find the unconstrained optimum.
  *
  * # Errors
- * Returns a `JsValue` error string if data contains non-positive values,
- * has fewer than 2 elements, or the range is not finite with
- * `lambda_min < lambda_max`.
- * @param {Float64Array} data
+ * Throws as [`box_cox`] does for the data, and `invalid_lambda_range` when the
+ * range is not finite with `lambda_min < lambda_max`.
+ * @param {number[] | Float64Array} data
  * @param {number} lambda_min
  * @param {number} lambda_max
  * @returns {LambdaEstimateDto}
  */
 export 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);
+    const ret = wasm.estimate_lambda(data, lambda_min, lambda_max);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
@@ -141,15 +137,18 @@ export function inverse_normal_cdf(p) {
 /**
  * Arithmetic mean of `data` using Kahan compensated summation.
  *
- * Returns `NaN` if `data` is empty or contains non-finite values.
- * @param {Float64Array} data
+ * # Errors
+ * Throws `empty_input` when `data` is empty, and as every `data` argument
+ * does for an element that is not a finite number.
+ * @param {number[] | Float64Array} data
  * @returns {number}
  */
 export function mean(data) {
-    const ptr0 = passArrayF64ToWasm0(data, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.mean(ptr0, len0);
-    return ret;
+    const ret = wasm.mean(data);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return ret[0];
 }
 
 /**
@@ -187,30 +186,37 @@ export function normal_sf(x) {
  * Returns the `n` complex bins interleaved as `[re0, im0, re1, im1, …]`
  * (length `2n`). Bins `k` and `n − k` are conjugates, so the spectrum of a
  * real signal is fully described by bins `0..=n/2`.
- * @param {Float64Array} data
+ *
+ * # Errors
+ * Throws as every `data` argument does for an element that is not a finite
+ * number.
+ * @param {number[] | Float64Array} data
  * @returns {Float64Array}
  */
 export function rfft(data) {
-    const ptr0 = passArrayF64ToWasm0(data, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.rfft(ptr0, len0);
-    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    const ret = wasm.rfft(data);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
     wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
-    return v2;
+    return v1;
 }
 
 /**
  * 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
+ * # Errors
+ * Throws `insufficient_data` below 2 values.
+ * @param {number[] | Float64Array} data
  * @returns {number}
  */
 export 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;
+    const ret = wasm.std_dev(data);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return ret[0];
 }
 
 /**
@@ -252,15 +258,17 @@ export function t_distribution_quantile(p, df) {
 /**
  * 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
+ * # Errors
+ * Throws `insufficient_data` below 2 values.
+ * @param {number[] | Float64Array} data
  * @returns {number}
  */
 export function variance(data) {
-    const ptr0 = passArrayF64ToWasm0(data, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.variance(ptr0, len0);
-    return ret;
+    const ret = wasm.variance(data);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return ret[0];
 }
 export function __wbg_String_8564e559799eccda(arg0, arg1) {
     const ret = String(arg1);
@@ -269,13 +277,72 @@ export function __wbg_String_8564e559799eccda(arg0, arg1) {
     getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
     getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
 }
+export function __wbg___wbindgen_is_null_e343b7d08827ba72(arg0) {
+    const ret = arg0 === null;
+    return ret;
+}
+export function __wbg___wbindgen_number_get_2e0e7dee9f701a71(arg0, arg1) {
+    const obj = arg1;
+    const ret = typeof(obj) === 'number' ? obj : undefined;
+    getDataViewMemory0().setFloat64(arg0 + 8 * 1, isLikeNone(ret) ? 0 : ret, true);
+    getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
+}
+export function __wbg___wbindgen_string_get_0380ccaa2f57f0d9(arg0, arg1) {
+    const obj = arg1;
+    const ret = typeof(obj) === 'string' ? obj : undefined;
+    var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len1 = WASM_VECTOR_LEN;
+    getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+    getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+}
 export function __wbg___wbindgen_throw_41e9ee4f547fc59a(arg0, arg1) {
     throw new Error(getStringFromWasm0(arg0, arg1));
 }
+export function __wbg___wbindgen_typeof_e777a26e115d416b(arg0) {
+    const ret = typeof arg0;
+    return ret;
+}
+export function __wbg_get_unchecked_288889d017702237(arg0, arg1) {
+    const ret = arg0[arg1 >>> 0];
+    return ret;
+}
+export function __wbg_instanceof_Float64Array_8a59377f9eec1b8b(arg0) {
+    let result;
+    try {
+        result = arg0 instanceof Float64Array;
+    } catch (_) {
+        result = false;
+    }
+    const ret = result;
+    return ret;
+}
+export function __wbg_isArray_e15a2ff68ffdbef2(arg0) {
+    const ret = Array.isArray(arg0);
+    return ret;
+}
+export function __wbg_length_b5f0008bbf60cf59(arg0) {
+    const ret = arg0.length;
+    return ret;
+}
+export function __wbg_length_d4bdea10311bd9cf(arg0) {
+    const ret = arg0.length;
+    return ret;
+}
+export function __wbg_new_343a093a3c2ffb4e(arg0, arg1) {
+    const ret = new Error(getStringFromWasm0(arg0, arg1));
+    return ret;
+}
 export function __wbg_new_617a8cdb8bb1130e() {
     const ret = new Object();
     return ret;
 }
+export function __wbg_prototypesetcall_d49a4fab5ca427bc(arg0, arg1, arg2) {
+    Float64Array.prototype.set.call(getArrayF64FromWasm0(arg0, arg1), arg2);
+}
+export function __wbg_set_145a351398b48c65() { return handleError(function (arg0, arg1, arg2) {
+    const ret = Reflect.set(arg0, arg1, arg2);
+    return ret;
+}, arguments); }
 export function __wbg_set_6be42768c690e380(arg0, arg1, arg2) {
     arg0[arg1] = arg2;
 }
@@ -298,6 +365,12 @@ export function __wbindgen_init_externref_table() {
     table.set(offset + 2, true);
     table.set(offset + 3, false);
 }
+function addToExternrefTable0(obj) {
+    const idx = wasm.__externref_table_alloc();
+    wasm.__wbindgen_externrefs.set(idx, obj);
+    return idx;
+}
+
 function getArrayF64FromWasm0(ptr, len) {
     ptr = ptr >>> 0;
     return getFloat64ArrayMemory0().subarray(ptr / 8, ptr / 8 + len);
@@ -331,11 +404,17 @@ function getUint8ArrayMemory0() {
     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 handleError(f, args) {
+    try {
+        return f.apply(this, args);
+    } catch (e) {
+        const idx = addToExternrefTable0(e);
+        wasm.__wbindgen_exn_store(idx);
+    }
+}
+
+function isLikeNone(x) {
+    return x === undefined || x === null;
 }
 
 function passStringToWasm0(arg, malloc, realloc) {