Run formatter, clippy, expand workflow

Author: AzeezDa

.github/workflows/rust.yml

@@ -11,14 +11,45 @@ env:
 
 jobs:
   build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Build
+        run: cargo build --verbose
 
+  check-fmt:
     runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Check Formatting
+        run: cargo fmt -- --check
 
+  clippy:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Install clippy
+        run: rustup component add clippy
+      - name: Run clippy
+        run: cargo clippy
+
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Run tests
+        run: cargo test
+
+  examples:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Run tests
+        run: ./run_examples
+
+  docs:
+    runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v4
-    - name: Build
-      run: cargo build --verbose
-    - name: Run tests
-      run: cargo test --verbose
-    - name: Run examples
-      run: ./run_examples.sh
+      - uses: actions/checkout@v4
+      - name: Generate documentation
+        run: cargo doc

Cargo.toml

@@ -17,14 +17,14 @@ name = "eqsolver"
 path = "src/lib.rs"
 
 [dependencies]
-nalgebra = "0.33.0"
+nalgebra = "0.34.1"
 num-traits = "0.2.19"
-rand = "0.9.1"
+rand = "0.9.2"
 rand_distr = "0.5.1"
 thiserror = "2.0.17"
 
 [dev-dependencies]
-criterion = { version = "0.6.0", features = ["html_reports"] }
+criterion = { version = "0.8.1", features = ["html_reports"] }
 rand_chacha = "0.9.0"
 
 [[bench]]

benchmarks/integrators.rs

@@ -55,17 +55,11 @@ macro_rules! bench_with_all_methods {
         });
 
         $c.bench_function("Monte Carlo", |bh| {
-            bh.iter(|| {
-                MonteCarlo::new($f)
-                    .integrate(black_box($from), black_box($to))
-            });
+            bh.iter(|| MonteCarlo::new($f).integrate(black_box($from), black_box($to)));
         });
 
         $c.bench_function("MISER", |bh| {
-            bh.iter(|| {
-                MonteCarlo::new($f)
-                    .integrate(black_box($from), black_box($to))
-            });
+            bh.iter(|| MonteCarlo::new($f).integrate(black_box($from), black_box($to)));
         });
     };
 }

benchmarks/lib.rs

@@ -1,8 +1,13 @@
 use criterion::criterion_main;
 
+mod integrators;
 mod multi;
 mod ode;
 mod single;
-mod integrators;
 
-criterion_main!(single::benches, multi::benches, ode::benches, integrators::benches);
+criterion_main!(
+    single::benches,
+    multi::benches,
+    ode::benches,
+    integrators::benches
+);

benchmarks/multi.rs

@@ -1,8 +1,8 @@
 use criterion::{criterion_group, Criterion};
-use std::hint::black_box;
 use eqsolver::{global_optimisers::*, multivariable::*};
 use nalgebra::{vector, DMatrix, DVector, Matrix, SVector};
 use std::f64::consts::PI;
+use std::hint::black_box;
 
 criterion_group!(
     benches,

benchmarks/ode.rs

@@ -1,7 +1,7 @@
 use criterion::{criterion_group, Criterion};
-use std::hint::black_box;
 use eqsolver::{ODESolver, ODESolverMethod};
 use nalgebra::{vector, SVector, Vector2};
+use std::hint::black_box;
 
 criterion_group!(
     benches,

benchmarks/single.rs

@@ -1,7 +1,7 @@
 use criterion::{criterion_group, Criterion};
-use std::hint::black_box;
 use eqsolver::single_variable::*;
 use std::f64::consts::PI;
+use std::hint::black_box;
 
 criterion_group!(
     benches,

run_examples.sh

@@ -4,5 +4,6 @@ cd examples
 for file in *; do
     if [ -f "$file" ]; then
         cargo run --example "${file%.*}"
+        cargo run --release --example "${file%.*}"
     fi
 done

src/integrators/adaptive_newton_cotes.rs

@@ -5,7 +5,6 @@ use crate::integrators::DEFAULT_MAXIMUM_CUT_COUNT;
 use crate::DEFAULT_TOL;
 use crate::{SolverError, SolverResult};
 
-
 /// # Adaptive Newton-Cotes
 ///
 /// A numerical integrator of functions `f: R -> R` based on the adaptive Newton-Cotes
@@ -160,8 +159,8 @@ where
             let delta_i = (to_i - from_i) * half;
             let mid_i = from_i + delta_i;
 
-            let integral_full = formula(&self, from_i, to_i);
-            let integral_split = formula(&self, from_i, mid_i) + formula(&self, mid_i, to_i);
+            let integral_full = formula(self, from_i, to_i);
+            let integral_split = formula(self, from_i, mid_i) + formula(self, mid_i, to_i);
 
             let error = (integral_full - integral_split).abs();
 

src/integrators/miser.rs

@@ -24,18 +24,18 @@ const DEFAULT_DITHER: f64 = 0.05;
 
 /// # The MISER Algorithm
 ///
-/// The Monte Carlo integration algorithm MISER by Press and Farrar (See [1]) uses stratified
+/// The Monte Carlo integration algorithm MISER by Press and Farrar (See \[1\]) uses stratified
 /// sampling based on variance of the integrand's value on the sampled points. More specifically,
 /// the original subregion (which must be a Cartesian product of intervals `[a, b]` for real `a,
 /// b`) is bisected along some dimension such that the integrand's value in those two subregions
 /// gives the smallest total variance amongst all other bisections. The total samples points are
 /// then distributed to those subregions according to the variance. This procedure is continued
 /// recursively until either the recursion depth is reached or the number of sample points
 /// allocated to that subregion fall under an (adjustable) threshold. The procedure is implemented
-/// in [`miser_recurse`].
+/// in (private function) `miser_recurse`.
 ///
 /// There are several adjustable parameters in this implementation of [`MISER`]. The parameters are
-/// inspired by those used in [1]. The parameters in [`MISER`] are:
+/// inspired by those used in \[1\]. The parameters in [`MISER`] are:
 ///
 /// - **Sample Count**: (Default `1000`) A lower bound on the number of points to sample in total.
 ///   The reason this is a lower bound is because if the minimum threshold is fallen under then
@@ -84,7 +84,7 @@ const DEFAULT_DITHER: f64 = 0.05;
 /// ## References:
 /// (1) Press, W.H. and Farrar, G.R., 1990. Recursive stratified sampling for multidimensional
 ///     Monte Carlo integration. Computers in Physics, 4(2), pp.190-195.
-/// (2) https://www.gnu.org/software/gsl/doc/html/montecarlo.html
+/// (2) <https://www.gnu.org/software/gsl/doc/html/montecarlo.html>
 pub struct MISER<F, V, T> {
     f: F,
     sample_count: usize,
@@ -205,9 +205,10 @@ where
     ///
     /// The alpha value changes the proportions of the allocated samples points to each subregion
     /// of the bisection that happens in every recursion call of [`MISER`]. More precisely, the
-    /// allocated points for each subregions follow the following formulas.
+    /// allocated points for each subregions follow the following formulas:
     /// - `N_1 = N * (Var_1^beta / (Var_1^beta + Var_2^beta))`
     /// - `N_2 = N * (Var_2^beta / (Var_1^beta + Var_2^beta))`
+    ///
     /// where `N` is the total sample points, `Var_1` and `Var_2` are the variances of the
     /// integrand on the first and second subregions, respectively, and `beta = 1 / (1 + alpha)`.
     ///
@@ -280,7 +281,7 @@ where
         rng: &mut impl rand::Rng,
     ) -> SolverResult<MeanVariance<T>> {
         miser_recurse(
-            &self,
+            self,
             &mut from,
             &mut to,
             rng,