chore: Increased coverage and disabled coverage for error strings

Author: schmidmt

src/data/partition.rs

@@ -77,6 +77,7 @@ pub enum PartitionError {
 
 impl std::error::Error for PartitionError {}
 
+#[cfg_attr(coverage_nightly, coverage(off))]
 impl fmt::Display for PartitionError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {

src/dist/bernoulli.rs

@@ -369,6 +369,7 @@ impl Variance<f64> for Bernoulli {
 
 impl std::error::Error for BernoulliError {}
 
+#[cfg_attr(coverage_nightly, coverage(off))]
 impl fmt::Display for BernoulliError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {

src/dist/beta.rs

@@ -450,6 +450,7 @@ impl_traits!(f64);
 
 impl std::error::Error for BetaError {}
 
+#[cfg_attr(coverage_nightly, coverage(off))]
 impl fmt::Display for BetaError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {

src/dist/beta_binom.rs

@@ -427,6 +427,7 @@ impl_int_traits!(i64);
 
 impl std::error::Error for BetaBinomialError {}
 
+#[cfg_attr(coverage_nightly, coverage(off))]
 impl fmt::Display for BetaBinomialError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {

src/dist/betaprime.rs

@@ -250,6 +250,7 @@ impl Default for BetaPrime {
     }
 }
 
+#[cfg_attr(coverage_nightly, coverage(off))]
 impl From<&BetaPrime> for String {
     fn from(bp: &BetaPrime) -> String {
         format!("BetaPrime(α: {}, β: {})", bp.alpha, bp.beta)
@@ -358,6 +359,7 @@ impl Variance<f64> for BetaPrime {
 
 impl std::error::Error for BetaPrimeError {}
 
+#[cfg_attr(coverage_nightly, coverage(off))]
 impl fmt::Display for BetaPrimeError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
@@ -448,11 +450,14 @@ mod tests {
     use rand_xoshiro::Xoshiro256Plus;
 
     use super::*;
-    use crate::test_basic_impls;
+    use crate::{
+        misc::{KsAlternative, KsMode, ks_two_sample},
+        test_basic_impls,
+    };
 
     const TOL: f64 = 1E-12;
 
-    test_basic_impls!(f64, BetaPrime, BetaPrime::new(1.0, 1.0).unwrap());
+    test_basic_impls!(f64, BetaPrime, BetaPrime::default());
 
     #[test]
     fn new() {
@@ -564,6 +569,29 @@ mod tests {
         }
     }
 
+    #[test]
+    fn draw_and_sample_are_consistent() {
+        let mut rng = rand::rng();
+        let bp = BetaPrime::new(2.0, 3.0).unwrap();
+
+        let draw_sample: Vec<f64> =
+            (0..1000).map(|_| bp.draw(&mut rng)).collect();
+        let sample_sample: Vec<f64> = bp.sample(1000, &mut rng);
+
+        let (stat, p) = ks_two_sample(
+            &draw_sample,
+            &sample_sample,
+            KsMode::Auto,
+            KsAlternative::TwoSided,
+        )
+        .unwrap();
+
+        dbg!(&p);
+        dbg!(stat);
+
+        assert!(p > 0.05);
+    }
+
     #[cfg(feature = "experimental")]
     #[test]
     fn test_ln_m_cache_consistency() {

src/dist/categorical.rs

@@ -301,6 +301,7 @@ impl KlDivergence for Categorical {
     }
 }
 
+#[cfg_attr(coverage_nightly, coverage(off))]
 impl fmt::Display for CategoricalError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {

src/dist/cauchy.rs

@@ -287,6 +287,7 @@ impl_traits!(f32);
 
 impl std::error::Error for CauchyError {}
 
+#[cfg_attr(coverage_nightly, coverage(off))]
 impl fmt::Display for CauchyError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {

src/dist/cdvm.rs

@@ -35,7 +35,10 @@ use std::fmt;
 //     }
 // }
 
-/// [CDVM distribution](https://arxiv.org/pdf/2009.05437),
+/// Conditionalized Discrete von Mises (CDVM)
+///
+/// This is defined under "Definition 4" in
+/// [Families of discrete circular distributions with some novel applications](https://arxiv.org/pdf/2009.05437),
 /// A unimodal distribution over x in (0, m-1) where m is the number of categories.
 ///
 /// Note that in while the paper uses μ ∈ [0, 2π), we use μ ∈ [0, m)
@@ -90,6 +93,20 @@ impl Cdvm {
     /// * `mu` - mean direction (must be in [0, modulus))
     /// * `k` - concentration (must be non-negative)
     /// * `modulus` - Number of categories
+    ///
+    /// # Example
+    /// ```rust
+    /// use rv::prelude::*;
+    /// use rv::dist::{Cdvm, CdvmError};
+    ///
+    /// assert!(matches!(Cdvm::new(5, f64::INFINITY, 0.0), Err(CdvmError::MuNotFinite { .. })));
+    /// assert!(matches!(Cdvm::new(5, 0.0, f64::INFINITY), Err(CdvmError::KNotFinite { .. })));
+    /// assert!(matches!(Cdvm::new(5, 0.0, -1.0), Err(CdvmError::KNegative { .. })));
+    /// assert!(matches!(Cdvm::new(2, 1.0, 1.0), Err(CdvmError::InvalidCategories { .. })));
+    ///
+    /// let cdvm = Cdvm::new(3, 1.0, 1.0).expect("valid parameters");
+    ///
+    /// ```
     pub fn new(modulus: usize, mu: f64, k: f64) -> Result<Self, CdvmError> {
         // Validate parameters
         if !mu.is_finite() {
@@ -110,14 +127,14 @@ impl Cdvm {
 
     // Test that dependent fields are properly set
     // This is just for testing purposes
-    #[must_use]
-    pub fn is_consistent(&self) -> bool {
+    #[cfg(test)]
+    fn is_consistent(&self) -> bool {
         let other = Cdvm::new(self.modulus, self.mu, self.k).unwrap();
-        self.mu == other.mu
-            && self.k == other.k
-            && self.modulus == other.modulus
-            && self.log_norm_const == other.log_norm_const
-            && self.twopi_over_m == other.twopi_over_m
+        self.mu() == other.mu()
+            && self.k() == other.k()
+            && self.modulus() == other.modulus()
+            && self.log_norm_const() == other.log_norm_const()
+            && self.twopi_over_m() == other.twopi_over_m()
     }
 
     /// Creates a new CDVM without checking whether the parameters are valid.
@@ -258,6 +275,7 @@ impl_display!(Cdvm);
 
 impl std::error::Error for CdvmError {}
 
+#[cfg_attr(coverage_nightly, coverage(off))]
 impl fmt::Display for CdvmError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
@@ -322,8 +340,11 @@ impl HasSuffStat<usize> for Cdvm {
 
 #[cfg(test)]
 mod tests {
+    use crate::misc::x2_test;
+
     use super::*;
     use proptest::prelude::*;
+    use rand::{SeedableRng, rngs::SmallRng};
 
     const TOL: f64 = 1E-12;
 
@@ -486,4 +507,29 @@ mod tests {
                 "CDVM not consistent after set_mu: m={}, mu1={}, mu2={}, k={}", m, mu1, mu2, k);
         }
     }
+
+    #[test]
+    fn f_is_probability_measure() {
+        let dist = Cdvm::new_unchecked(10, 5.0, 0.5);
+
+        assert::close((0..10).map(|i| dist.f(&i)).sum::<f64>(), 1.0, 1e-10);
+    }
+
+    #[test]
+    fn ln_f_agrees_with_draw() {
+        let mut rng = SmallRng::from_os_rng();
+        let dist = Cdvm::new_unchecked(10, 5.0, 0.5);
+
+        let sample = dist.sample(100_000, &mut rng);
+        let ps: Vec<f64> = (0..10).map(|i| dist.f(&i)).collect();
+
+        let observed_counts =
+            sample.into_iter().fold(vec![0; 10], |mut acc, x| {
+                acc[x] += 1;
+                acc
+            });
+
+        let (_, p) = x2_test(&observed_counts, &ps);
+        assert!(p > 0.05);
+    }
 }

src/dist/chi_squared.rs

@@ -229,6 +229,7 @@ impl_traits!(f32);
 
 impl std::error::Error for ChiSquaredError {}
 
+#[cfg_attr(coverage_nightly, coverage(off))]
 impl fmt::Display for ChiSquaredError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {

src/dist/crp.rs

@@ -274,6 +274,7 @@ impl Support<Partition> for Crp {
 
 impl std::error::Error for CrpError {}
 
+#[cfg_attr(coverage_nightly, coverage(off))]
 impl fmt::Display for CrpError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {