add clarabel wasm feature flag

Author: Specy

.github/workflows/rust.yml

@@ -38,6 +38,8 @@ jobs:
           curl -LO https://github.com/rust-or/good_lp/releases/download/cplex/cplex.bin
           chmod u+x cplex.bin
           ./cplex.bin -f ./.github/cplex/response.properties
+          # Install wasm-pack 
+          cargo install wasm-pack
       - name: Build with all default solvers (no cplex)
         run: cargo build --features all_default_solvers --tests
       - name: Run tests with all default solvers (no cplex)
@@ -57,4 +59,8 @@ jobs:
         run: cargo test --no-default-features --features cplex-rs
       - name: Run tests with Clarabel
         run: cargo test --no-default-features --features clarabel
+      - name: Run tests with Clarabel on WASM
+        run: wasm-pack test --node --no-default-features --features "clarabel,clarabel-wasm"
+      - name: Run tests with minilp on WASM
+        run: wasm-pack test --node --no-default-features --features "minilp"
       - run: cargo bench

Cargo.toml

@@ -16,6 +16,7 @@ default = ["coin_cbc", "singlethread-cbc"]
 singlethread-cbc = ["coin_cbc?/singlethread-cbc"]
 scip = ["russcip"]
 all_default_solvers = ["coin_cbc", "minilp", "lpsolve", "highs", "russcip", "lp-solvers", "clarabel"] # cplex-rs is not included because it is incompatible with lpsolve
+clarabel-wasm = ["clarabel/wasm"]
 
 [dependencies]
 coin_cbc = { version = "0.1", optional = true, default-features = false }
@@ -29,9 +30,14 @@ clarabel = { version = "0.9.0", optional = true, features = [] }
 fnv = "1.0.5"
 
 [dev-dependencies]
-criterion = "0.5"
 float_eq = "1.0"
 
+[target.'cfg(not(target_arch = "wasm32"))'.dev-dependencies]
+criterion = "0.5"
+
+[target.'cfg(target_arch = "wasm32")'.dev-dependencies]
+wasm-bindgen-test = "0.3.0"
+
 [[bench]]
 name = "benchmark"
 harness = false

benches/benchmark.rs

@@ -1,34 +1,37 @@
-use criterion::{black_box, criterion_group, criterion_main, Criterion};
+#[cfg(not(target_arch = "wasm32"))]
+mod bench {
+    use criterion::{black_box, criterion_group, criterion_main, Criterion};
 
-use good_lp::{default_solver, variable, variables, Expression, Solution, SolverModel};
+    use good_lp::{default_solver, variable, variables, Expression, Solution, SolverModel};
 
-pub fn criterion_benchmark(c: &mut Criterion) {
-    c.bench_function("sum((2 x_i + 1) for i in [1..100_000])", |b| {
-        b.iter(|| {
-            let mut vars = variables!();
-            let v: Expression = (0..100_000)
-                .map(|_i| {
-                    let x_i = vars.add_variable();
-                    black_box(2) * black_box(x_i) + black_box(1)
-                })
-                .sum();
-            v
-        })
-    });
-
-    c.bench_function(
-        "solving empty problem with 1M variables and reading results",
-        |b| {
+    pub fn criterion_benchmark(c: &mut Criterion) {
+        c.bench_function("sum((2 x_i + 1) for i in [1..100_000])", |b| {
             b.iter(|| {
                 let mut vars = variables!();
-                let vs = vars.add_vector(variable().min(0).name("test"), 1_000_000);
-                let obj: Expression = vs.iter().sum();
-                let sol = vars.minimise(&obj).using(default_solver).solve().unwrap();
-                sol.eval(obj)
+                let v: Expression = (0..100_000)
+                    .map(|_i| {
+                        let x_i = vars.add_variable();
+                        black_box(2) * black_box(x_i) + black_box(1)
+                    })
+                    .sum();
+                v
             })
-        },
-    );
-}
+        });
 
-criterion_group!(benches, criterion_benchmark);
-criterion_main!(benches);
+        c.bench_function(
+            "solving empty problem with 1M variables and reading results",
+            |b| {
+                b.iter(|| {
+                    let mut vars = variables!();
+                    let vs = vars.add_vector(variable().min(0).name("test"), 1_000_000);
+                    let obj: Expression = vs.iter().sum();
+                    let sol = vars.minimise(&obj).using(default_solver).solve().unwrap();
+                    sol.eval(obj)
+                })
+            },
+        );
+    }
+
+    criterion_group!(benches, criterion_benchmark);
+    criterion_main!(benches);
+}

tests/readme_example.rs

@@ -1,8 +1,11 @@
 use std::error::Error;
 
 use good_lp::{constraint, default_solver, variables, Solution, SolverModel};
+#[cfg(target_arch = "wasm32")]
+use wasm_bindgen_test::*;
 
 #[test]
+#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
 fn main() -> Result<(), Box<dyn Error>> {
     variables! {
         vars:

tests/resource_allocation_problem.rs

@@ -12,7 +12,8 @@
 
 use good_lp::variable::ProblemVariables;
 use good_lp::{default_solver, variable, variables, Expression, Solution, SolverModel, Variable};
-
+#[cfg(target_arch = "wasm32")]
+use wasm_bindgen_test::*;
 struct Product {
     // amount of fuel producing 1 unit takes
     needed_fuel: f64,
@@ -65,6 +66,7 @@ impl ResourceAllocationProblem {
 use float_eq::assert_float_eq;
 
 #[test]
+#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
 fn resource_allocation() {
     let mut pb = ResourceAllocationProblem::new(5., 3.);
     let steel = pb.add(Product {
@@ -87,6 +89,7 @@ fn resource_allocation() {
 }
 
 #[test]
+#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
 fn using_a_vector() {
     let products = vec![
         Product {

tests/shadow_price.rs

@@ -5,7 +5,8 @@ use good_lp::{
     solvers::{DualValues, SolutionWithDual},
     variable, variables, Solution, Solver, SolverModel,
 };
-
+#[cfg(target_arch = "wasm32")]
+use wasm_bindgen_test::*;
 // Using a generic function here ensures the dual can be retrieved in a generic,
 // solver-independent manner.
 #[allow(dead_code)]
@@ -75,6 +76,7 @@ where
 macro_rules! dual_test {
     ($([$solver_feature:literal, $solver:expr])*) => {
         #[test]
+        #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
         fn determine_shadow_prices() {
             $(
                 #[cfg(feature = $solver_feature)]
@@ -83,6 +85,7 @@ macro_rules! dual_test {
         }
 
         #[test]
+        #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
         fn furniture_problem() {
             $(
                 #[cfg(feature = $solver_feature)]

tests/solver_scaling.rs

@@ -1,6 +1,7 @@
 use float_eq::assert_float_eq;
 use good_lp::{constraint, default_solver, variable, variables, Expression, Solution, SolverModel};
-
+#[cfg(target_arch = "wasm32")]
+use wasm_bindgen_test::*;
 const BIG_NUM: usize = 1000; // <- Set this higher to test how good_lp and the solvers scale
 
 #[test]
@@ -21,6 +22,7 @@ fn solve_large_problem() {
 }
 
 #[test]
+#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
 fn add_10_000_constraints() {
     let mut vars = variables!();
     let v = vars.add_vector(variable(), 10_000);
@@ -31,6 +33,7 @@ fn add_10_000_constraints() {
 }
 
 #[test]
+#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
 fn sum_binaries() {
     // See: https://github.com/rust-or/good_lp/issues/8
     let mut vars = variables!();

tests/static_solver.rs

@@ -1,5 +1,6 @@
 use good_lp::{constraint, variables, Solution, SolverModel, StaticSolver};
-
+#[cfg(target_arch = "wasm32")]
+use wasm_bindgen_test::*;
 // See: https://github.com/rust-or/good_lp/pull/5
 
 fn generic_solve_example<S: StaticSolver>(solver: S) -> Result<(), Box<dyn std::error::Error>> {
@@ -19,6 +20,7 @@ fn generic_solve_example<S: StaticSolver>(solver: S) -> Result<(), Box<dyn std::
 }
 
 #[test]
+#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
 fn concrete() {
     generic_solve_example(good_lp::default_solver).expect("solve")
 }

tests/variables.rs

@@ -1,6 +1,9 @@
 use good_lp::{variables, Expression};
+#[cfg(target_arch = "wasm32")]
+use wasm_bindgen_test::*;
 
 #[test]
+#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
 fn complex_expression() {
     let mut var1 = variables!();
     let a = var1.add_variable();
@@ -14,6 +17,7 @@ fn complex_expression() {
 }
 
 #[test]
+#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
 fn large_sum() {
     let mut var1 = variables!();
     let var_vec: Vec<_> = (0..100_000).map(|_i| var1.add_variable()).collect();
@@ -23,6 +27,7 @@ fn large_sum() {
 }
 
 #[test]
+#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
 fn complete() {
     let mut var1 = variables!();
     let mut var2 = variables!();
@@ -38,6 +43,7 @@ fn complete() {
 }
 
 #[test]
+#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
 fn debug_format() {
     let mut vars = variables!();
     let a = vars.add_variable();