Add additional checks to remove possibility of NotNaN containing NaN

reem · reem · commit 28f34f948909 · 2017-01-31T10:55:54.000+01:00
Fixes #17
diff --git a/src/lib.rs b/src/lib.rs
@@ -211,7 +211,7 @@ impl Into<f64> for NotNaN<f64> {
 
 /// Creates a NotNaN value from a Float.
 ///
-/// Panics if the provided value is NaN.
+/// Panics if the provided value is NaN or the computation results in NaN
 impl<T: Float> From<T> for NotNaN<T> {
     fn from(v: T) -> Self {
         assert!(!v.is_nan());
@@ -239,35 +239,38 @@ impl<T: Float> Add for NotNaN<T> {
 
 /// Adds a float directly.
 ///
-/// Panics if the provided value is NaN.
+/// Panics if the provided value is NaN or the computation results in NaN
 impl<T: Float> Add<T> for NotNaN<T> {
     type Output = Self;
 
     fn add(self, other: T) -> Self {
         assert!(!other.is_nan());
-        NotNaN(self.0 + other)
+        NotNaN::new(self.0 + other).expect("Addition resulted in NaN")
     }
 }
 
 impl AddAssign for NotNaN<f64> {
     fn add_assign(&mut self, other: Self) {
         self.0 += other.0;
+        assert!(!self.0.is_nan(), "Addition resulted in NaN")
     }
 }
 
 impl AddAssign for NotNaN<f32> {
     fn add_assign(&mut self, other: Self) {
         self.0 += other.0;
+        assert!(!self.0.is_nan(), "Addition resulted in NaN")
     }
 }
 
 /// Adds a float directly.
 ///
-/// Panics if the provided value is NaN.
+/// Panics if the provided value is NaN or the computation results in NaN
 impl AddAssign<f64> for NotNaN<f64> {
     fn add_assign(&mut self, other: f64) {
         assert!(!other.is_nan());
         self.0 += other;
+        assert!(!self.0.is_nan(), "Addition resulted in NaN")
     }
 }
 
@@ -278,90 +281,97 @@ impl AddAssign<f32> for NotNaN<f32> {
     fn add_assign(&mut self, other: f32) {
         assert!(!other.is_nan());
         self.0 += other;
+        assert!(!self.0.is_nan(), "Addition resulted in NaN")
     }
 }
 
 impl<T: Float> Sub for NotNaN<T> {
     type Output = Self;
 
     fn sub(self, other: Self) -> Self {
-        NotNaN(self.0 - other.0)
+        NotNaN::new(self.0 - other.0).expect("Subtraction resulted in NaN")
     }
 }
 
 /// Subtracts a float directly.
 ///
-/// Panics if the provided value is NaN.
+/// Panics if the provided value is NaN or the computation results in NaN
 impl<T: Float> Sub<T> for NotNaN<T> {
     type Output = Self;
 
     fn sub(self, other: T) -> Self {
         assert!(!other.is_nan());
-        NotNaN(self.0 - other)
+        NotNaN::new(self.0 - other).expect("Subtraction resulted in NaN")
     }
 }
 
 impl SubAssign for NotNaN<f64> {
     fn sub_assign(&mut self, other: Self) {
         self.0 -= other.0;
+        assert!(!self.0.is_nan(), "Subtraction resulted in NaN")
     }
 }
 
 impl SubAssign for NotNaN<f32> {
     fn sub_assign(&mut self, other: Self) {
         self.0 -= other.0;
+        assert!(!self.0.is_nan(), "Subtraction resulted in NaN")
     }
 }
 
 /// Subtracts a float directly.
 ///
-/// Panics if the provided value is NaN.
+/// Panics if the provided value is NaN or the computation results in NaN
 impl SubAssign<f64> for NotNaN<f64> {
     fn sub_assign(&mut self, other: f64) {
         assert!(!other.is_nan());
         self.0 -= other;
+        assert!(!self.0.is_nan(), "Subtraction resulted in NaN")
     }
 }
 
 /// Subtracts a float directly.
 ///
-/// Panics if the provided value is NaN.
+/// Panics if the provided value is NaN or the computation results in NaN
 impl SubAssign<f32> for NotNaN<f32> {
     fn sub_assign(&mut self, other: f32) {
         assert!(!other.is_nan());
         self.0 -= other;
+        assert!(!self.0.is_nan(), "Subtraction resulted in NaN")
     }
 }
 
 impl<T: Float> Mul for NotNaN<T> {
     type Output = Self;
 
     fn mul(self, other: Self) -> Self {
-        NotNaN(self.0 * other.0)
+        NotNaN::new(self.0 * other.0).expect("Multiplication resulted in NaN")
     }
 }
 
 /// Multiplies a float directly.
 ///
-/// Panics if the provided value is NaN.
+/// Panics if the provided value is NaN or the computation results in NaN
 impl<T: Float> Mul<T> for NotNaN<T> {
     type Output = Self;
 
     fn mul(self, other: T) -> Self {
         assert!(!other.is_nan());
-        NotNaN(self.0 * other)
+        NotNaN::new(self.0 * other).expect("Multiplication resulted in NaN")
     }
 }
 
 impl MulAssign for NotNaN<f64> {
     fn mul_assign(&mut self, other: Self) {
         self.0 *= other.0;
+        assert!(!self.0.is_nan(), "Multiplication resulted in NaN")
     }
 }
 
 impl MulAssign for NotNaN<f32> {
     fn mul_assign(&mut self, other: Self) {
         self.0 *= other.0;
+        assert!(!self.0.is_nan(), "Multiplication resulted in NaN")
     }
 }
 
@@ -377,123 +387,132 @@ impl MulAssign<f64> for NotNaN<f64> {
 
 /// Multiplies a float directly.
 ///
-/// Panics if the provided value is NaN.
+/// Panics if the provided value is NaN or the computation results in NaN
 impl MulAssign<f32> for NotNaN<f32> {
     fn mul_assign(&mut self, other: f32) {
         assert!(!other.is_nan());
         self.0 *= other;
+        assert!(!self.0.is_nan(), "Multiplication resulted in NaN")
     }
 }
 
 impl<T: Float> Div for NotNaN<T> {
     type Output = Self;
 
     fn div(self, other: Self) -> Self {
-        NotNaN(self.0 / other.0)
+        NotNaN::new(self.0 / other.0).expect("Division resulted in NaN")
     }
 }
 
 /// Divides a float directly.
 ///
-/// Panics if the provided value is NaN.
+/// Panics if the provided value is NaN or the computation results in NaN
 impl<T: Float> Div<T> for NotNaN<T> {
     type Output = Self;
 
     fn div(self, other: T) -> Self {
         assert!(!other.is_nan());
-        NotNaN(self.0 / other)
+        NotNaN::new(self.0 / other).expect("Division resulted in NaN")
     }
 }
 
 impl DivAssign for NotNaN<f64> {
     fn div_assign(&mut self, other: Self) {
         self.0 /= other.0;
+        assert!(!self.0.is_nan(), "Division resulted in NaN")
     }
 }
 
 impl DivAssign for NotNaN<f32> {
     fn div_assign(&mut self, other: Self) {
         self.0 /= other.0;
+        assert!(!self.0.is_nan(), "Division resulted in NaN")
     }
 }
 
 /// Divides a float directly.
 ///
-/// Panics if the provided value is NaN.
+/// Panics if the provided value is NaN or the computation results in NaN
 impl DivAssign<f64> for NotNaN<f64> {
     fn div_assign(&mut self, other: f64) {
         assert!(!other.is_nan());
         self.0 /= other;
+        assert!(!self.0.is_nan(), "Division resulted in NaN")
     }
 }
 
 /// Divides a float directly.
 ///
-/// Panics if the provided value is NaN.
+/// Panics if the provided value is NaN or the computation results in NaN
 impl DivAssign<f32> for NotNaN<f32> {
     fn div_assign(&mut self, other: f32) {
         assert!(!other.is_nan());
         self.0 /= other;
+        assert!(!self.0.is_nan(), "Division resulted in NaN")
     }
 }
 
 impl<T: Float> Rem for NotNaN<T> {
     type Output = Self;
 
     fn rem(self, other: Self) -> Self {
-        NotNaN(self.0 % other.0)
+        NotNaN::new(self.0 % other.0).expect("Rem resulted in NaN")
     }
 }
 
 /// Calculates `%` with a float directly.
 ///
-/// Panics if the provided value is NaN.
+/// Panics if the provided value is NaN or the computation results in NaN
 impl<T: Float> Rem<T> for NotNaN<T> {
     type Output = Self;
 
     fn rem(self, other: T) -> Self {
         assert!(!other.is_nan());
-        NotNaN(self.0 % other)
+        NotNaN::new(self.0 % other).expect("Rem resulted in NaN")
     }
 }
 
 impl RemAssign for NotNaN<f64> {
     fn rem_assign(&mut self, other: Self) {
         self.0 %= other.0;
+        assert!(!self.0.is_nan(), "Rem resulted in NaN")
     }
 }
 
 impl RemAssign for NotNaN<f32> {
     fn rem_assign(&mut self, other: Self) {
         self.0 %= other.0;
+        assert!(!self.0.is_nan(), "Rem resulted in NaN")
     }
 }
 
 /// Calculates `%=` with a float directly.
 ///
-/// Panics if the provided value is NaN.
+/// Panics if the provided value is NaN or the computation results in NaN
 impl RemAssign<f64> for NotNaN<f64> {
     fn rem_assign(&mut self, other: f64) {
         assert!(!other.is_nan());
         self.0 %= other;
+        assert!(!self.0.is_nan(), "Rem resulted in NaN")
     }
 }
 
 /// Calculates `%=` with a float directly.
 ///
-/// Panics if the provided value is NaN.
+/// Panics if the provided value is NaN or the computation results in NaN
 impl RemAssign<f32> for NotNaN<f32> {
     fn rem_assign(&mut self, other: f32) {
         assert!(!other.is_nan());
         self.0 %= other;
+        assert!(!self.0.is_nan(), "Rem resulted in NaN")
     }
 }
 
 impl<T: Float> Neg for NotNaN<T> {
     type Output = Self;
 
     fn neg(self) -> Self {
-        NotNaN(-self.0)
+        NotNaN::new(-self.0).expect("Negation resulted in NaN")
     }
 }
 

Original file line number	Diff line number	Diff line change
`@@ -211,7 +211,7 @@ impl Into<f64> for NotNaN<f64> {`
`211`	`211`
`212`	`212`	`/// Creates a NotNaN value from a Float.`
`213`	`213`	`///`
`214`		`-/// Panics if the provided value is NaN.`
	`214`	`+/// Panics if the provided value is NaN or the computation results in NaN`
`215`	`215`	`impl<T: Float> From<T> for NotNaN<T> {`
`216`	`216`	`fn from(v: T) -> Self {`
`217`	`217`	`assert!(!v.is_nan());`
`@@ -239,35 +239,38 @@ impl<T: Float> Add for NotNaN<T> {`
`239`	`239`
`240`	`240`	`/// Adds a float directly.`
`241`	`241`	`///`
`242`		`-/// Panics if the provided value is NaN.`
	`242`	`+/// Panics if the provided value is NaN or the computation results in NaN`
`243`	`243`	`impl<T: Float> Add<T> for NotNaN<T> {`
`244`	`244`	`type Output = Self;`
`245`	`245`
`246`	`246`	`fn add(self, other: T) -> Self {`
`247`	`247`	`assert!(!other.is_nan());`
`248`		`- NotNaN(self.0 + other)`
	`248`	`+ NotNaN::new(self.0 + other).expect("Addition resulted in NaN")`
`249`	`249`	`}`
`250`	`250`	`}`
`251`	`251`
`252`	`252`	`impl AddAssign for NotNaN<f64> {`
`253`	`253`	`fn add_assign(&mut self, other: Self) {`
`254`	`254`	`self.0 += other.0;`
	`255`	`+ assert!(!self.0.is_nan(), "Addition resulted in NaN")`
`255`	`256`	`}`
`256`	`257`	`}`
`257`	`258`
`258`	`259`	`impl AddAssign for NotNaN<f32> {`
`259`	`260`	`fn add_assign(&mut self, other: Self) {`
`260`	`261`	`self.0 += other.0;`
	`262`	`+ assert!(!self.0.is_nan(), "Addition resulted in NaN")`
`261`	`263`	`}`
`262`	`264`	`}`
`263`	`265`
`264`	`266`	`/// Adds a float directly.`
`265`	`267`	`///`
`266`		`-/// Panics if the provided value is NaN.`
	`268`	`+/// Panics if the provided value is NaN or the computation results in NaN`
`267`	`269`	`impl AddAssign<f64> for NotNaN<f64> {`
`268`	`270`	`fn add_assign(&mut self, other: f64) {`
`269`	`271`	`assert!(!other.is_nan());`
`270`	`272`	`self.0 += other;`
	`273`	`+ assert!(!self.0.is_nan(), "Addition resulted in NaN")`
`271`	`274`	`}`
`272`	`275`	`}`
`273`	`276`
`@@ -278,90 +281,97 @@ impl AddAssign<f32> for NotNaN<f32> {`
`278`	`281`	`fn add_assign(&mut self, other: f32) {`
`279`	`282`	`assert!(!other.is_nan());`
`280`	`283`	`self.0 += other;`
	`284`	`+ assert!(!self.0.is_nan(), "Addition resulted in NaN")`
`281`	`285`	`}`
`282`	`286`	`}`
`283`	`287`
`284`	`288`	`impl<T: Float> Sub for NotNaN<T> {`
`285`	`289`	`type Output = Self;`
`286`	`290`
`287`	`291`	`fn sub(self, other: Self) -> Self {`
`288`		`- NotNaN(self.0 - other.0)`
	`292`	`+ NotNaN::new(self.0 - other.0).expect("Subtraction resulted in NaN")`
`289`	`293`	`}`
`290`	`294`	`}`
`291`	`295`
`292`	`296`	`/// Subtracts a float directly.`
`293`	`297`	`///`
`294`		`-/// Panics if the provided value is NaN.`
	`298`	`+/// Panics if the provided value is NaN or the computation results in NaN`
`295`	`299`	`impl<T: Float> Sub<T> for NotNaN<T> {`
`296`	`300`	`type Output = Self;`
`297`	`301`
`298`	`302`	`fn sub(self, other: T) -> Self {`
`299`	`303`	`assert!(!other.is_nan());`
`300`		`- NotNaN(self.0 - other)`
	`304`	`+ NotNaN::new(self.0 - other).expect("Subtraction resulted in NaN")`
`301`	`305`	`}`
`302`	`306`	`}`
`303`	`307`
`304`	`308`	`impl SubAssign for NotNaN<f64> {`
`305`	`309`	`fn sub_assign(&mut self, other: Self) {`
`306`	`310`	`self.0 -= other.0;`
	`311`	`+ assert!(!self.0.is_nan(), "Subtraction resulted in NaN")`
`307`	`312`	`}`
`308`	`313`	`}`
`309`	`314`
`310`	`315`	`impl SubAssign for NotNaN<f32> {`
`311`	`316`	`fn sub_assign(&mut self, other: Self) {`
`312`	`317`	`self.0 -= other.0;`
	`318`	`+ assert!(!self.0.is_nan(), "Subtraction resulted in NaN")`
`313`	`319`	`}`
`314`	`320`	`}`
`315`	`321`
`316`	`322`	`/// Subtracts a float directly.`
`317`	`323`	`///`
`318`		`-/// Panics if the provided value is NaN.`
	`324`	`+/// Panics if the provided value is NaN or the computation results in NaN`
`319`	`325`	`impl SubAssign<f64> for NotNaN<f64> {`
`320`	`326`	`fn sub_assign(&mut self, other: f64) {`
`321`	`327`	`assert!(!other.is_nan());`
`322`	`328`	`self.0 -= other;`
	`329`	`+ assert!(!self.0.is_nan(), "Subtraction resulted in NaN")`
`323`	`330`	`}`
`324`	`331`	`}`
`325`	`332`
`326`	`333`	`/// Subtracts a float directly.`
`327`	`334`	`///`
`328`		`-/// Panics if the provided value is NaN.`
	`335`	`+/// Panics if the provided value is NaN or the computation results in NaN`
`329`	`336`	`impl SubAssign<f32> for NotNaN<f32> {`
`330`	`337`	`fn sub_assign(&mut self, other: f32) {`
`331`	`338`	`assert!(!other.is_nan());`
`332`	`339`	`self.0 -= other;`
	`340`	`+ assert!(!self.0.is_nan(), "Subtraction resulted in NaN")`
`333`	`341`	`}`
`334`	`342`	`}`
`335`	`343`
`336`	`344`	`impl<T: Float> Mul for NotNaN<T> {`
`337`	`345`	`type Output = Self;`
`338`	`346`
`339`	`347`	`fn mul(self, other: Self) -> Self {`
`340`		`- NotNaN(self.0 * other.0)`
	`348`	`+ NotNaN::new(self.0 * other.0).expect("Multiplication resulted in NaN")`
`341`	`349`	`}`
`342`	`350`	`}`
`343`	`351`
`344`	`352`	`/// Multiplies a float directly.`
`345`	`353`	`///`
`346`		`-/// Panics if the provided value is NaN.`
	`354`	`+/// Panics if the provided value is NaN or the computation results in NaN`
`347`	`355`	`impl<T: Float> Mul<T> for NotNaN<T> {`
`348`	`356`	`type Output = Self;`
`349`	`357`
`350`	`358`	`fn mul(self, other: T) -> Self {`
`351`	`359`	`assert!(!other.is_nan());`
`352`		`- NotNaN(self.0 * other)`
	`360`	`+ NotNaN::new(self.0 * other).expect("Multiplication resulted in NaN")`
`353`	`361`	`}`
`354`	`362`	`}`
`355`	`363`
`356`	`364`	`impl MulAssign for NotNaN<f64> {`
`357`	`365`	`fn mul_assign(&mut self, other: Self) {`
`358`	`366`	`self.0 *= other.0;`
	`367`	`+ assert!(!self.0.is_nan(), "Multiplication resulted in NaN")`
`359`	`368`	`}`
`360`	`369`	`}`
`361`	`370`
`362`	`371`	`impl MulAssign for NotNaN<f32> {`
`363`	`372`	`fn mul_assign(&mut self, other: Self) {`
`364`	`373`	`self.0 *= other.0;`
	`374`	`+ assert!(!self.0.is_nan(), "Multiplication resulted in NaN")`
`365`	`375`	`}`
`366`	`376`	`}`
`367`	`377`
`@@ -377,123 +387,132 @@ impl MulAssign<f64> for NotNaN<f64> {`
`377`	`387`
`378`	`388`	`/// Multiplies a float directly.`
`379`	`389`	`///`
`380`		`-/// Panics if the provided value is NaN.`
	`390`	`+/// Panics if the provided value is NaN or the computation results in NaN`
`381`	`391`	`impl MulAssign<f32> for NotNaN<f32> {`
`382`	`392`	`fn mul_assign(&mut self, other: f32) {`
`383`	`393`	`assert!(!other.is_nan());`
`384`	`394`	`self.0 *= other;`
	`395`	`+ assert!(!self.0.is_nan(), "Multiplication resulted in NaN")`
`385`	`396`	`}`
`386`	`397`	`}`
`387`	`398`
`388`	`399`	`impl<T: Float> Div for NotNaN<T> {`
`389`	`400`	`type Output = Self;`
`390`	`401`
`391`	`402`	`fn div(self, other: Self) -> Self {`
`392`		`- NotNaN(self.0 / other.0)`
	`403`	`+ NotNaN::new(self.0 / other.0).expect("Division resulted in NaN")`
`393`	`404`	`}`
`394`	`405`	`}`
`395`	`406`
`396`	`407`	`/// Divides a float directly.`
`397`	`408`	`///`
`398`		`-/// Panics if the provided value is NaN.`
	`409`	`+/// Panics if the provided value is NaN or the computation results in NaN`
`399`	`410`	`impl<T: Float> Div<T> for NotNaN<T> {`
`400`	`411`	`type Output = Self;`
`401`	`412`
`402`	`413`	`fn div(self, other: T) -> Self {`
`403`	`414`	`assert!(!other.is_nan());`
`404`		`- NotNaN(self.0 / other)`
	`415`	`+ NotNaN::new(self.0 / other).expect("Division resulted in NaN")`
`405`	`416`	`}`
`406`	`417`	`}`
`407`	`418`
`408`	`419`	`impl DivAssign for NotNaN<f64> {`
`409`	`420`	`fn div_assign(&mut self, other: Self) {`
`410`	`421`	`self.0 /= other.0;`
	`422`	`+ assert!(!self.0.is_nan(), "Division resulted in NaN")`
`411`	`423`	`}`
`412`	`424`	`}`
`413`	`425`
`414`	`426`	`impl DivAssign for NotNaN<f32> {`
`415`	`427`	`fn div_assign(&mut self, other: Self) {`
`416`	`428`	`self.0 /= other.0;`
	`429`	`+ assert!(!self.0.is_nan(), "Division resulted in NaN")`
`417`	`430`	`}`
`418`	`431`	`}`
`419`	`432`
`420`	`433`	`/// Divides a float directly.`
`421`	`434`	`///`
`422`		`-/// Panics if the provided value is NaN.`
	`435`	`+/// Panics if the provided value is NaN or the computation results in NaN`
`423`	`436`	`impl DivAssign<f64> for NotNaN<f64> {`
`424`	`437`	`fn div_assign(&mut self, other: f64) {`
`425`	`438`	`assert!(!other.is_nan());`
`426`	`439`	`self.0 /= other;`
	`440`	`+ assert!(!self.0.is_nan(), "Division resulted in NaN")`
`427`	`441`	`}`
`428`	`442`	`}`
`429`	`443`
`430`	`444`	`/// Divides a float directly.`
`431`	`445`	`///`
`432`		`-/// Panics if the provided value is NaN.`
	`446`	`+/// Panics if the provided value is NaN or the computation results in NaN`
`433`	`447`	`impl DivAssign<f32> for NotNaN<f32> {`
`434`	`448`	`fn div_assign(&mut self, other: f32) {`
`435`	`449`	`assert!(!other.is_nan());`
`436`	`450`	`self.0 /= other;`
	`451`	`+ assert!(!self.0.is_nan(), "Division resulted in NaN")`
`437`	`452`	`}`
`438`	`453`	`}`
`439`	`454`
`440`	`455`	`impl<T: Float> Rem for NotNaN<T> {`
`441`	`456`	`type Output = Self;`
`442`	`457`
`443`	`458`	`fn rem(self, other: Self) -> Self {`
`444`		`- NotNaN(self.0 % other.0)`
	`459`	`+ NotNaN::new(self.0 % other.0).expect("Rem resulted in NaN")`
`445`	`460`	`}`
`446`	`461`	`}`
`447`	`462`
`448`	`463`	/// Calculates `%` with a float directly.
`449`	`464`	`///`
`450`		`-/// Panics if the provided value is NaN.`
	`465`	`+/// Panics if the provided value is NaN or the computation results in NaN`
`451`	`466`	`impl<T: Float> Rem<T> for NotNaN<T> {`
`452`	`467`	`type Output = Self;`
`453`	`468`
`454`	`469`	`fn rem(self, other: T) -> Self {`
`455`	`470`	`assert!(!other.is_nan());`
`456`		`- NotNaN(self.0 % other)`
	`471`	`+ NotNaN::new(self.0 % other).expect("Rem resulted in NaN")`
`457`	`472`	`}`
`458`	`473`	`}`
`459`	`474`
`460`	`475`	`impl RemAssign for NotNaN<f64> {`
`461`	`476`	`fn rem_assign(&mut self, other: Self) {`
`462`	`477`	`self.0 %= other.0;`
	`478`	`+ assert!(!self.0.is_nan(), "Rem resulted in NaN")`
`463`	`479`	`}`
`464`	`480`	`}`
`465`	`481`
`466`	`482`	`impl RemAssign for NotNaN<f32> {`
`467`	`483`	`fn rem_assign(&mut self, other: Self) {`
`468`	`484`	`self.0 %= other.0;`
	`485`	`+ assert!(!self.0.is_nan(), "Rem resulted in NaN")`
`469`	`486`	`}`
`470`	`487`	`}`
`471`	`488`
`472`	`489`	/// Calculates `%=` with a float directly.
`473`	`490`	`///`
`474`		`-/// Panics if the provided value is NaN.`
	`491`	`+/// Panics if the provided value is NaN or the computation results in NaN`
`475`	`492`	`impl RemAssign<f64> for NotNaN<f64> {`
`476`	`493`	`fn rem_assign(&mut self, other: f64) {`
`477`	`494`	`assert!(!other.is_nan());`
`478`	`495`	`self.0 %= other;`
	`496`	`+ assert!(!self.0.is_nan(), "Rem resulted in NaN")`
`479`	`497`	`}`
`480`	`498`	`}`
`481`	`499`
`482`	`500`	/// Calculates `%=` with a float directly.
`483`	`501`	`///`
`484`		`-/// Panics if the provided value is NaN.`
	`502`	`+/// Panics if the provided value is NaN or the computation results in NaN`
`485`	`503`	`impl RemAssign<f32> for NotNaN<f32> {`
`486`	`504`	`fn rem_assign(&mut self, other: f32) {`
`487`	`505`	`assert!(!other.is_nan());`
`488`	`506`	`self.0 %= other;`
	`507`	`+ assert!(!self.0.is_nan(), "Rem resulted in NaN")`
`489`	`508`	`}`
`490`	`509`	`}`
`491`	`510`
`492`	`511`	`impl<T: Float> Neg for NotNaN<T> {`
`493`	`512`	`type Output = Self;`
`494`	`513`
`495`	`514`	`fn neg(self) -> Self {`
`496`		`- NotNaN(-self.0)`
	`515`	`+ NotNaN::new(-self.0).expect("Negation resulted in NaN")`
`497`	`516`	`}`
`498`	`517`	`}`
`499`	`518`