@iyulab/u-doe 0.2.0 → 0.3.0

package/README.md

@@ -121,6 +121,115 @@ println!("Required replicates: {n}");
 - Jones, B. & Nachtsheim, C.J. (2011). A Class of Three-Level Designs for Definitive Screening in the Presence of Second-Order Effects. *Journal of Quality Technology* 43(1), 1–15.
 - Taguchi, G. (1986). *Introduction to Quality Engineering*. Asian Productivity Organization.
 
+## WebAssembly / npm
+
+Available as an npm package via [wasm-pack](https://rustwasm.github.io/wasm-pack/).
+
+```bash
+npm install @iyulab/u-doe
+```
+
+### Quick Start
+
+```javascript
+import init, { full_factorial, doe_anova } from '@iyulab/u-doe';
+
+await init();
+const design = full_factorial(3); // 2^3 = 8 runs
+```
+
+### Functions
+
+#### `full_factorial(k) -> DesignMatrix`
+
+Generate a 2^k full factorial design (k = 1..7).
+
+**Output:**
+```json
+{ "data": [[...]], "factor_names": ["X1","X2"], "run_count": 4, "factor_count": 2 }
+```
+
+#### `fractional_factorial(k, p) -> DesignMatrix`
+
+Generate a 2^(k-p) fractional factorial design (k = 4..7, p = 1..3).
+
+#### `plackett_burman(k) -> DesignMatrix`
+
+Generate a Plackett-Burman screening design (k = 1..19).
+
+#### `ccd(k, design_type, n_center) -> DesignMatrix`
+
+Generate a Central Composite Design. `design_type`: `"FaceCentered"` | `"Rotatable"` | `"Inscribed"`. k = 2..6.
+
+#### `box_behnken(k, n_center) -> DesignMatrix`
+
+Generate a Box-Behnken design (k = 3, 4, or 5).
+
+#### `taguchi_array(name, k) -> DesignMatrix`
+
+Get a Taguchi orthogonal array. `name`: `"L4"` | `"L8"` | `"L9"` | `"L12"` | `"L16"` | `"L18"` | `"L27"`.
+
+#### `definitive_screening(k) -> DesignMatrix`
+
+Generate a Definitive Screening Design (k = 2..12).
+
+#### `doe_anova(design, responses, factor_names, effect_names) -> AnovaResult`
+
+Perform DOE ANOVA on a coded design matrix.
+
+**Input:** `design`: `[[f64]]`, `responses`: `Float64Array`, `factor_names`: `["A","B"]`, `effect_names`: `["A","B","AB"]`
+
+**Output:**
+```json
+{ "effects": [{ "name": "A", "sum_of_squares": 10.0, "df": 1, "mean_square": 10.0, "f_statistic": 5.0, "p_value": 0.03 }], "residual_ss": 4.0, "residual_df": 2, "total_ss": 14.0, "r_squared": 0.71, "r_squared_adj": 0.57 }
+```
+
+#### `signal_to_noise(responses, goal) -> [f64]`
+
+Compute Taguchi S/N ratios. `responses`: `[[f64]]` (replicates per run). `goal`: `"LargerIsBetter"` | `"SmallerIsBetter"` | `"NominalIsBest"`.
+
+#### `estimate_effects(design, responses, factor_names, max_order) -> EffectsResult`
+
+Estimate main effects and interactions for a 2-level factorial design.
+
+**Output:**
+```json
+{ "effects": [{ "name": "A", "estimate": 21.6, "sum_of_squares": 1870.6, "percent_contribution": 45.2 }], "half_normal": [[21.6, 1.15]] }
+```
+
+#### `fit_rsm(design, responses, factor_names) -> RsmModel`
+
+Fit a second-order Response Surface Model via OLS.
+
+**Output:**
+```json
+{ "coefficients": [10.0, 2.5, -1.3, 0.5, 0.8, -0.2], "r_squared": 0.95, "factor_count": 2 }
+```
+
+#### `steepest_ascent(coefficients, factor_count, n_steps, step_size) -> AscentResult`
+
+Compute the steepest ascent path from a fitted RSM model.
+
+**Output:**
+```json
+{ "steps": [{ "coded": [0.5, 0.3], "step_number": 1 }] }
+```
+
+#### `desirability(specs, responses) -> DesirabilityResult`
+
+Compute Derringer-Suich desirability for multiple responses.
+
+**Input:** `specs`: `[{ "goal": "Maximize"|"Minimize"|"Target", "lower": 0, "target": 100, "upper": 100, "s1": 1, "s2": 1 }]`, `responses`: `Float64Array`
+
+**Output:**
+```json
+{ "individual": [0.8, 0.6], "overall": 0.69 }
+```
+
+#### `two_level_factorial_power(k, p, n_replicates, effect_size, sigma, alpha) -> f64`
+
+Compute statistical power of a 2^(k-p) factorial design. Returns power in [0, 1].
+
 ## Related
 
 - [`u-analytics`](https://crates.io/crates/u-analytics) — SPC, process capability, statistical analysis

package/package.json

@@ -5,7 +5,7 @@
     "iyulab"
   ],
   "description": "Design of Experiments (DOE) framework: factorial, Plackett-Burman, CCD, Box-Behnken, Taguchi, effects analysis, RSM, and desirability optimization.",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "license": "MIT",
   "repository": {
     "type": "git",

package/u_doe.d.ts

@@ -38,6 +38,21 @@ export function ccd(k: number, design_type: string, n_center: number): any;
  */
 export function definitive_screening(k: number): any;
 
+/**
+ * Compute Derringer-Suich desirability for multiple responses.
+ *
+ * `specs_json`: JSON array of response specifications, each:
+ *   `{ goal: "Maximize"|"Minimize"|"Target", lower, target, upper, s1, s2 }`
+ * `responses`: flat array of observed response values (one per spec).
+ *
+ * Returns `{ individual: [f64], overall: f64 }`.
+ *
+ * # Errors
+ * Returns an error string if JSON is malformed, specs/responses length mismatch,
+ * or goal string is unrecognised.
+ */
+export function desirability(specs_json: any, responses: Float64Array): any;
+
 /**
  * Perform DOE ANOVA.
  *
@@ -54,6 +69,52 @@ export function definitive_screening(k: number): any;
  */
 export function doe_anova(design_json: any, responses: Float64Array, factor_names_json: any, effect_names_json: any): any;
 
+/**
+ * Estimate main effects and interactions for a 2-level factorial design,
+ * plus half-normal plot data for identifying active effects.
+ *
+ * `design_json`: JSON array-of-arrays `[[f64]]` — the coded design matrix (rows = runs).
+ * `responses`: flat array of response values, one per run.
+ * `factor_names_json`: JSON array of factor name strings.
+ * `max_order`: maximum interaction order (1 = main effects only, 2 = + 2FI, 3 = + 3FI).
+ *
+ * Returns `{ effects: [{ name, estimate, sum_of_squares, percent_contribution }],
+ *            half_normal: [[abs_effect, quantile]] }`.
+ *
+ * # Errors
+ * Returns an error string if dimensions do not match or JSON is malformed.
+ */
+export function estimate_effects(design_json: any, responses: Float64Array, factor_names_json: any, max_order: number): any;
+
+/**
+ * Fit a second-order Response Surface Model (RSM) using OLS.
+ *
+ * `design_json`: JSON array-of-arrays `[[f64]]` — the coded design matrix.
+ * `responses`: flat array of response values, one per run.
+ * `factor_names_json`: JSON array of factor name strings.
+ *
+ * Returns `{ coefficients: [f64], r_squared: f64, factor_count: usize }`.
+ * Coefficient order: [intercept, linear..., quadratic..., interactions...].
+ *
+ * # Errors
+ * Returns an error string if dimensions do not match, JSON is malformed,
+ * or the model matrix is singular.
+ */
+export function fit_rsm(design_json: any, responses: Float64Array, factor_names_json: any): any;
+
+/**
+ * Generate a 2^(k-p) fractional factorial design.
+ *
+ * Uses standard generators from Montgomery (2019) Table 8.14.
+ * Supported: k=4..7, p=1..3 (standard combinations only).
+ *
+ * Returns `{ data: [[f64]], factor_names: [str], run_count: usize, factor_count: usize }`.
+ *
+ * # Errors
+ * Returns an error string if the (k, p) combination is not in the standard table.
+ */
+export function fractional_factorial(k: number, p: number): any;
+
 /**
  * Generate a 2^k full factorial design.
  *
@@ -64,6 +125,18 @@ export function doe_anova(design_json: any, responses: Float64Array, factor_name
  */
 export function full_factorial(k: number): any;
 
+/**
+ * Generate a Plackett-Burman screening design for `k` factors (1 ≤ k ≤ 19).
+ *
+ * Automatically selects the smallest N (multiple of 4) such that N − 1 ≥ k.
+ *
+ * Returns `{ data: [[f64]], factor_names: [str], run_count: usize, factor_count: usize }`.
+ *
+ * # Errors
+ * Returns an error string if `k == 0` or `k > 19`.
+ */
+export function plackett_burman(k: number): any;
+
 /**
  * Compute Taguchi Signal-to-Noise ratios.
  *
@@ -79,6 +152,18 @@ export function full_factorial(k: number): any;
  */
 export function signal_to_noise(responses_json: any, goal: string): any;
 
+/**
+ * Compute the steepest ascent path from a fitted RSM model.
+ *
+ * `coefficients_json`: JSON array of model coefficients (from `fit_rsm`).
+ * `factor_count`: number of factors in the model.
+ * `n_steps`: number of steps along the ascent path.
+ * `step_size`: step size in coded units.
+ *
+ * Returns `{ steps: [{ coded: [f64], step_number: usize }] }`.
+ */
+export function steepest_ascent(coefficients_json: any, factor_count: number, n_steps: number, step_size: number): any;
+
 /**
  * Get a Taguchi orthogonal array.
  *

package/u_doe.js

@@ -5,5 +5,5 @@ import { __wbg_set_wasm } from "./u_doe_bg.js";
 __wbg_set_wasm(wasm);
 wasm.__wbindgen_start();
 export {
-    box_behnken, ccd, definitive_screening, doe_anova, full_factorial, signal_to_noise, taguchi_array, two_level_factorial_power
+    box_behnken, ccd, definitive_screening, desirability, doe_anova, estimate_effects, fit_rsm, fractional_factorial, full_factorial, plackett_burman, signal_to_noise, steepest_ascent, taguchi_array, two_level_factorial_power
 } from "./u_doe_bg.js";

package/u_doe_bg.js

@@ -64,6 +64,32 @@ export function definitive_screening(k) {
     return takeFromExternrefTable0(ret[0]);
 }
 
+/**
+ * Compute Derringer-Suich desirability for multiple responses.
+ *
+ * `specs_json`: JSON array of response specifications, each:
+ *   `{ goal: "Maximize"|"Minimize"|"Target", lower, target, upper, s1, s2 }`
+ * `responses`: flat array of observed response values (one per spec).
+ *
+ * Returns `{ individual: [f64], overall: f64 }`.
+ *
+ * # Errors
+ * Returns an error string if JSON is malformed, specs/responses length mismatch,
+ * or goal string is unrecognised.
+ * @param {any} specs_json
+ * @param {Float64Array} responses
+ * @returns {any}
+ */
+export function desirability(specs_json, responses) {
+    const ptr0 = passArrayF64ToWasm0(responses, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.desirability(specs_json, ptr0, len0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
 /**
  * Perform DOE ANOVA.
  *
@@ -93,6 +119,86 @@ export function doe_anova(design_json, responses, factor_names_json, effect_name
     return takeFromExternrefTable0(ret[0]);
 }
 
+/**
+ * Estimate main effects and interactions for a 2-level factorial design,
+ * plus half-normal plot data for identifying active effects.
+ *
+ * `design_json`: JSON array-of-arrays `[[f64]]` — the coded design matrix (rows = runs).
+ * `responses`: flat array of response values, one per run.
+ * `factor_names_json`: JSON array of factor name strings.
+ * `max_order`: maximum interaction order (1 = main effects only, 2 = + 2FI, 3 = + 3FI).
+ *
+ * Returns `{ effects: [{ name, estimate, sum_of_squares, percent_contribution }],
+ *            half_normal: [[abs_effect, quantile]] }`.
+ *
+ * # Errors
+ * Returns an error string if dimensions do not match or JSON is malformed.
+ * @param {any} design_json
+ * @param {Float64Array} responses
+ * @param {any} factor_names_json
+ * @param {number} max_order
+ * @returns {any}
+ */
+export function estimate_effects(design_json, responses, factor_names_json, max_order) {
+    const ptr0 = passArrayF64ToWasm0(responses, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.estimate_effects(design_json, ptr0, len0, factor_names_json, max_order);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * Fit a second-order Response Surface Model (RSM) using OLS.
+ *
+ * `design_json`: JSON array-of-arrays `[[f64]]` — the coded design matrix.
+ * `responses`: flat array of response values, one per run.
+ * `factor_names_json`: JSON array of factor name strings.
+ *
+ * Returns `{ coefficients: [f64], r_squared: f64, factor_count: usize }`.
+ * Coefficient order: [intercept, linear..., quadratic..., interactions...].
+ *
+ * # Errors
+ * Returns an error string if dimensions do not match, JSON is malformed,
+ * or the model matrix is singular.
+ * @param {any} design_json
+ * @param {Float64Array} responses
+ * @param {any} factor_names_json
+ * @returns {any}
+ */
+export function fit_rsm(design_json, responses, factor_names_json) {
+    const ptr0 = passArrayF64ToWasm0(responses, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.fit_rsm(design_json, ptr0, len0, factor_names_json);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * Generate a 2^(k-p) fractional factorial design.
+ *
+ * Uses standard generators from Montgomery (2019) Table 8.14.
+ * Supported: k=4..7, p=1..3 (standard combinations only).
+ *
+ * Returns `{ data: [[f64]], factor_names: [str], run_count: usize, factor_count: usize }`.
+ *
+ * # Errors
+ * Returns an error string if the (k, p) combination is not in the standard table.
+ * @param {number} k
+ * @param {number} p
+ * @returns {any}
+ */
+export function fractional_factorial(k, p) {
+    const ret = wasm.fractional_factorial(k, p);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
 /**
  * Generate a 2^k full factorial design.
  *
@@ -111,6 +217,26 @@ export function full_factorial(k) {
     return takeFromExternrefTable0(ret[0]);
 }
 
+/**
+ * Generate a Plackett-Burman screening design for `k` factors (1 ≤ k ≤ 19).
+ *
+ * Automatically selects the smallest N (multiple of 4) such that N − 1 ≥ k.
+ *
+ * Returns `{ data: [[f64]], factor_names: [str], run_count: usize, factor_count: usize }`.
+ *
+ * # Errors
+ * Returns an error string if `k == 0` or `k > 19`.
+ * @param {number} k
+ * @returns {any}
+ */
+export function plackett_burman(k) {
+    const ret = wasm.plackett_burman(k);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
 /**
  * Compute Taguchi Signal-to-Noise ratios.
  *
@@ -137,6 +263,29 @@ export function signal_to_noise(responses_json, goal) {
     return takeFromExternrefTable0(ret[0]);
 }
 
+/**
+ * Compute the steepest ascent path from a fitted RSM model.
+ *
+ * `coefficients_json`: JSON array of model coefficients (from `fit_rsm`).
+ * `factor_count`: number of factors in the model.
+ * `n_steps`: number of steps along the ascent path.
+ * `step_size`: step size in coded units.
+ *
+ * Returns `{ steps: [{ coded: [f64], step_number: usize }] }`.
+ * @param {any} coefficients_json
+ * @param {number} factor_count
+ * @param {number} n_steps
+ * @param {number} step_size
+ * @returns {any}
+ */
+export function steepest_ascent(coefficients_json, factor_count, n_steps, step_size) {
+    const ret = wasm.steepest_ascent(coefficients_json, factor_count, n_steps, step_size);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
 /**
  * Get a Taguchi orthogonal array.
  *
@@ -210,6 +359,10 @@ export function __wbg___wbindgen_debug_string_5398f5bb970e0daa(arg0, arg1) {
     getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
     getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
 }
+export function __wbg___wbindgen_in_41dbb8413020e076(arg0, arg1) {
+    const ret = arg0 in arg1;
+    return ret;
+}
 export function __wbg___wbindgen_is_function_3c846841762788c1(arg0) {
     const ret = typeof(arg0) === 'function';
     return ret;
@@ -219,6 +372,10 @@ export function __wbg___wbindgen_is_object_781bc9f159099513(arg0) {
     const ret = typeof(val) === 'object' && val !== null;
     return ret;
 }
+export function __wbg___wbindgen_is_undefined_52709e72fb9f179c(arg0) {
+    const ret = arg0 === undefined;
+    return ret;
+}
 export function __wbg___wbindgen_jsval_loose_eq_5bcc3bed3c69e72b(arg0, arg1) {
     const ret = arg0 == arg1;
     return ret;
@@ -256,6 +413,10 @@ export function __wbg_get_unchecked_329cfe50afab7352(arg0, arg1) {
     const ret = arg0[arg1 >>> 0];
     return ret;
 }
+export function __wbg_get_with_ref_key_6412cf3094599694(arg0, arg1) {
+    const ret = arg0[arg1];
+    return ret;
+}
 export function __wbg_instanceof_ArrayBuffer_101e2bf31071a9f6(arg0) {
     let result;
     try {