@iyulab/u-numflow 0.7.0 → 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
@@ -112,6 +112,12 @@ Exported functions: `mean`, `std_dev`, `variance`, `normal_cdf`, `normal_sf` (up
 `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** (an `Error` naming the argument — see *Errors* below) when an argument is outside the domain,
 rather than returning `NaN`:
@@ -146,9 +152,11 @@ try {
 | `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) |
-| `value_not_finite` | `parameter` (for a scalar argument) | A NaN argument, or a NaN or infinity in `box_cox`/`estimate_lambda` data |
+| `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` | — | Box-Cox data with fewer than 2 values |
+| `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` |
 
@@ -159,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

@@ -9,20 +9,18 @@
  * 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 {Float64Array} data
+ * @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;
 
@@ -75,15 +73,13 @@ exports.chi_squared_quantile = chi_squared_quantile;
  * # Errors
  * Throws as [`box_cox`] does for the data, and `invalid_lambda_range` when the
  * range is not finite with `lambda_min < lambda_max`.
- * @param {Float64Array} data
+ * @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,9 +297,57 @@ 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;
@@ -300,6 +356,9 @@ function __wbg_get_imports() {
             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;
@@ -381,11 +440,8 @@ function handleError(f, args) {
     }
 }
 
-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 isLikeNone(x) {
+    return x === undefined || x === null;
 }
 
 function passStringToWasm0(arg, malloc, realloc) {

package/node/u_numflow.d.cts

@@ -19,7 +19,7 @@ export interface LambdaEstimateDto {
  * 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`).
@@ -51,7 +51,7 @@ export function chi_squared_quantile(p: number, k: number): number;
  * 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.7.0",
+  "version": "0.8.0",
   "license": "MIT",
   "repository": {
     "type": "git",

package/u_numflow.d.ts

@@ -19,7 +19,7 @@ export interface LambdaEstimateDto {
  * 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`).
@@ -51,7 +51,7 @@ export function chi_squared_quantile(p: number, k: number): number;
  * 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

@@ -7,20 +7,18 @@
  * 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 {Float64Array} data
+ * @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;
 }
 
 /**
@@ -70,15 +68,13 @@ export function chi_squared_quantile(p, k) {
  * # Errors
  * Throws as [`box_cox`] does for the data, and `invalid_lambda_range` when the
  * range is not finite with `lambda_min < lambda_max`.
- * @param {Float64Array} data
+ * @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,9 +277,57 @@ 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;
@@ -280,6 +336,9 @@ 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;
@@ -354,11 +413,8 @@ function handleError(f, args) {
     }
 }
 
-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 isLikeNone(x) {
+    return x === undefined || x === null;
 }
 
 function passStringToWasm0(arg, malloc, realloc) {