QR, solveh

ndarray-linalg/Cargo.toml

@@ -62,6 +62,10 @@ harness = false
 name = "eigh"
 harness = false
 
+[[bench]]
+name = "qr"
+harness = false
+
 [[bench]]
 name = "svd"
 harness = false
@@ -70,5 +74,9 @@ harness = false
 name = "solve"
 harness = false
 
+[[bench]]
+name = "solveh"
+harness = false
+
 [package.metadata.docs.rs]
 rustdoc-args = ["--html-in-header", "katex-header.html"]

ndarray-linalg/benches/qr.rs

@@ -0,0 +1,24 @@
+use criterion::*;
+use ndarray::*;
+use ndarray_linalg::*;
+
+fn qr_small(c: &mut Criterion) {
+    let mut group = c.benchmark_group("qr");
+    for &n in &[4, 8, 16, 32, 64, 128] {
+        group.bench_with_input(BenchmarkId::new("C", n), &n, |b, n| {
+            let a: Array2<f64> = random((*n, *n));
+            b.iter(|| {
+                let _result = a.qr().unwrap();
+            })
+        });
+        group.bench_with_input(BenchmarkId::new("F", n), &n, |b, n| {
+            let a: Array2<f64> = random((*n, *n).f());
+            b.iter(|| {
+                let _result = a.qr().unwrap();
+            })
+        });
+    }
+}
+
+criterion_group!(qr, qr_small);
+criterion_main!(qr);

ndarray-linalg/benches/solve.rs

@@ -2,23 +2,35 @@ use criterion::*;
 use ndarray::*;
 use ndarray_linalg::*;
 
-fn factorize_small(c: &mut Criterion) {
-    let mut group = c.benchmark_group("factorize");
+fn solve_small(c: &mut Criterion) {
+    let mut group = c.benchmark_group("solve");
     for &n in &[4, 8, 16, 32, 64, 128] {
-        group.bench_with_input(BenchmarkId::new("C", n), &n, |b, n| {
+        group.bench_with_input(BenchmarkId::new("factorize/C", n), &n, |b, n| {
             let a: Array2<f64> = random((*n, *n));
             b.iter(|| {
                 let _lu = a.factorize().unwrap();
             })
         });
-        group.bench_with_input(BenchmarkId::new("F", n), &n, |b, n| {
+        group.bench_with_input(BenchmarkId::new("factorize/F", n), &n, |b, n| {
             let a: Array2<f64> = random((*n, *n).f());
             b.iter(|| {
                 let _lu = a.factorize().unwrap();
             })
         });
+        group.bench_with_input(BenchmarkId::new("inv/C", n), &n, |b, n| {
+            let a: Array2<f64> = random((*n, *n));
+            b.iter(|| {
+                let _inv = a.inv().unwrap();
+            })
+        });
+        group.bench_with_input(BenchmarkId::new("inv/F", n), &n, |b, n| {
+            let a: Array2<f64> = random((*n, *n).f());
+            b.iter(|| {
+                let _inv = a.inv().unwrap();
+            })
+        });
     }
 }
 
-criterion_group!(factorize, factorize_small);
-criterion_main!(factorize);
+criterion_group!(solve, solve_small);
+criterion_main!(solve);

ndarray-linalg/benches/solveh.rs

@@ -0,0 +1,36 @@
+use criterion::*;
+use ndarray::*;
+use ndarray_linalg::*;
+
+fn solveh_small(c: &mut Criterion) {
+    let mut group = c.benchmark_group("solveh");
+    for &n in &[4, 8, 16, 32, 64, 128] {
+        group.bench_with_input(BenchmarkId::new("factorizeh/C", n), &n, |b, n| {
+            let a: Array2<f64> = random((*n, *n));
+            b.iter(|| {
+                let _lu = a.factorizeh().unwrap();
+            })
+        });
+        group.bench_with_input(BenchmarkId::new("factorizeh/F", n), &n, |b, n| {
+            let a: Array2<f64> = random((*n, *n).f());
+            b.iter(|| {
+                let _lu = a.factorizeh().unwrap();
+            })
+        });
+        group.bench_with_input(BenchmarkId::new("invh/C", n), &n, |b, n| {
+            let a: Array2<f64> = random((*n, *n));
+            b.iter(|| {
+                let _inv = a.invh().unwrap();
+            })
+        });
+        group.bench_with_input(BenchmarkId::new("invh/F", n), &n, |b, n| {
+            let a: Array2<f64> = random((*n, *n).f());
+            b.iter(|| {
+                let _inv = a.invh().unwrap();
+            })
+        });
+    }
+}
+
+criterion_group!(solveh, solveh_small);
+criterion_main!(solveh);