Make assignment operators panic safe

Author: branpk

src/lib.rs

@@ -356,8 +356,7 @@ impl<T: Float + AddAssign> AddAssign for NotNan<T> {
 /// Panics if the provided value is NaN.
 impl<T: Float + AddAssign> AddAssign<T> for NotNan<T> {
     fn add_assign(&mut self, other: T) {
-        self.0 += other;
-        assert!(!self.0.is_nan(), "Addition resulted in NaN");
+        *self = *self + other;
     }
 }
 
@@ -404,8 +403,7 @@ impl<T: Float + SubAssign> SubAssign for NotNan<T> {
 /// Panics if the provided value is NaN or the computation results in NaN
 impl<T: Float + SubAssign> SubAssign<T> for NotNan<T> {
     fn sub_assign(&mut self, other: T) {
-        self.0 -= other;
-        assert!(!self.0.is_nan(), "Subtraction resulted in NaN");
+        *self = *self - other;
     }
 }
 
@@ -439,8 +437,7 @@ impl<T: Float + MulAssign> MulAssign for NotNan<T> {
 /// Panics if the provided value is NaN.
 impl<T: Float + MulAssign> MulAssign<T> for NotNan<T> {
     fn mul_assign(&mut self, other: T) {
-        self.0 *= other;
-        assert!(!self.0.is_nan(), "Multiplication resulted in NaN");
+        *self = *self * other;
     }
 }
 
@@ -486,8 +483,7 @@ impl<T: Float + DivAssign> DivAssign for NotNan<T> {
 /// Panics if the provided value is NaN or the computation results in NaN
 impl<T: Float + DivAssign> DivAssign<T> for NotNan<T> {
     fn div_assign(&mut self, other: T) {
-        self.0 /= other;
-        assert!(!self.0.is_nan(), "Division resulted in NaN");
+        *self = *self / other;
     }
 }
 
@@ -521,8 +517,7 @@ impl<T: Float + RemAssign> RemAssign for NotNan<T> {
 /// Panics if the provided value is NaN or the computation results in NaN
 impl<T: Float + RemAssign> RemAssign<T> for NotNan<T> {
     fn rem_assign(&mut self, other: T) {
-        self.0 %= other;
-        assert!(!self.0.is_nan(), "Rem resulted in NaN");
+        *self = *self % other;
     }
 }
 

tests/test.rs

@@ -579,3 +579,18 @@ fn not_nan64_sum_product() {
     assert_eq!([a,b,c].iter().product::<NotNan<_>>(), a * b * c);
 
 }
+
+#[test]
+fn not_nan_panic_safety() {
+    let catch_op = |mut num, op: fn(&mut NotNan<_>)| {
+        let mut num_ref = panic::AssertUnwindSafe(&mut num);
+        let _ = panic::catch_unwind(move || op(*num_ref));
+        num
+    };
+
+    assert!(!catch_op(NotNan::from(f32::INFINITY), |a| *a += f32::NEG_INFINITY).is_nan());
+    assert!(!catch_op(NotNan::from(f32::INFINITY), |a| *a -= f32::INFINITY).is_nan());
+    assert!(!catch_op(NotNan::from(0.0), |a| *a *= f32::INFINITY).is_nan());
+    assert!(!catch_op(NotNan::from(0.0), |a| *a /= 0.0).is_nan());
+    assert!(!catch_op(NotNan::from(0.0), |a| *a %= 0.0).is_nan());
+}