Merge pull request #919 from kennytm/impl-error-for-distr-error

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

Author: dhardy

CHANGELOG.md

@@ -8,6 +8,10 @@ A [separate changelog is kept for rand_core](rand_core/CHANGELOG.md).
 
 You may also find the [Upgrade Guide](https://rust-random.github.io/book/update.html) useful.
 
+## Unreleased
+### Additions
+- Implement `std::error::Error` for `BernoulliError` (#919)
+
 ## [0.7.2] - 2019-09-16
 ### Fixes
 - Fix dependency on `rand_core` 0.5.1 (#890)

rand_distr/CHANGELOG.md

@@ -4,6 +4,10 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## Unreleased
+- All error types now implement `std::error::Error` (#919)
+- Re-exported `rand::distributions::BernoulliError` (#919)
+
 ## [0.2.2] - 2019-09-10
 - Fix version requirement on rand lib (#847)
 - Clippy fixes & suppression (#840)

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 => "requirement min < max is not met 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 => {
+                "requirement min <= max is not met 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>
 {