Added unit tests for new version of exp() for complex numbers.

Author: JorisDeRidder

src/lib.rs

@@ -1577,6 +1577,23 @@ mod test {
     pub const _05_05i: Complex64 = Complex { re: 0.5, im: 0.5 };
     pub const all_consts: [Complex64; 5] = [_0_0i, _1_0i, _1_1i, _neg1_1i, _05_05i];
     pub const _4_2i: Complex64 = Complex { re: 4.0, im: 2.0 };
+    pub const _1_infi: Complex64 = Complex { re: 1.0, im: f64::INFINITY};
+    pub const _neg1_infi: Complex64 = Complex { re: -1.0, im: f64::INFINITY};
+    pub const _1_nani: Complex64 = Complex { re: 1.0, im: f64::NAN};
+    pub const _neg1_nani: Complex64 = Complex { re: -1.0, im: f64::NAN};
+    pub const _inf_0i: Complex64 = Complex { re: f64::INFINITY, im: 0.0};
+    pub const _neginf_1i: Complex64 = Complex { re: f64::NEG_INFINITY, im: 1.0};
+    pub const _neginf_neg1i: Complex64 = Complex { re: f64::NEG_INFINITY, im: -1.0};
+    pub const _inf_1i: Complex64 = Complex { re: f64::INFINITY, im: 1.0};
+    pub const _inf_neg1i: Complex64 = Complex { re: f64::INFINITY, im: -1.0};
+    pub const _neginf_infi: Complex64 = Complex { re: f64::NEG_INFINITY, im: f64::INFINITY};
+    pub const _inf_infi: Complex64 = Complex { re: f64::INFINITY, im: f64::INFINITY};
+    pub const _neginf_nani: Complex64 = Complex {re: f64::NEG_INFINITY, im: f64::NAN};
+    pub const _inf_nani: Complex64 = Complex {re: f64::INFINITY, im: f64::NAN};
+    pub const _nan_0i: Complex64 = Complex {re: f64::NAN, im: 0.0};
+    pub const _nan_1i: Complex64 = Complex {re: f64::NAN, im: 1.0};
+    pub const _nan_neg1i: Complex64 = Complex {re: f64::NAN, im: -1.0};
+    pub const _nan_nani: Complex64 = Complex {re: f64::NAN, im: f64::NAN};
 
     #[test]
     fn test_consts() {
@@ -1727,6 +1744,50 @@ mod test {
             close
         }
 
+        
+        // Version that also works if re or im are +inf, -inf, or nan
+        fn close_naninf(a: Complex64, b: Complex64) -> bool {
+            close_naninf_to_tol(a, b, 1.0e-10)
+        }
+
+
+        fn close_naninf_to_tol(a: Complex64, b: Complex64, tol: f64) -> bool {
+    
+            let mut close = true;
+
+            // Compare the real parts
+            if a.re.is_finite() {
+                if b.re.is_finite() {
+                    close = (a.re == b.re) || (a.re - b.re).abs() < tol;   
+                } else {
+                    close = false; 
+                }
+            } else if (a.re.is_nan() && !b.re.is_nan())
+                    || (a.re.is_infinite() && a.re.is_sign_positive() && !(b.re.is_infinite() && b.re.is_sign_positive()))
+                    || (a.re.is_infinite() && a.re.is_sign_negative() && !(b.re.is_infinite() && b.re.is_sign_negative())) { 
+                close = false;
+            }
+        
+            // Compare the imaginary parts
+            if a.im.is_finite() {
+                if b.im.is_finite() {
+                    close = (a.im == b.im) || (a.im - b.im).abs() < tol;   
+                } else {
+                   close = false; 
+                }
+            } else if (a.im.is_nan() && !b.im.is_nan())
+                    || (a.im.is_infinite() && a.im.is_sign_positive() && !(b.im.is_infinite() && b.im.is_sign_positive()))
+                    || (a.im.is_infinite() && a.im.is_sign_negative() && !(b.im.is_infinite() && b.im.is_sign_negative())) { 
+                close = false;
+            }
+
+            if close == false {
+                println!("{:?} != {:?}", a, b);
+            }
+            close
+        }
+
+
         #[test]
         fn test_exp() {
             assert!(close(_1_0i.exp(), _1_0i.scale(f64::consts::E)));
@@ -1746,6 +1807,24 @@ mod test {
                     (c + _0_1i.scale(f64::consts::PI * 2.0)).exp()
                 ));
             }
+
+            assert!(close_naninf(_1_infi.exp(), _nan_nani));
+            assert!(close_naninf(_neg1_infi.exp(), _nan_nani)); 
+            assert!(close_naninf(_1_nani.exp(), _nan_nani)); 
+            assert!(close_naninf(_neg1_nani.exp(), _nan_nani));
+            assert!(close_naninf(_inf_0i.exp(), _inf_0i));
+            assert!(close_naninf(_neginf_1i.exp(), 0.0 * Complex64::new(1.0.cos(), 1.0.sin()))); 
+            assert!(close_naninf(_neginf_neg1i.exp(), 0.0 * Complex64::new((-1.0).cos(), (-1.0).sin()))); 
+            assert!(close_naninf(_inf_1i.exp(), f64::INFINITY * Complex64::new(1.0.cos(), 1.0.sin())));  
+            assert!(close_naninf(_inf_neg1i.exp(), f64::INFINITY * Complex64::new((-1.0).cos(), (-1.0).sin()))); 
+            assert!(close_naninf(_neginf_infi.exp(), _0_0i));            // Note: ±0±0i: signs of zeros are unspecified 
+            assert!(close_naninf(_inf_infi.exp(), _inf_nani));           // Note: ±∞+NaN*i: sign of the real part is unspecified
+            assert!(close_naninf(_neginf_nani.exp(), _0_0i));            // Note: ±0±0i: signs of zeros are unspecified 
+            assert!(close_naninf(_inf_nani.exp(), _inf_nani));           // Note: ±∞+NaN*i: sign of the real part is unspecified 
+            assert!(close_naninf(_nan_0i.exp(), _nan_0i));
+            assert!(close_naninf(_nan_1i.exp(), _nan_nani));
+            assert!(close_naninf(_nan_neg1i.exp(), _nan_nani)); 
+            assert!(close_naninf(_nan_nani.exp(), _nan_nani));
         }
 
         #[test]