impl std::error::Error for rand_distr::*Error.

rand_distr/src/binomial.rs

@@ -11,6 +11,7 @@
 
 use rand::Rng;
 use crate::{Distribution, Uniform};
+use std::{error, fmt};
 
 /// The binomial distribution `Binomial(n, p)`.
 ///
@@ -43,6 +44,17 @@ pub enum Error {
     ProbabilityTooLarge,
 }
 
+impl fmt::Display for Error {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str(match self {
+            Error::ProbabilityTooSmall => "p < 0 or is NaN in binomial distribution",
+            Error::ProbabilityTooLarge => "p > 1 in binomial distribution",
+        })
+    }
+}
+
+impl error::Error for Error {}
+
 impl Binomial {
     /// Construct a new `Binomial` with the given shape parameters `n` (number
     /// of trials) and `p` (probability of success).

rand_distr/src/cauchy.rs

@@ -12,6 +12,7 @@
 use rand::Rng;
 use crate::{Distribution, Standard};
 use crate::utils::Float;
+use std::{error, fmt};
 
 /// The Cauchy distribution `Cauchy(median, scale)`.
 ///
@@ -43,6 +44,16 @@ pub enum Error {
     ScaleTooSmall,
 }
 
+impl fmt::Display for Error {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str(match self {
+            Error::ScaleTooSmall => "scale is not positive in Cauchy distribution",
+        })
+    }
+}
+
+impl error::Error for Error {}
+
 impl<N: Float> Cauchy<N>
 where Standard: Distribution<N>
 {

rand_distr/src/dirichlet.rs

@@ -12,8 +12,9 @@
 use rand::Rng;
 use crate::{Distribution, Gamma, StandardNormal, Exp1, Open01};
 use crate::utils::Float;
+use std::{error, fmt};
 
-/// The dirichelet distribution `Dirichlet(alpha)`.
+/// The Dirichlet distribution `Dirichlet(alpha)`.
 ///
 /// The Dirichlet distribution is a family of continuous multivariate
 /// probability distributions parameterized by a vector alpha of positive reals.
@@ -46,6 +47,19 @@ pub enum Error {
     SizeTooSmall,
 }
 
+impl fmt::Display for Error {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str(match self {
+            Error::AlphaTooShort | Error::SizeTooSmall => {
+                "less than 2 dimensions in Dirichlet distribution"
+            }
+            Error::AlphaTooSmall => "alpha is not positive in Dirichlet distribution",
+        })
+    }
+}
+
+impl error::Error for Error {}
+
 impl<N: Float> Dirichlet<N>
 where StandardNormal: Distribution<N>, Exp1: Distribution<N>, Open01: Distribution<N>
 {

rand_distr/src/exponential.rs

@@ -12,6 +12,7 @@
 use rand::Rng;
 use crate::{ziggurat_tables, Distribution};
 use crate::utils::{ziggurat, Float};
+use std::{error, fmt};
 
 /// Samples floating-point numbers according to the exponential distribution,
 /// with rate parameter `λ = 1`. This is equivalent to `Exp::new(1.0)` or
@@ -97,6 +98,16 @@ pub enum Error {
     LambdaTooSmall,
 }
 
+impl fmt::Display for Error {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str(match self {
+            Error::LambdaTooSmall => "lambda is not positive in exponential distribution",
+        })
+    }
+}
+
+impl error::Error for Error {}
+
 impl<N: Float> Exp<N>
 where Exp1: Distribution<N>
 {

rand_distr/src/gamma.rs

@@ -16,6 +16,7 @@ use rand::Rng;
 use crate::normal::StandardNormal;
 use crate::{Distribution, Exp1, Exp, Open01};
 use crate::utils::Float;
+use std::{error, fmt};
 
 /// The Gamma distribution `Gamma(shape, scale)` distribution.
 ///
@@ -63,6 +64,18 @@ pub enum Error {
     ScaleTooLarge,
 }
 
+impl fmt::Display for Error {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str(match self {
+            Error::ShapeTooSmall => "shape is not positive in gamma distribution",
+            Error::ScaleTooSmall => "scale is not positive in gamma distribution",
+            Error::ScaleTooLarge => "scale is infinity in gamma distribution",
+        })
+    }
+}
+
+impl error::Error for Error {}
+
 #[derive(Clone, Copy, Debug)]
 enum GammaRepr<N> {
     Large(GammaLargeShape<N>),
@@ -224,6 +237,18 @@ pub enum ChiSquaredError {
     DoFTooSmall,
 }
 
+impl fmt::Display for ChiSquaredError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str(match self {
+            ChiSquaredError::DoFTooSmall => {
+                "degrees-of-freedom k is not positive in chi-squared distribution"
+            }
+        })
+    }
+}
+
+impl error::Error for ChiSquaredError {}
+
 #[derive(Clone, Copy, Debug)]
 enum ChiSquaredRepr<N> {
     // k == 1, Gamma(alpha, ..) is particularly slow for alpha < 1,
@@ -298,6 +323,17 @@ pub enum FisherFError {
     NTooSmall,
 }
 
+impl fmt::Display for FisherFError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str(match self {
+            FisherFError::MTooSmall => "m is not positive in Fisher F distribution",
+            FisherFError::NTooSmall => "n is not positive in Fisher F distribution",
+        })
+    }
+}
+
+impl error::Error for FisherFError {}
+
 impl<N: Float> FisherF<N>
 where StandardNormal: Distribution<N>, Exp1: Distribution<N>, Open01: Distribution<N>
 {
@@ -390,6 +426,17 @@ pub enum BetaError {
     BetaTooSmall,
 }
 
+impl fmt::Display for BetaError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str(match self {
+            BetaError::AlphaTooSmall => "alpha is not positive in beta distribution",
+            BetaError::BetaTooSmall => "beta is not positive in beta distribution",
+        })
+    }
+}
+
+impl error::Error for BetaError {}
+
 impl<N: Float> Beta<N>
 where StandardNormal: Distribution<N>, Exp1: Distribution<N>, Open01: Distribution<N>
 {

rand_distr/src/lib.rs

@@ -64,7 +64,8 @@
 //!   - [`UnitDisc`] distribution
 
 pub use rand::distributions::{Distribution, DistIter, Standard,
-    Alphanumeric, Uniform, OpenClosed01, Open01, Bernoulli, uniform, weighted};
+    Alphanumeric, Uniform, OpenClosed01, Open01, Bernoulli, BernoulliError,
+    uniform, weighted};
 
 pub use self::unit_sphere::UnitSphere;
 pub use self::unit_ball::UnitBall;

rand_distr/src/normal.rs

@@ -12,6 +12,7 @@
 use rand::Rng;
 use crate::{ziggurat_tables, Distribution, Open01};
 use crate::utils::{ziggurat, Float};
+use std::{error, fmt};
 
 /// Samples floating-point numbers according to the normal distribution
 /// `N(0, 1)` (a.k.a. a standard normal, or Gaussian). This is equivalent to
@@ -114,6 +115,16 @@ pub enum Error {
     StdDevTooSmall,
 }
 
+impl fmt::Display for Error {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str(match self {
+            Error::StdDevTooSmall => "std_dev < 0 or is NaN in normal distribution",
+        })
+    }
+}
+
+impl error::Error for Error {}
+
 impl<N: Float> Normal<N>
 where StandardNormal: Distribution<N>
 {

rand_distr/src/pareto.rs

@@ -11,6 +11,7 @@
 use rand::Rng;
 use crate::{Distribution, OpenClosed01};
 use crate::utils::Float;
+use std::{error, fmt};
 
 /// Samples floating-point numbers according to the Pareto distribution
 ///
@@ -37,6 +38,17 @@ pub enum Error {
     ShapeTooSmall,
 }
 
+impl fmt::Display for Error {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str(match self {
+            Error::ScaleTooSmall => "scale is not positive in Pareto distribution",
+            Error::ShapeTooSmall => "shape is not positive in Pareto distribution",
+        })
+    }
+}
+
+impl error::Error for Error {}
+
 impl<N: Float> Pareto<N>
 where OpenClosed01: Distribution<N>
 {

rand_distr/src/pert.rs

@@ -10,6 +10,7 @@
 use rand::Rng;
 use crate::{Distribution, Beta, StandardNormal, Exp1, Open01};
 use crate::utils::Float;
+use std::{error, fmt};
 
 /// The PERT distribution.
 ///
@@ -47,6 +48,18 @@ pub enum PertError {
     ShapeTooSmall,
 }
 
+impl fmt::Display for PertError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str(match self {
+            PertError::RangeTooSmall => "min..=max is not proper range in PERT distribution",
+            PertError::ModeRange => "mode is outside min..=max in PERT distribution",
+            PertError::ShapeTooSmall => "shape < 0 or is NaN in PERT distribution",
+        })
+    }
+}
+
+impl error::Error for PertError {}
+
 impl<N: Float> Pert<N>
 where StandardNormal: Distribution<N>, Exp1: Distribution<N>, Open01: Distribution<N>
 {

rand_distr/src/poisson.rs

@@ -12,6 +12,7 @@
 use rand::Rng;
 use crate::{Distribution, Cauchy, Standard};
 use crate::utils::Float;
+use std::{error, fmt};
 
 /// The Poisson distribution `Poisson(lambda)`.
 ///
@@ -44,6 +45,16 @@ pub enum Error {
     ShapeTooSmall,
 }
 
+impl fmt::Display for Error {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str(match self {
+            Error::ShapeTooSmall => "lambda is not positive in Poisson distribution",
+        })
+    }
+}
+
+impl error::Error for Error {}
+
 impl<N: Float> Poisson<N>
 where Standard: Distribution<N>
 {

rand_distr/src/triangular.rs

@@ -10,6 +10,7 @@
 use rand::Rng;
 use crate::{Distribution, Standard};
 use crate::utils::Float;
+use std::{error, fmt};
 
 /// The triangular distribution.
 /// 
@@ -46,6 +47,19 @@ pub enum TriangularError {
     ModeRange,
 }
 
+impl fmt::Display for TriangularError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str(match self {
+            TriangularError::RangeTooSmall => {
+                "min..=max is not proper range in triangular distribution"
+            }
+            TriangularError::ModeRange => "mode is outside min..=max in triangular distribution",
+        })
+    }
+}
+
+impl error::Error for TriangularError {}
+
 impl<N: Float> Triangular<N>
 where Standard: Distribution<N>
 {

rand_distr/src/weibull.rs

@@ -11,6 +11,7 @@
 use rand::Rng;
 use crate::{Distribution, OpenClosed01};
 use crate::utils::Float;
+use std::{error, fmt};
 
 /// Samples floating-point numbers according to the Weibull distribution
 ///
@@ -37,6 +38,17 @@ pub enum Error {
     ShapeTooSmall,
 }
 
+impl fmt::Display for Error {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str(match self {
+            Error::ScaleTooSmall => "scale is not positive in Weibull distribution",
+            Error::ShapeTooSmall => "shape is not positive in Weibull distribution",
+        })
+    }
+}
+
+impl error::Error for Error {}
+
 impl<N: Float> Weibull<N>
 where OpenClosed01: Distribution<N>
 {

src/distributions/bernoulli.rs

@@ -10,6 +10,7 @@
 
 use crate::Rng;
 use crate::distributions::Distribution;
+use core::{fmt, u64};
 
 /// The Bernoulli distribution.
 ///
@@ -55,7 +56,7 @@ pub struct Bernoulli {
 // the RNG, and pay the performance price for all uses that *are* reasonable.
 // Luckily, if `new()` and `sample` are close, the compiler can optimize out the
 // extra check.
-const ALWAYS_TRUE: u64 = ::core::u64::MAX;
+const ALWAYS_TRUE: u64 = u64::MAX;
 
 // This is just `2.0.powi(64)`, but written this way because it is not available
 // in `no_std` mode.
@@ -68,6 +69,17 @@ pub enum BernoulliError {
     InvalidProbability,
 }
 
+impl fmt::Display for BernoulliError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str(match self {
+            BernoulliError::InvalidProbability => "p is outside 0..=1 in Bernoulli distribution",
+        })
+    }
+}
+
+#[cfg(feature = "std")]
+impl ::std::error::Error for BernoulliError {}
+
 impl Bernoulli {
     /// Construct a new `Bernoulli` with the given probability of success `p`.
     ///