New upstream version 1.38.0+dfsg1

[rustc.git] / vendor / rand / src / distributions / unit_sphere.rs

diff --git a/vendor/rand/src/distributions/unit_sphere.rs b/vendor/rand/src/distributions/unit_sphere.rs
index 61cbda5720e20fc9b7f9ad642e88845e9ce778d0..2a224cbe5ecf560ed42c5d86047fbcefd63a7220 100644 (file)
--- a/vendor/rand/src/distributions/unit_sphere.rs
+++ b/vendor/rand/src/distributions/unit_sphere.rs
@@ -6,45 +6,36 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use Rng;
-use distributions::{Distribution, Uniform};
+#![allow(deprecated)]
+
+use crate::Rng;
+use crate::distributions::{Distribution, Uniform};
 
 /// Samples uniformly from the surface of the unit sphere in three dimensions.
 ///
 /// Implemented via a method by Marsaglia[^1].
 ///
-///
-/// # Example
-///
-/// ```
-/// use rand::distributions::{UnitSphereSurface, Distribution};
-///
-/// let sphere = UnitSphereSurface::new();
-/// let v = sphere.sample(&mut rand::thread_rng());
-/// println!("{:?} is from the unit sphere surface.", v)
-/// ```
-///
 /// [^1]: Marsaglia, George (1972). [*Choosing a Point from the Surface of a
 ///       Sphere.*](https://doi.org/10.1214/aoms/1177692644)
 ///       Ann. Math. Statist. 43, no. 2, 645--646.
+#[deprecated(since="0.7.0", note="moved to rand_distr crate")]
 #[derive(Clone, Copy, Debug)]
-pub struct UnitSphereSurface {
-    uniform: Uniform<f64>,
-}
+pub struct UnitSphereSurface;
 
 impl UnitSphereSurface {
     /// Construct a new `UnitSphereSurface` distribution.
     #[inline]
     pub fn new() -> UnitSphereSurface {
-        UnitSphereSurface { uniform: Uniform::new(-1., 1.) }
+        UnitSphereSurface
     }
 }
 
 impl Distribution<[f64; 3]> for UnitSphereSurface {
     #[inline]
     fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> [f64; 3] {
+        let uniform = Uniform::new(-1., 1.);
         loop {
-            let (x1, x2) = (self.uniform.sample(rng), self.uniform.sample(rng));
+            let (x1, x2) = (uniform.sample(rng), uniform.sample(rng));
             let sum = x1*x1 + x2*x2;
             if sum >= 1. {
                 continue;
@@ -57,7 +48,7 @@ impl Distribution<[f64; 3]> for UnitSphereSurface {
 
 #[cfg(test)]
 mod tests {
-    use distributions::Distribution;
+    use crate::distributions::Distribution;
     use super::UnitSphereSurface;
 
     /// Assert that two numbers are almost equal to each other.
@@ -78,7 +69,7 @@ mod tests {
 
     #[test]
     fn norm() {
-        let mut rng = ::test::rng(1);
+        let mut rng = crate::test::rng(1);
         let dist = UnitSphereSurface::new();
         for _ in 0..1000 {
             let x = dist.sample(&mut rng);
@@ -88,13 +79,17 @@ mod tests {
 
     #[test]
     fn value_stability() {
-        let mut rng = ::test::rng(2);
-        let dist = UnitSphereSurface::new();
-        assert_eq!(dist.sample(&mut rng),
-                   [-0.24950027180862533, -0.7552572587896719, 0.6060825747478084]);
-        assert_eq!(dist.sample(&mut rng),
-                   [0.47604534507233487, -0.797200864987207, -0.3712837328763685]);
-        assert_eq!(dist.sample(&mut rng),
-                   [0.9795722330927367, 0.18692349236651176, 0.07414747571708524]);
+        let mut rng = crate::test::rng(2);
+        let expected = [
+                [0.03247542860231647, -0.7830477442152738, 0.6211131755296027],
+                [-0.09978440840914075, 0.9706650829833128, -0.21875184231323952],
+                [0.2735582468624679, 0.9435374242279655, -0.1868234852870203],
+            ];
+        let samples = [
+                UnitSphereSurface.sample(&mut rng),
+                UnitSphereSurface.sample(&mut rng),
+                UnitSphereSurface.sample(&mut rng),
+            ];
+        assert_eq!(samples, expected);
     }
 }