refactor(distribution): move inverse_cdf panic checks to try_inverse_cdf

src/distribution/beta.rs

@@ -1,4 +1,4 @@
-use crate::distribution::{Continuous, ContinuousCDF, InverseCdfError};
+use crate::distribution::{Continuous, ContinuousCDF};
 use crate::function::{beta, gamma};
 use crate::statistics::*;
 #[cfg(not(feature = "std"))]
@@ -181,10 +181,6 @@ impl ContinuousCDF<f64, f64> for Beta {
     /// Calculates the inverse cumulative distribution function for the beta
     /// distribution at `x`.
     ///
-    /// # Panics
-    ///
-    /// If x is not in `[0, 1]`.
-    ///
     /// # Formula
     ///
     /// ```text
@@ -194,34 +190,7 @@ impl ContinuousCDF<f64, f64> for Beta {
     /// where `α` is shapeA, `β` is shapeB, and `I_x` is the inverse of the
     /// regularized lower incomplete beta function.
     fn inverse_cdf(&self, x: f64) -> f64 {
-        if !(0.0..=1.0).contains(&x) {
-            panic!("x must be in [0, 1]");
-        } else {
-            beta::inv_beta_reg(self.shape_a, self.shape_b, x)
-        }
-    }
-
-    /// Calculates the inverse cumulative distribution function for the beta
-    /// distribution at `x`.
-    ///
-    /// # Returns an error instead of a panic
-    ///
-    /// If x is not in `[0, 1]`.
-    ///
-    /// # Formula
-    ///
-    /// ```text
-    /// I^{-1}_x(α, β)
-    /// ```
-    ///
-    /// where `α` is shapeA, `β` is shapeB, and `I_x` is the inverse of the
-    /// regularized lower incomplete beta function.
-    fn try_inverse_cdf(&self, x: f64) -> Result<f64, InverseCdfError> {
-        if !(0.0..=1.0).contains(&x) {
-            Err(InverseCdfError::ArgumentOutOfRange)
-        } else {
-            Ok(beta::inv_beta_reg(self.shape_a, self.shape_b, x))
-        }
+        beta::inv_beta_reg(self.shape_a, self.shape_b, x)
     }
 }
 

src/distribution/categorical.rs

@@ -1,4 +1,4 @@
-use crate::distribution::{Discrete, DiscreteCDF};
+use crate::distribution::{Discrete, DiscreteCDF, DiscreteInverseCdfError};
 use crate::statistics::*;
 use alloc::vec::Vec;
 #[cfg(not(feature = "std"))]
@@ -181,10 +181,6 @@ impl DiscreteCDF<u64, f64> for Categorical {
     /// categorical
     /// distribution at `x`
     ///
-    /// # Panics
-    ///
-    /// If `x <= 0.0` or `x >= 1.0`
-    ///
     /// # Formula
     ///
     /// ```text
@@ -195,12 +191,23 @@ impl DiscreteCDF<u64, f64> for Categorical {
     /// and `f(x)` is defined as `p_x + f(x - 1)` and `f(0) = p_0` where
     /// `p_x` is the `x`th probability mass
     fn inverse_cdf(&self, x: f64) -> u64 {
-        if x >= 1.0 || x <= 0.0 {
-            panic!("x must be in [0, 1]")
-        }
-
         self.locate(x)
     }
+
+    /// Calculates the inverse cumulative distribution function for the
+    /// categorical distribution at `x`, returning an error instead of
+    /// panicking if `x` is not in the open interval `(0.0, 1.0)`, including
+    /// when `x` is NaN.
+    fn try_inverse_cdf(&self, x: f64) -> Result<u64, DiscreteInverseCdfError<f64>> {
+        // Written as a conjunction of `>`/`<`, not `x >= 1.0 || x <= 0.0`, so
+        // that NaN (which compares false against everything) is rejected
+        // rather than falling through to `locate`, which panics on NaN.
+        if x > 0.0 && x < 1.0 {
+            Ok(self.inverse_cdf(x))
+        } else {
+            Err(DiscreteInverseCdfError::ArgumentOutOfRange)
+        }
+    }
 }
 
 impl Min<u64> for Categorical {
@@ -517,17 +524,30 @@ mod tests {
     }
 
     #[test]
-    #[should_panic]
-    fn test_inverse_cdf_input_low() {
+    fn test_try_inverse_cdf_input_low() {
+        let dist = create_ok(&[4.0, 2.5, 2.5, 1.0]);
+        assert_eq!(
+            dist.try_inverse_cdf(0.0),
+            Err(DiscreteInverseCdfError::ArgumentOutOfRange)
+        );
+    }
+
+    #[test]
+    fn test_try_inverse_cdf_input_high() {
         let dist = create_ok(&[4.0, 2.5, 2.5, 1.0]);
-        dist.inverse_cdf(0.0);
+        assert_eq!(
+            dist.try_inverse_cdf(1.0),
+            Err(DiscreteInverseCdfError::ArgumentOutOfRange)
+        );
     }
 
     #[test]
-    #[should_panic]
-    fn test_inverse_cdf_input_high() {
+    fn test_try_inverse_cdf_nan_does_not_panic() {
         let dist = create_ok(&[4.0, 2.5, 2.5, 1.0]);
-        dist.inverse_cdf(1.0);
+        assert_eq!(
+            dist.try_inverse_cdf(f64::NAN),
+            Err(DiscreteInverseCdfError::ArgumentOutOfRange)
+        );
     }
 
     #[test]

src/distribution/cauchy.rs

@@ -163,11 +163,7 @@ impl ContinuousCDF<f64, f64> for Cauchy {
     ///
     /// where `x_0` is the location and `γ` is the scale
     fn inverse_cdf(&self, x: f64) -> f64 {
-        if !(0.0..=1.0).contains(&x) {
-            panic!("x must be in [0, 1]");
-        } else {
-            self.location + self.scale * (f64_consts::PI * (x - 0.5)).tan()
-        }
+        self.location + self.scale * (f64_consts::PI * (x - 0.5)).tan()
     }
 }
 

src/distribution/chi.rs

@@ -151,14 +151,7 @@ impl ContinuousCDF<f64, f64> for Chi {
 
     /// Calculates the inverse cumulative distribution function for the chi
     /// distribution at `p`, i.e. the `p`-quantile.
-    ///
-    /// # Panics
-    ///
-    /// If `p` is not in `[0, 1]`.
     fn inverse_cdf(&self, p: f64) -> f64 {
-        if !(0.0..=1.0).contains(&p) {
-            panic!("p must be in [0, 1]")
-        }
         if p == 0.0 {
             return self.min();
         }
@@ -367,6 +360,7 @@ impl Continuous<f64, f64> for Chi {
 mod tests {
     use super::*;
     use crate::distribution::internal::density_util;
+    use crate::distribution::InverseCdfError;
     crate::distribution::internal::testing_boiler!(freedom: u64; Chi; ChiError);
 
     #[test]
@@ -588,14 +582,18 @@ mod tests {
     }
 
     #[test]
-    #[should_panic(expected = "p must be in [0, 1]")]
-    fn test_inverse_cdf_p_above_one() {
-        create_ok(3).inverse_cdf(1.0 + f64::EPSILON);
+    fn test_try_inverse_cdf_p_above_one() {
+        assert_eq!(
+            create_ok(3).try_inverse_cdf(1.0 + f64::EPSILON),
+            Err(InverseCdfError::ArgumentOutOfRange)
+        );
     }
 
     #[test]
-    #[should_panic(expected = "p must be in [0, 1]")]
-    fn test_inverse_cdf_p_below_zero() {
-        create_ok(3).inverse_cdf(-1e-300);
+    fn test_try_inverse_cdf_p_below_zero() {
+        assert_eq!(
+            create_ok(3).try_inverse_cdf(-1e-300),
+            Err(InverseCdfError::ArgumentOutOfRange)
+        );
     }
 }

src/distribution/chi_squared.rs

@@ -1,4 +1,4 @@
-use crate::distribution::{Continuous, ContinuousCDF, Gamma, GammaError};
+use crate::distribution::{Continuous, ContinuousCDF, Gamma, GammaError, InverseCdfError};
 use crate::statistics::*;
 
 /// Implements the
@@ -152,6 +152,10 @@ impl ContinuousCDF<f64, f64> for ChiSquared {
     fn inverse_cdf(&self, p: f64) -> f64 {
         self.g.inverse_cdf(p)
     }
+
+    fn try_inverse_cdf(&self, p: f64) -> Result<f64, InverseCdfError> {
+        self.g.try_inverse_cdf(p)
+    }
 }
 
 impl Min<f64> for ChiSquared {

src/distribution/erlang.rs

@@ -1,4 +1,4 @@
-use crate::distribution::{Continuous, ContinuousCDF, Gamma, GammaError};
+use crate::distribution::{Continuous, ContinuousCDF, Gamma, GammaError, InverseCdfError};
 use crate::statistics::*;
 
 /// Implements the [Erlang](https://en.wikipedia.org/wiki/Erlang_distribution)
@@ -137,6 +137,10 @@ impl ContinuousCDF<f64, f64> for Erlang {
     fn inverse_cdf(&self, p: f64) -> f64 {
         self.g.inverse_cdf(p)
     }
+
+    fn try_inverse_cdf(&self, p: f64) -> Result<f64, InverseCdfError> {
+        self.g.try_inverse_cdf(p)
+    }
 }
 
 impl Min<f64> for Erlang {

src/distribution/fisher_snedecor.rs

@@ -201,12 +201,8 @@ impl ContinuousCDF<f64, f64> for FisherSnedecor {
     /// the second degree of freedom, and `I` is the regularized incomplete
     /// beta function
     fn inverse_cdf(&self, x: f64) -> f64 {
-        if !(0.0..=1.0).contains(&x) {
-            panic!("x must be in [0, 1]");
-        } else {
-            let z = beta::inv_beta_reg(self.freedom_1 / 2.0, self.freedom_2 / 2.0, x);
-            self.freedom_2 / (self.freedom_1 * (1.0 / z - 1.0))
-        }
+        let z = beta::inv_beta_reg(self.freedom_1 / 2.0, self.freedom_2 / 2.0, x);
+        self.freedom_2 / (self.freedom_1 * (1.0 / z - 1.0))
     }
 }
 

src/distribution/gamma.rs

@@ -185,9 +185,6 @@ impl ContinuousCDF<f64, f64> for Gamma {
     }
 
     fn inverse_cdf(&self, p: f64) -> f64 {
-        if !(0.0..=1.0).contains(&p) {
-            panic!("default inverse_cdf implementation should be provided probability on [0,1]")
-        }
         if p == 0.0 {
             return self.min();
         };