Add #![no_std] support

.github/workflows/test.yml

@@ -59,6 +59,9 @@ jobs:
       - name: Install Rust stable
         uses: dtolnay/rust-toolchain@stable
 
+      - name: Test no_std
+        run: cargo test --no-default-features -F rand
+
       - name: Test default features
         run: cargo test
 

Cargo.toml

@@ -22,11 +22,13 @@ path = "src/lib.rs"
 [[bench]]
 name = "order_statistics"
 harness = false
-required-features = ["rand"]
+required-features = ["rand", "std"]
 
 [features]
-default = ["nalgebra", "rand"]
-nalgebra = ["dep:nalgebra"]
+default = ["std", "nalgebra", "rand"]
+std = ["nalgebra?/std", "rand?/std"]
+# at the moment, all nalgebra features needs std
+nalgebra = ["dep:nalgebra", "std"]
 rand = ["dep:rand", "nalgebra?/rand"]
 
 [dependencies]
@@ -36,12 +38,12 @@ num-traits = "0.2.14"
 [dependencies.rand]
 version = "0.8"
 optional = true
+default-features = false
 
 [dependencies.nalgebra]
 version = "0.33"
 optional = true
 default-features = false
-features = ["std"]
 
 [dev-dependencies]
 criterion = "0.5"

src/distribution/bernoulli.rs

@@ -78,8 +78,8 @@
     }
 }
 
-impl std::fmt::Display for Bernoulli {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+impl core::fmt::Display for Bernoulli {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         write!(f, "Bernoulli({})", self.p())
     }
 }

src/distribution/beta.rs

@@ -33,16 +33,17 @@
     ShapeBInvalid,
 }
 
-impl std::fmt::Display for BetaError {
+impl core::fmt::Display for BetaError {
     #[cfg_attr(coverage_nightly, coverage(off))]
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
         match self {
             BetaError::ShapeAInvalid => write!(f, "Shape A is NaN, infinite, zero or negative"),
             BetaError::ShapeBInvalid => write!(f, "Shape B is NaN, infinite, zero or negative"),
         }
     }
 }
 
+#[cfg(feature = "std")]
 impl std::error::Error for BetaError {}
 
 impl Beta {
@@ -106,8 +107,8 @@
     }
 }
 
-impl std::fmt::Display for Beta {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+impl core::fmt::Display for Beta {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         write!(f, "Beta(a={}, b={})", self.shape_a, self.shape_b)
     }
 }

src/distribution/binomial.rs

@@ -1,7 +1,7 @@
 use crate::distribution::{Discrete, DiscreteCDF};
 use crate::function::{beta, factorial};
 use crate::statistics::*;
-use std::f64;
+use core::f64;
 
 /// Implements the
 /// [Binomial](https://en.wikipedia.org/wiki/Binomial_distribution)
@@ -32,15 +32,16 @@
     ProbabilityInvalid,
 }
 
-impl std::fmt::Display for BinomialError {
+impl core::fmt::Display for BinomialError {
     #[cfg_attr(coverage_nightly, coverage(off))]
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
         match self {
             BinomialError::ProbabilityInvalid => write!(f, "Probability is NaN or not in [0, 1]"),
         }
     }
 }
 
+#[cfg(feature = "std")]
 impl std::error::Error for BinomialError {}
 
 impl Binomial {
@@ -103,8 +104,8 @@
     }
 }
 
-impl std::fmt::Display for Binomial {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+impl core::fmt::Display for Binomial {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         write!(f, "Bin({},{})", self.p, self.n)
     }
 }

src/distribution/categorical.rs

@@ -1,6 +1,6 @@
 use crate::distribution::{Discrete, DiscreteCDF};
 use crate::statistics::*;
-use std::f64;
+use core::f64;
 
 /// Implements the
 /// [Categorical](https://en.wikipedia.org/wiki/Categorical_distribution)
@@ -39,9 +39,9 @@
     ProbMassHasInvalidElements,
 }
 
-impl std::fmt::Display for CategoricalError {
+impl core::fmt::Display for CategoricalError {
     #[cfg_attr(coverage_nightly, coverage(off))]
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
         match self {
             CategoricalError::ProbMassEmpty => write!(f, "Probability mass is empty"),
             CategoricalError::ProbMassSumZero => write!(f, "Probabilities sum up to zero"),
@@ -53,6 +53,7 @@
     }
 }
 
+#[cfg(feature = "std")]
 impl std::error::Error for CategoricalError {}
 
 impl Categorical {
@@ -117,8 +118,8 @@
     }
 }
 
-impl std::fmt::Display for Categorical {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+impl core::fmt::Display for Categorical {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         write!(f, "Cat({:#?})", self.norm_pmf)
     }
 }
@@ -371,7 +372,7 @@
 // return 0. Otherwise val returns the index of the first element larger than
 // it within the search array.
 fn binary_index(search: &[f64], val: f64) -> usize {
-    use std::cmp;
+    use core::cmp;
 
     let mut low = 0_isize;
     let mut high = search.len() as isize - 1;

src/distribution/cauchy.rs

@@ -1,6 +1,6 @@
 use crate::distribution::{Continuous, ContinuousCDF};
 use crate::statistics::*;
-use std::f64;
+use core::f64;
 
 /// Implements the [Cauchy](https://en.wikipedia.org/wiki/Cauchy_distribution)
 /// distribution, also known as the Lorentz distribution.
@@ -32,16 +32,17 @@
     ScaleInvalid,
 }
 
-impl std::fmt::Display for CauchyError {
+impl core::fmt::Display for CauchyError {
     #[cfg_attr(coverage_nightly, coverage(off))]
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
         match self {
             CauchyError::LocationInvalid => write!(f, "Location is NaN"),
             CauchyError::ScaleInvalid => write!(f, "Scale is NaN, zero or less than zero"),
         }
     }
 }
 
+#[cfg(feature = "std")]
 impl std::error::Error for CauchyError {}
 
 impl Cauchy {
@@ -104,8 +105,8 @@
     }
 }
 
-impl std::fmt::Display for Cauchy {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+impl core::fmt::Display for Cauchy {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         write!(f, "Cauchy({}, {})", self.location, self.scale)
     }
 }

src/distribution/chi.rs

@@ -1,8 +1,8 @@
 use crate::distribution::{Continuous, ContinuousCDF};
 use crate::function::gamma;
 use crate::statistics::*;
-use std::f64;
-use std::num::NonZeroU64;
+use core::f64;
+use core::num::NonZeroU64;
 
 /// Implements the [Chi](https://en.wikipedia.org/wiki/Chi_distribution)
 /// distribution
@@ -31,9 +31,9 @@
     FreedomInvalid,
 }
 
-impl std::fmt::Display for ChiError {
+impl core::fmt::Display for ChiError {
     #[cfg_attr(coverage_nightly, coverage(off))]
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
         match self {
             ChiError::FreedomInvalid => {
                 write!(f, "Degrees of freedom are zero")
@@ -42,6 +42,7 @@
     }
 }
 
+#[cfg(feature = "std")]
 impl std::error::Error for ChiError {}
 
 impl Chi {
@@ -86,8 +87,8 @@
     }
 }
 
-impl std::fmt::Display for Chi {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+impl core::fmt::Display for Chi {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         write!(f, "χ_{}", self.freedom)
     }
 }

src/distribution/chi_squared.rs

@@ -1,6 +1,6 @@
 use crate::distribution::{Continuous, ContinuousCDF, Gamma, GammaError};
 use crate::statistics::*;
-use std::f64;
+use core::f64;
 
 /// Implements the
 /// [Chi-squared](https://en.wikipedia.org/wiki/Chi-squared_distribution)
@@ -94,8 +94,8 @@
     }
 }
 
-impl std::fmt::Display for ChiSquared {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+impl core::fmt::Display for ChiSquared {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         write!(f, "χ^2_{}", self.freedom)
     }
 }

src/distribution/dirac.rs

@@ -24,15 +24,16 @@
     ValueInvalid,
 }
 
-impl std::fmt::Display for DiracError {
+impl core::fmt::Display for DiracError {
     #[cfg_attr(coverage_nightly, coverage(off))]
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
         match self {
             DiracError::ValueInvalid => write!(f, "Value v is NaN"),
         }
     }
 }
 
+#[cfg(feature = "std")]
 impl std::error::Error for DiracError {}
 
 impl Dirac {
@@ -62,8 +63,8 @@
     }
 }
 
-impl std::fmt::Display for Dirac {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+impl core::fmt::Display for Dirac {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         write!(f, "δ_{}", self.0)
     }
 }

src/distribution/dirichlet.rs

@@ -2,8 +2,8 @@
 use crate::function::gamma;
 use crate::prec;
 use crate::statistics::*;
+use core::f64;
 use nalgebra::{Dim, Dyn, OMatrix, OVector};
-use std::f64;
 
 /// Implements the
 /// [Dirichlet](https://en.wikipedia.org/wiki/Dirichlet_distribution)
@@ -41,9 +41,9 @@
     AlphaHasInvalidElements,
 }
 
-impl std::fmt::Display for DirichletError {
+impl core::fmt::Display for DirichletError {
     #[cfg_attr(coverage_nightly, coverage(off))]
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
         match self {
             DirichletError::AlphaTooShort => write!(f, "Alpha contains less than two elements"),
             DirichletError::AlphaHasInvalidElements => write!(
@@ -54,6 +54,7 @@
     }
 }
 
+#[cfg(feature = "std")]
 impl std::error::Error for DirichletError {}
 
 impl Dirichlet<Dyn> {
@@ -181,12 +182,12 @@
     }
 }
 
-impl<D> std::fmt::Display for Dirichlet<D>
+impl<D> core::fmt::Display for Dirichlet<D>
 where
     D: Dim,
     nalgebra::DefaultAllocator: nalgebra::allocator::Allocator<D>,
 {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         write!(f, "Dir({}, {})", self.alpha.len(), &self.alpha)
     }
 }

src/distribution/discrete_uniform.rs

@@ -29,15 +29,16 @@
     MinMaxInvalid,
 }
 
-impl std::fmt::Display for DiscreteUniformError {
+impl core::fmt::Display for DiscreteUniformError {
     #[cfg_attr(coverage_nightly, coverage(off))]
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
         match self {
             DiscreteUniformError::MinMaxInvalid => write!(f, "Maximum is less than minimum"),
         }
     }
 }
 
+#[cfg(feature = "std")]
 impl std::error::Error for DiscreteUniformError {}
 
 impl DiscreteUniform {
@@ -68,8 +69,8 @@
     }
 }
 
-impl std::fmt::Display for DiscreteUniform {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+impl core::fmt::Display for DiscreteUniform {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         write!(f, "Uni([{}, {}])", self.min, self.max)
     }
 }

src/distribution/empirical.rs

@@ -179,12 +179,12 @@ impl Empirical {
     }
 }
 
-impl std::fmt::Display for Empirical {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+impl core::fmt::Display for Empirical {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         let mut enumerated_values = self
             .data
             .iter()
-            .flat_map(|(x, &count)| std::iter::repeat(x.get()).take(count as usize));
+            .flat_map(|(x, &count)| core::iter::repeat(x.get()).take(count as usize));
 
         if let Some(x) = enumerated_values.next() {
             write!(f, "Empirical([{x:.3e}")?;