Adding guard loops back to binomial and poission

Author: MaximoB

src/distributions/binomial.rs

@@ -93,10 +93,17 @@ impl Distribution<u64> for Binomial {
         // f(x) ~ 1/(1+x^2)
         let cauchy = Cauchy::new(0.0, 1.0);
         loop {
-            // draw from the Cauchy distribution
-            let comp_dev = rng.sample(cauchy);
-            // shift the peak of the comparison distribution
-            lresult = expected + sq * comp_dev;
+            let mut comp_dev: f64;
+            loop {
+                // draw from the Cauchy distribution
+                comp_dev = rng.sample(cauchy);
+                // shift the peak of the comparison ditribution
+                lresult = expected + sq * comp_dev;
+                // repeat the drawing until we are in the range of possible values
+                if lresult >= 0.0 && lresult < float_n + 1.0 {
+                    break;
+                }
+            }
 
             // the result should be discrete
             lresult = lresult.floor();

src/distributions/cauchy.rs

@@ -50,7 +50,7 @@ impl Cauchy {
 impl Distribution<f64> for Cauchy {
     fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> f64 {
         // sample from [0, 1)
-        let mut x: f64 = rng.gen::<f64>();
+        let mut x = rng.gen::<f64>();
         // guard against the extremely unlikely case we get the invalid 0.5
         while x == 0.5 {
             x = rng.gen::<f64>();

src/distributions/poisson.rs

@@ -75,12 +75,21 @@ impl Distribution<u64> for Poisson {
             // we use the Cauchy distribution as the comparison distribution
             // f(x) ~ 1/(1+x^2)
             let cauchy = Cauchy::new(0.0, 1.0);
+
             loop {
-                // draw from the Cauchy distribution
-                let comp_dev = rng.sample(cauchy);
-                // shift the peak of the comparison ditribution
-                let mut result = self.sqrt_2lambda * comp_dev + self.lambda;
+                let mut result;
+                let mut comp_dev;
 
+                loop {
+                    // draw from the Cauchy distribution
+                    comp_dev = rng.sample(cauchy);
+                    // shift the peak of the comparison ditribution
+                    result = self.sqrt_2lambda * comp_dev + self.lambda;
+                    // repeat the drawing until we are in the range of possible values
+                    if result >= 0.0 {
+                        break;
+                    }
+                }
                 // now the result is a random variable greater than 0 with Cauchy distribution
                 // the result should be an integer value
                 result = result.floor();