fix: use f*_algebraic intrinsics, instead of f*_fast intrinsics (#481)

usamoi · web-flow · commit a299b54b55c9 · 2024-05-20T10:13:18.000Z
Signed-off-by: usamoi &lt;usamoi@outlook.com&gt;
diff --git a/crates/base/src/scalar/f32.rs b/crates/base/src/scalar/f32.rs
@@ -455,14 +455,14 @@ impl Add<F32> for F32 {
 
     #[inline(always)]
     fn add(self, rhs: F32) -> F32 {
-        unsafe { std::intrinsics::fadd_fast(self.0, rhs.0).into() }
+        intrinsics::fadd_algebraic(self.0, rhs.0).into()
     }
 }
 
 impl AddAssign<F32> for F32 {
     #[inline(always)]
     fn add_assign(&mut self, rhs: F32) {
-        unsafe { self.0 = std::intrinsics::fadd_fast(self.0, rhs.0) }
+        self.0 = intrinsics::fadd_algebraic(self.0, rhs.0)
     }
 }
 
@@ -477,14 +477,14 @@ impl Sub<F32> for F32 {
 
     #[inline(always)]
     fn sub(self, rhs: F32) -> F32 {
-        unsafe { std::intrinsics::fsub_fast(self.0, rhs.0).into() }
+        intrinsics::fsub_algebraic(self.0, rhs.0).into()
     }
 }
 
 impl SubAssign<F32> for F32 {
     #[inline(always)]
     fn sub_assign(&mut self, rhs: F32) {
-        unsafe { self.0 = std::intrinsics::fsub_fast(self.0, rhs.0) }
+        self.0 = intrinsics::fsub_algebraic(self.0, rhs.0)
     }
 }
 
@@ -493,14 +493,14 @@ impl Mul<F32> for F32 {
 
     #[inline(always)]
     fn mul(self, rhs: F32) -> F32 {
-        unsafe { std::intrinsics::fmul_fast(self.0, rhs.0).into() }
+        intrinsics::fmul_algebraic(self.0, rhs.0).into()
     }
 }
 
 impl MulAssign<F32> for F32 {
     #[inline(always)]
     fn mul_assign(&mut self, rhs: F32) {
-        unsafe { self.0 = std::intrinsics::fmul_fast(self.0, rhs.0) }
+        self.0 = intrinsics::fmul_algebraic(self.0, rhs.0)
     }
 }
 
@@ -509,14 +509,14 @@ impl Div<F32> for F32 {
 
     #[inline(always)]
     fn div(self, rhs: F32) -> F32 {
-        unsafe { std::intrinsics::fdiv_fast(self.0, rhs.0).into() }
+        intrinsics::fdiv_algebraic(self.0, rhs.0).into()
     }
 }
 
 impl DivAssign<F32> for F32 {
     #[inline(always)]
     fn div_assign(&mut self, rhs: F32) {
-        unsafe { self.0 = std::intrinsics::fdiv_fast(self.0, rhs.0) }
+        self.0 = intrinsics::fdiv_algebraic(self.0, rhs.0)
     }
 }
 
@@ -525,14 +525,14 @@ impl Rem<F32> for F32 {
 
     #[inline(always)]
     fn rem(self, rhs: F32) -> F32 {
-        unsafe { std::intrinsics::frem_fast(self.0, rhs.0).into() }
+        intrinsics::frem_algebraic(self.0, rhs.0).into()
     }
 }
 
 impl RemAssign<F32> for F32 {
     #[inline(always)]
     fn rem_assign(&mut self, rhs: F32) {
-        unsafe { self.0 = std::intrinsics::frem_fast(self.0, rhs.0) }
+        self.0 = intrinsics::frem_algebraic(self.0, rhs.0)
     }
 }
 
@@ -569,13 +569,13 @@ impl Add<f32> for F32 {
 
     #[inline(always)]
     fn add(self, rhs: f32) -> F32 {
-        unsafe { std::intrinsics::fadd_fast(self.0, rhs).into() }
+        intrinsics::fadd_algebraic(self.0, rhs).into()
     }
 }
 
 impl AddAssign<f32> for F32 {
     fn add_assign(&mut self, rhs: f32) {
-        unsafe { self.0 = std::intrinsics::fadd_fast(self.0, rhs) }
+        self.0 = intrinsics::fadd_algebraic(self.0, rhs)
     }
 }
 
@@ -584,14 +584,14 @@ impl Sub<f32> for F32 {
 
     #[inline(always)]
     fn sub(self, rhs: f32) -> F32 {
-        unsafe { std::intrinsics::fsub_fast(self.0, rhs).into() }
+        intrinsics::fsub_algebraic(self.0, rhs).into()
     }
 }
 
 impl SubAssign<f32> for F32 {
     #[inline(always)]
     fn sub_assign(&mut self, rhs: f32) {
-        unsafe { self.0 = std::intrinsics::fsub_fast(self.0, rhs) }
+        self.0 = intrinsics::fsub_algebraic(self.0, rhs)
     }
 }
 
@@ -600,14 +600,14 @@ impl Mul<f32> for F32 {
 
     #[inline(always)]
     fn mul(self, rhs: f32) -> F32 {
-        unsafe { std::intrinsics::fmul_fast(self.0, rhs).into() }
+        intrinsics::fmul_algebraic(self.0, rhs).into()
     }
 }
 
 impl MulAssign<f32> for F32 {
     #[inline(always)]
     fn mul_assign(&mut self, rhs: f32) {
-        unsafe { self.0 = std::intrinsics::fmul_fast(self.0, rhs) }
+        self.0 = intrinsics::fmul_algebraic(self.0, rhs)
     }
 }
 
@@ -616,14 +616,14 @@ impl Div<f32> for F32 {
 
     #[inline(always)]
     fn div(self, rhs: f32) -> F32 {
-        unsafe { std::intrinsics::fdiv_fast(self.0, rhs).into() }
+        intrinsics::fdiv_algebraic(self.0, rhs).into()
     }
 }
 
 impl DivAssign<f32> for F32 {
     #[inline(always)]
     fn div_assign(&mut self, rhs: f32) {
-        unsafe { self.0 = std::intrinsics::fdiv_fast(self.0, rhs) }
+        self.0 = intrinsics::fdiv_algebraic(self.0, rhs)
     }
 }
 
@@ -632,14 +632,37 @@ impl Rem<f32> for F32 {
 
     #[inline(always)]
     fn rem(self, rhs: f32) -> F32 {
-        unsafe { std::intrinsics::frem_fast(self.0, rhs).into() }
+        intrinsics::frem_algebraic(self.0, rhs).into()
     }
 }
 
 impl RemAssign<f32> for F32 {
     #[inline(always)]
     fn rem_assign(&mut self, rhs: f32) {
-        unsafe { self.0 = std::intrinsics::frem_fast(self.0, rhs) }
+        self.0 = intrinsics::frem_algebraic(self.0, rhs)
+    }
+}
+
+mod intrinsics {
+    #[inline(always)]
+    pub fn fadd_algebraic(lhs: f32, rhs: f32) -> f32 {
+        std::intrinsics::fadd_algebraic(lhs, rhs)
+    }
+    #[inline(always)]
+    pub fn fsub_algebraic(lhs: f32, rhs: f32) -> f32 {
+        std::intrinsics::fsub_algebraic(lhs, rhs)
+    }
+    #[inline(always)]
+    pub fn fmul_algebraic(lhs: f32, rhs: f32) -> f32 {
+        std::intrinsics::fmul_algebraic(lhs, rhs)
+    }
+    #[inline(always)]
+    pub fn fdiv_algebraic(lhs: f32, rhs: f32) -> f32 {
+        std::intrinsics::fdiv_algebraic(lhs, rhs)
+    }
+    #[inline(always)]
+    pub fn frem_algebraic(lhs: f32, rhs: f32) -> f32 {
+        std::intrinsics::frem_algebraic(lhs, rhs)
     }
 }
 
diff --git a/crates/base/src/scalar/half_f16.rs b/crates/base/src/scalar/half_f16.rs
@@ -441,14 +441,14 @@ impl Add<F16> for F16 {
 
     #[inline(always)]
     fn add(self, rhs: F16) -> F16 {
-        unsafe { intrinsics::fadd_fast(self.0, rhs.0).into() }
+        intrinsics::fadd_algebraic(self.0, rhs.0).into()
     }
 }
 
 impl AddAssign<F16> for F16 {
     #[inline(always)]
     fn add_assign(&mut self, rhs: F16) {
-        unsafe { self.0 = intrinsics::fadd_fast(self.0, rhs.0) }
+        self.0 = intrinsics::fadd_algebraic(self.0, rhs.0)
     }
 }
 
@@ -457,14 +457,14 @@ impl Sub<F16> for F16 {
 
     #[inline(always)]
     fn sub(self, rhs: F16) -> F16 {
-        unsafe { intrinsics::fsub_fast(self.0, rhs.0).into() }
+        intrinsics::fsub_algebraic(self.0, rhs.0).into()
     }
 }
 
 impl SubAssign<F16> for F16 {
     #[inline(always)]
     fn sub_assign(&mut self, rhs: F16) {
-        unsafe { self.0 = intrinsics::fsub_fast(self.0, rhs.0) }
+        self.0 = intrinsics::fsub_algebraic(self.0, rhs.0)
     }
 }
 
@@ -473,14 +473,14 @@ impl Mul<F16> for F16 {
 
     #[inline(always)]
     fn mul(self, rhs: F16) -> F16 {
-        unsafe { intrinsics::fmul_fast(self.0, rhs.0).into() }
+        intrinsics::fmul_algebraic(self.0, rhs.0).into()
     }
 }
 
 impl MulAssign<F16> for F16 {
     #[inline(always)]
     fn mul_assign(&mut self, rhs: F16) {
-        unsafe { self.0 = intrinsics::fmul_fast(self.0, rhs.0) }
+        self.0 = intrinsics::fmul_algebraic(self.0, rhs.0)
     }
 }
 
@@ -489,14 +489,14 @@ impl Div<F16> for F16 {
 
     #[inline(always)]
     fn div(self, rhs: F16) -> F16 {
-        unsafe { intrinsics::fdiv_fast(self.0, rhs.0).into() }
+        intrinsics::fdiv_algebraic(self.0, rhs.0).into()
     }
 }
 
 impl DivAssign<F16> for F16 {
     #[inline(always)]
     fn div_assign(&mut self, rhs: F16) {
-        unsafe { self.0 = intrinsics::fdiv_fast(self.0, rhs.0) }
+        self.0 = intrinsics::fdiv_algebraic(self.0, rhs.0)
     }
 }
 
@@ -505,14 +505,14 @@ impl Rem<F16> for F16 {
 
     #[inline(always)]
     fn rem(self, rhs: F16) -> F16 {
-        unsafe { intrinsics::frem_fast(self.0, rhs.0).into() }
+        intrinsics::frem_algebraic(self.0, rhs.0).into()
     }
 }
 
 impl RemAssign<F16> for F16 {
     #[inline(always)]
     fn rem_assign(&mut self, rhs: F16) {
-        unsafe { self.0 = intrinsics::frem_fast(self.0, rhs.0) }
+        self.0 = intrinsics::frem_algebraic(self.0, rhs.0)
     }
 }
 
@@ -549,13 +549,13 @@ impl Add<f16> for F16 {
 
     #[inline(always)]
     fn add(self, rhs: f16) -> F16 {
-        unsafe { intrinsics::fadd_fast(self.0, rhs).into() }
+        intrinsics::fadd_algebraic(self.0, rhs).into()
     }
 }
 
 impl AddAssign<f16> for F16 {
     fn add_assign(&mut self, rhs: f16) {
-        unsafe { self.0 = intrinsics::fadd_fast(self.0, rhs) }
+        self.0 = intrinsics::fadd_algebraic(self.0, rhs)
     }
 }
 
@@ -564,14 +564,14 @@ impl Sub<f16> for F16 {
 
     #[inline(always)]
     fn sub(self, rhs: f16) -> F16 {
-        unsafe { intrinsics::fsub_fast(self.0, rhs).into() }
+        intrinsics::fsub_algebraic(self.0, rhs).into()
     }
 }
 
 impl SubAssign<f16> for F16 {
     #[inline(always)]
     fn sub_assign(&mut self, rhs: f16) {
-        unsafe { self.0 = intrinsics::fsub_fast(self.0, rhs) }
+        self.0 = intrinsics::fsub_algebraic(self.0, rhs)
     }
 }
 
@@ -580,14 +580,14 @@ impl Mul<f16> for F16 {
 
     #[inline(always)]
     fn mul(self, rhs: f16) -> F16 {
-        unsafe { intrinsics::fmul_fast(self.0, rhs).into() }
+        intrinsics::fmul_algebraic(self.0, rhs).into()
     }
 }
 
 impl MulAssign<f16> for F16 {
     #[inline(always)]
     fn mul_assign(&mut self, rhs: f16) {
-        unsafe { self.0 = intrinsics::fmul_fast(self.0, rhs) }
+        self.0 = intrinsics::fmul_algebraic(self.0, rhs)
     }
 }
 
@@ -596,14 +596,14 @@ impl Div<f16> for F16 {
 
     #[inline(always)]
     fn div(self, rhs: f16) -> F16 {
-        unsafe { intrinsics::fdiv_fast(self.0, rhs).into() }
+        intrinsics::fdiv_algebraic(self.0, rhs).into()
     }
 }
 
 impl DivAssign<f16> for F16 {
     #[inline(always)]
     fn div_assign(&mut self, rhs: f16) {
-        unsafe { self.0 = intrinsics::fdiv_fast(self.0, rhs) }
+        self.0 = intrinsics::fdiv_algebraic(self.0, rhs)
     }
 }
 
@@ -612,33 +612,38 @@ impl Rem<f16> for F16 {
 
     #[inline(always)]
     fn rem(self, rhs: f16) -> F16 {
-        unsafe { intrinsics::frem_fast(self.0, rhs).into() }
+        intrinsics::frem_algebraic(self.0, rhs).into()
     }
 }
 
 impl RemAssign<f16> for F16 {
     #[inline(always)]
     fn rem_assign(&mut self, rhs: f16) {
-        unsafe { self.0 = intrinsics::frem_fast(self.0, rhs) }
+        self.0 = intrinsics::frem_algebraic(self.0, rhs)
     }
 }
 
 mod intrinsics {
     use half::f16;
 
-    pub unsafe fn fadd_fast(lhs: f16, rhs: f16) -> f16 {
+    #[inline(always)]
+    pub fn fadd_algebraic(lhs: f16, rhs: f16) -> f16 {
         lhs + rhs
     }
-    pub unsafe fn fsub_fast(lhs: f16, rhs: f16) -> f16 {
+    #[inline(always)]
+    pub fn fsub_algebraic(lhs: f16, rhs: f16) -> f16 {
         lhs - rhs
     }
-    pub unsafe fn fmul_fast(lhs: f16, rhs: f16) -> f16 {
+    #[inline(always)]
+    pub fn fmul_algebraic(lhs: f16, rhs: f16) -> f16 {
         lhs * rhs
     }
-    pub unsafe fn fdiv_fast(lhs: f16, rhs: f16) -> f16 {
+    #[inline(always)]
+    pub fn fdiv_algebraic(lhs: f16, rhs: f16) -> f16 {
         lhs / rhs
     }
-    pub unsafe fn frem_fast(lhs: f16, rhs: f16) -> f16 {
+    #[inline(always)]
+    pub fn frem_algebraic(lhs: f16, rhs: f16) -> f16 {
         lhs % rhs
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -455,14 +455,14 @@ impl Add<F32> for F32 {`
`455`	`455`
`456`	`456`	`#[inline(always)]`
`457`	`457`	`fn add(self, rhs: F32) -> F32 {`
`458`		`- unsafe { std::intrinsics::fadd_fast(self.0, rhs.0).into() }`
	`458`	`+ intrinsics::fadd_algebraic(self.0, rhs.0).into()`
`459`	`459`	`}`
`460`	`460`	`}`
`461`	`461`
`462`	`462`	`impl AddAssign<F32> for F32 {`
`463`	`463`	`#[inline(always)]`
`464`	`464`	`fn add_assign(&mut self, rhs: F32) {`
`465`		`- unsafe { self.0 = std::intrinsics::fadd_fast(self.0, rhs.0) }`
	`465`	`+ self.0 = intrinsics::fadd_algebraic(self.0, rhs.0)`
`466`	`466`	`}`
`467`	`467`	`}`
`468`	`468`
`@@ -477,14 +477,14 @@ impl Sub<F32> for F32 {`
`477`	`477`
`478`	`478`	`#[inline(always)]`
`479`	`479`	`fn sub(self, rhs: F32) -> F32 {`
`480`		`- unsafe { std::intrinsics::fsub_fast(self.0, rhs.0).into() }`
	`480`	`+ intrinsics::fsub_algebraic(self.0, rhs.0).into()`
`481`	`481`	`}`
`482`	`482`	`}`
`483`	`483`
`484`	`484`	`impl SubAssign<F32> for F32 {`
`485`	`485`	`#[inline(always)]`
`486`	`486`	`fn sub_assign(&mut self, rhs: F32) {`
`487`		`- unsafe { self.0 = std::intrinsics::fsub_fast(self.0, rhs.0) }`
	`487`	`+ self.0 = intrinsics::fsub_algebraic(self.0, rhs.0)`
`488`	`488`	`}`
`489`	`489`	`}`
`490`	`490`
`@@ -493,14 +493,14 @@ impl Mul<F32> for F32 {`
`493`	`493`
`494`	`494`	`#[inline(always)]`
`495`	`495`	`fn mul(self, rhs: F32) -> F32 {`
`496`		`- unsafe { std::intrinsics::fmul_fast(self.0, rhs.0).into() }`
	`496`	`+ intrinsics::fmul_algebraic(self.0, rhs.0).into()`
`497`	`497`	`}`
`498`	`498`	`}`
`499`	`499`
`500`	`500`	`impl MulAssign<F32> for F32 {`
`501`	`501`	`#[inline(always)]`
`502`	`502`	`fn mul_assign(&mut self, rhs: F32) {`
`503`		`- unsafe { self.0 = std::intrinsics::fmul_fast(self.0, rhs.0) }`
	`503`	`+ self.0 = intrinsics::fmul_algebraic(self.0, rhs.0)`
`504`	`504`	`}`
`505`	`505`	`}`
`506`	`506`
`@@ -509,14 +509,14 @@ impl Div<F32> for F32 {`
`509`	`509`
`510`	`510`	`#[inline(always)]`
`511`	`511`	`fn div(self, rhs: F32) -> F32 {`
`512`		`- unsafe { std::intrinsics::fdiv_fast(self.0, rhs.0).into() }`
	`512`	`+ intrinsics::fdiv_algebraic(self.0, rhs.0).into()`
`513`	`513`	`}`
`514`	`514`	`}`
`515`	`515`
`516`	`516`	`impl DivAssign<F32> for F32 {`
`517`	`517`	`#[inline(always)]`
`518`	`518`	`fn div_assign(&mut self, rhs: F32) {`
`519`		`- unsafe { self.0 = std::intrinsics::fdiv_fast(self.0, rhs.0) }`
	`519`	`+ self.0 = intrinsics::fdiv_algebraic(self.0, rhs.0)`
`520`	`520`	`}`
`521`	`521`	`}`
`522`	`522`
`@@ -525,14 +525,14 @@ impl Rem<F32> for F32 {`
`525`	`525`
`526`	`526`	`#[inline(always)]`
`527`	`527`	`fn rem(self, rhs: F32) -> F32 {`
`528`		`- unsafe { std::intrinsics::frem_fast(self.0, rhs.0).into() }`
	`528`	`+ intrinsics::frem_algebraic(self.0, rhs.0).into()`
`529`	`529`	`}`
`530`	`530`	`}`
`531`	`531`
`532`	`532`	`impl RemAssign<F32> for F32 {`
`533`	`533`	`#[inline(always)]`
`534`	`534`	`fn rem_assign(&mut self, rhs: F32) {`
`535`		`- unsafe { self.0 = std::intrinsics::frem_fast(self.0, rhs.0) }`
	`535`	`+ self.0 = intrinsics::frem_algebraic(self.0, rhs.0)`
`536`	`536`	`}`
`537`	`537`	`}`
`538`	`538`
`@@ -569,13 +569,13 @@ impl Add<f32> for F32 {`
`569`	`569`
`570`	`570`	`#[inline(always)]`
`571`	`571`	`fn add(self, rhs: f32) -> F32 {`
`572`		`- unsafe { std::intrinsics::fadd_fast(self.0, rhs).into() }`
	`572`	`+ intrinsics::fadd_algebraic(self.0, rhs).into()`
`573`	`573`	`}`
`574`	`574`	`}`
`575`	`575`
`576`	`576`	`impl AddAssign<f32> for F32 {`
`577`	`577`	`fn add_assign(&mut self, rhs: f32) {`
`578`		`- unsafe { self.0 = std::intrinsics::fadd_fast(self.0, rhs) }`
	`578`	`+ self.0 = intrinsics::fadd_algebraic(self.0, rhs)`
`579`	`579`	`}`
`580`	`580`	`}`
`581`	`581`
`@@ -584,14 +584,14 @@ impl Sub<f32> for F32 {`
`584`	`584`
`585`	`585`	`#[inline(always)]`
`586`	`586`	`fn sub(self, rhs: f32) -> F32 {`
`587`		`- unsafe { std::intrinsics::fsub_fast(self.0, rhs).into() }`
	`587`	`+ intrinsics::fsub_algebraic(self.0, rhs).into()`
`588`	`588`	`}`
`589`	`589`	`}`
`590`	`590`
`591`	`591`	`impl SubAssign<f32> for F32 {`
`592`	`592`	`#[inline(always)]`
`593`	`593`	`fn sub_assign(&mut self, rhs: f32) {`
`594`		`- unsafe { self.0 = std::intrinsics::fsub_fast(self.0, rhs) }`
	`594`	`+ self.0 = intrinsics::fsub_algebraic(self.0, rhs)`
`595`	`595`	`}`
`596`	`596`	`}`
`597`	`597`
`@@ -600,14 +600,14 @@ impl Mul<f32> for F32 {`
`600`	`600`
`601`	`601`	`#[inline(always)]`
`602`	`602`	`fn mul(self, rhs: f32) -> F32 {`
`603`		`- unsafe { std::intrinsics::fmul_fast(self.0, rhs).into() }`
	`603`	`+ intrinsics::fmul_algebraic(self.0, rhs).into()`
`604`	`604`	`}`
`605`	`605`	`}`
`606`	`606`
`607`	`607`	`impl MulAssign<f32> for F32 {`
`608`	`608`	`#[inline(always)]`
`609`	`609`	`fn mul_assign(&mut self, rhs: f32) {`
`610`		`- unsafe { self.0 = std::intrinsics::fmul_fast(self.0, rhs) }`
	`610`	`+ self.0 = intrinsics::fmul_algebraic(self.0, rhs)`
`611`	`611`	`}`
`612`	`612`	`}`
`613`	`613`
`@@ -616,14 +616,14 @@ impl Div<f32> for F32 {`
`616`	`616`
`617`	`617`	`#[inline(always)]`
`618`	`618`	`fn div(self, rhs: f32) -> F32 {`
`619`		`- unsafe { std::intrinsics::fdiv_fast(self.0, rhs).into() }`
	`619`	`+ intrinsics::fdiv_algebraic(self.0, rhs).into()`
`620`	`620`	`}`
`621`	`621`	`}`
`622`	`622`
`623`	`623`	`impl DivAssign<f32> for F32 {`
`624`	`624`	`#[inline(always)]`
`625`	`625`	`fn div_assign(&mut self, rhs: f32) {`
`626`		`- unsafe { self.0 = std::intrinsics::fdiv_fast(self.0, rhs) }`
	`626`	`+ self.0 = intrinsics::fdiv_algebraic(self.0, rhs)`
`627`	`627`	`}`
`628`	`628`	`}`
`629`	`629`
`@@ -632,14 +632,37 @@ impl Rem<f32> for F32 {`
`632`	`632`
`633`	`633`	`#[inline(always)]`
`634`	`634`	`fn rem(self, rhs: f32) -> F32 {`
`635`		`- unsafe { std::intrinsics::frem_fast(self.0, rhs).into() }`
	`635`	`+ intrinsics::frem_algebraic(self.0, rhs).into()`
`636`	`636`	`}`
`637`	`637`	`}`
`638`	`638`
`639`	`639`	`impl RemAssign<f32> for F32 {`
`640`	`640`	`#[inline(always)]`
`641`	`641`	`fn rem_assign(&mut self, rhs: f32) {`
`642`		`- unsafe { self.0 = std::intrinsics::frem_fast(self.0, rhs) }`
	`642`	`+ self.0 = intrinsics::frem_algebraic(self.0, rhs)`
	`643`	`+ }`
	`644`	`+}`
	`645`	`+`
	`646`	`+mod intrinsics {`
	`647`	`+ #[inline(always)]`
	`648`	`+ pub fn fadd_algebraic(lhs: f32, rhs: f32) -> f32 {`
	`649`	`+ std::intrinsics::fadd_algebraic(lhs, rhs)`
	`650`	`+ }`
	`651`	`+ #[inline(always)]`
	`652`	`+ pub fn fsub_algebraic(lhs: f32, rhs: f32) -> f32 {`
	`653`	`+ std::intrinsics::fsub_algebraic(lhs, rhs)`
	`654`	`+ }`
	`655`	`+ #[inline(always)]`
	`656`	`+ pub fn fmul_algebraic(lhs: f32, rhs: f32) -> f32 {`
	`657`	`+ std::intrinsics::fmul_algebraic(lhs, rhs)`
	`658`	`+ }`
	`659`	`+ #[inline(always)]`
	`660`	`+ pub fn fdiv_algebraic(lhs: f32, rhs: f32) -> f32 {`
	`661`	`+ std::intrinsics::fdiv_algebraic(lhs, rhs)`
	`662`	`+ }`
	`663`	`+ #[inline(always)]`
	`664`	`+ pub fn frem_algebraic(lhs: f32, rhs: f32) -> f32 {`
	`665`	`+ std::intrinsics::frem_algebraic(lhs, rhs)`
`643`	`666`	`}`
`644`	`667`	`}`
`645`	`668`
Original file line number	Diff line number	Diff line change
`@@ -441,14 +441,14 @@ impl Add<F16> for F16 {`
`441`	`441`
`442`	`442`	`#[inline(always)]`
`443`	`443`	`fn add(self, rhs: F16) -> F16 {`
`444`		`- unsafe { intrinsics::fadd_fast(self.0, rhs.0).into() }`
	`444`	`+ intrinsics::fadd_algebraic(self.0, rhs.0).into()`
`445`	`445`	`}`
`446`	`446`	`}`
`447`	`447`
`448`	`448`	`impl AddAssign<F16> for F16 {`
`449`	`449`	`#[inline(always)]`
`450`	`450`	`fn add_assign(&mut self, rhs: F16) {`
`451`		`- unsafe { self.0 = intrinsics::fadd_fast(self.0, rhs.0) }`
	`451`	`+ self.0 = intrinsics::fadd_algebraic(self.0, rhs.0)`
`452`	`452`	`}`
`453`	`453`	`}`
`454`	`454`
`@@ -457,14 +457,14 @@ impl Sub<F16> for F16 {`
`457`	`457`
`458`	`458`	`#[inline(always)]`
`459`	`459`	`fn sub(self, rhs: F16) -> F16 {`
`460`		`- unsafe { intrinsics::fsub_fast(self.0, rhs.0).into() }`
	`460`	`+ intrinsics::fsub_algebraic(self.0, rhs.0).into()`
`461`	`461`	`}`
`462`	`462`	`}`
`463`	`463`
`464`	`464`	`impl SubAssign<F16> for F16 {`
`465`	`465`	`#[inline(always)]`
`466`	`466`	`fn sub_assign(&mut self, rhs: F16) {`
`467`		`- unsafe { self.0 = intrinsics::fsub_fast(self.0, rhs.0) }`
	`467`	`+ self.0 = intrinsics::fsub_algebraic(self.0, rhs.0)`
`468`	`468`	`}`
`469`	`469`	`}`
`470`	`470`
`@@ -473,14 +473,14 @@ impl Mul<F16> for F16 {`
`473`	`473`
`474`	`474`	`#[inline(always)]`
`475`	`475`	`fn mul(self, rhs: F16) -> F16 {`
`476`		`- unsafe { intrinsics::fmul_fast(self.0, rhs.0).into() }`
	`476`	`+ intrinsics::fmul_algebraic(self.0, rhs.0).into()`
`477`	`477`	`}`
`478`	`478`	`}`
`479`	`479`
`480`	`480`	`impl MulAssign<F16> for F16 {`
`481`	`481`	`#[inline(always)]`
`482`	`482`	`fn mul_assign(&mut self, rhs: F16) {`
`483`		`- unsafe { self.0 = intrinsics::fmul_fast(self.0, rhs.0) }`
	`483`	`+ self.0 = intrinsics::fmul_algebraic(self.0, rhs.0)`
`484`	`484`	`}`
`485`	`485`	`}`
`486`	`486`
`@@ -489,14 +489,14 @@ impl Div<F16> for F16 {`
`489`	`489`
`490`	`490`	`#[inline(always)]`
`491`	`491`	`fn div(self, rhs: F16) -> F16 {`
`492`		`- unsafe { intrinsics::fdiv_fast(self.0, rhs.0).into() }`
	`492`	`+ intrinsics::fdiv_algebraic(self.0, rhs.0).into()`
`493`	`493`	`}`
`494`	`494`	`}`
`495`	`495`
`496`	`496`	`impl DivAssign<F16> for F16 {`
`497`	`497`	`#[inline(always)]`
`498`	`498`	`fn div_assign(&mut self, rhs: F16) {`
`499`		`- unsafe { self.0 = intrinsics::fdiv_fast(self.0, rhs.0) }`
	`499`	`+ self.0 = intrinsics::fdiv_algebraic(self.0, rhs.0)`
`500`	`500`	`}`
`501`	`501`	`}`
`502`	`502`
`@@ -505,14 +505,14 @@ impl Rem<F16> for F16 {`
`505`	`505`
`506`	`506`	`#[inline(always)]`
`507`	`507`	`fn rem(self, rhs: F16) -> F16 {`
`508`		`- unsafe { intrinsics::frem_fast(self.0, rhs.0).into() }`
	`508`	`+ intrinsics::frem_algebraic(self.0, rhs.0).into()`
`509`	`509`	`}`
`510`	`510`	`}`
`511`	`511`
`512`	`512`	`impl RemAssign<F16> for F16 {`
`513`	`513`	`#[inline(always)]`
`514`	`514`	`fn rem_assign(&mut self, rhs: F16) {`
`515`		`- unsafe { self.0 = intrinsics::frem_fast(self.0, rhs.0) }`
	`515`	`+ self.0 = intrinsics::frem_algebraic(self.0, rhs.0)`
`516`	`516`	`}`
`517`	`517`	`}`
`518`	`518`
`@@ -549,13 +549,13 @@ impl Add<f16> for F16 {`
`549`	`549`
`550`	`550`	`#[inline(always)]`
`551`	`551`	`fn add(self, rhs: f16) -> F16 {`
`552`		`- unsafe { intrinsics::fadd_fast(self.0, rhs).into() }`
	`552`	`+ intrinsics::fadd_algebraic(self.0, rhs).into()`
`553`	`553`	`}`
`554`	`554`	`}`
`555`	`555`
`556`	`556`	`impl AddAssign<f16> for F16 {`
`557`	`557`	`fn add_assign(&mut self, rhs: f16) {`
`558`		`- unsafe { self.0 = intrinsics::fadd_fast(self.0, rhs) }`
	`558`	`+ self.0 = intrinsics::fadd_algebraic(self.0, rhs)`
`559`	`559`	`}`
`560`	`560`	`}`
`561`	`561`
`@@ -564,14 +564,14 @@ impl Sub<f16> for F16 {`
`564`	`564`
`565`	`565`	`#[inline(always)]`
`566`	`566`	`fn sub(self, rhs: f16) -> F16 {`
`567`		`- unsafe { intrinsics::fsub_fast(self.0, rhs).into() }`
	`567`	`+ intrinsics::fsub_algebraic(self.0, rhs).into()`
`568`	`568`	`}`
`569`	`569`	`}`
`570`	`570`
`571`	`571`	`impl SubAssign<f16> for F16 {`
`572`	`572`	`#[inline(always)]`
`573`	`573`	`fn sub_assign(&mut self, rhs: f16) {`
`574`		`- unsafe { self.0 = intrinsics::fsub_fast(self.0, rhs) }`
	`574`	`+ self.0 = intrinsics::fsub_algebraic(self.0, rhs)`
`575`	`575`	`}`
`576`	`576`	`}`
`577`	`577`
`@@ -580,14 +580,14 @@ impl Mul<f16> for F16 {`
`580`	`580`
`581`	`581`	`#[inline(always)]`
`582`	`582`	`fn mul(self, rhs: f16) -> F16 {`
`583`		`- unsafe { intrinsics::fmul_fast(self.0, rhs).into() }`
	`583`	`+ intrinsics::fmul_algebraic(self.0, rhs).into()`
`584`	`584`	`}`
`585`	`585`	`}`
`586`	`586`
`587`	`587`	`impl MulAssign<f16> for F16 {`
`588`	`588`	`#[inline(always)]`
`589`	`589`	`fn mul_assign(&mut self, rhs: f16) {`
`590`		`- unsafe { self.0 = intrinsics::fmul_fast(self.0, rhs) }`
	`590`	`+ self.0 = intrinsics::fmul_algebraic(self.0, rhs)`
`591`	`591`	`}`
`592`	`592`	`}`
`593`	`593`
`@@ -596,14 +596,14 @@ impl Div<f16> for F16 {`
`596`	`596`
`597`	`597`	`#[inline(always)]`
`598`	`598`	`fn div(self, rhs: f16) -> F16 {`
`599`		`- unsafe { intrinsics::fdiv_fast(self.0, rhs).into() }`
	`599`	`+ intrinsics::fdiv_algebraic(self.0, rhs).into()`
`600`	`600`	`}`
`601`	`601`	`}`
`602`	`602`
`603`	`603`	`impl DivAssign<f16> for F16 {`
`604`	`604`	`#[inline(always)]`
`605`	`605`	`fn div_assign(&mut self, rhs: f16) {`
`606`		`- unsafe { self.0 = intrinsics::fdiv_fast(self.0, rhs) }`
	`606`	`+ self.0 = intrinsics::fdiv_algebraic(self.0, rhs)`
`607`	`607`	`}`
`608`	`608`	`}`
`609`	`609`
`@@ -612,33 +612,38 @@ impl Rem<f16> for F16 {`
`612`	`612`
`613`	`613`	`#[inline(always)]`
`614`	`614`	`fn rem(self, rhs: f16) -> F16 {`
`615`		`- unsafe { intrinsics::frem_fast(self.0, rhs).into() }`
	`615`	`+ intrinsics::frem_algebraic(self.0, rhs).into()`
`616`	`616`	`}`
`617`	`617`	`}`
`618`	`618`
`619`	`619`	`impl RemAssign<f16> for F16 {`
`620`	`620`	`#[inline(always)]`
`621`	`621`	`fn rem_assign(&mut self, rhs: f16) {`
`622`		`- unsafe { self.0 = intrinsics::frem_fast(self.0, rhs) }`
	`622`	`+ self.0 = intrinsics::frem_algebraic(self.0, rhs)`
`623`	`623`	`}`
`624`	`624`	`}`
`625`	`625`
`626`	`626`	`mod intrinsics {`
`627`	`627`	`use half::f16;`
`628`	`628`
`629`		`- pub unsafe fn fadd_fast(lhs: f16, rhs: f16) -> f16 {`
	`629`	`+ #[inline(always)]`
	`630`	`+ pub fn fadd_algebraic(lhs: f16, rhs: f16) -> f16 {`
`630`	`631`	`lhs + rhs`
`631`	`632`	`}`
`632`		`- pub unsafe fn fsub_fast(lhs: f16, rhs: f16) -> f16 {`
	`633`	`+ #[inline(always)]`
	`634`	`+ pub fn fsub_algebraic(lhs: f16, rhs: f16) -> f16 {`
`633`	`635`	`lhs - rhs`
`634`	`636`	`}`
`635`		`- pub unsafe fn fmul_fast(lhs: f16, rhs: f16) -> f16 {`
	`637`	`+ #[inline(always)]`
	`638`	`+ pub fn fmul_algebraic(lhs: f16, rhs: f16) -> f16 {`
`636`	`639`	`lhs * rhs`
`637`	`640`	`}`
`638`		`- pub unsafe fn fdiv_fast(lhs: f16, rhs: f16) -> f16 {`
	`641`	`+ #[inline(always)]`
	`642`	`+ pub fn fdiv_algebraic(lhs: f16, rhs: f16) -> f16 {`
`639`	`643`	`lhs / rhs`
`640`	`644`	`}`
`641`		`- pub unsafe fn frem_fast(lhs: f16, rhs: f16) -> f16 {`
	`645`	`+ #[inline(always)]`
	`646`	`+ pub fn frem_algebraic(lhs: f16, rhs: f16) -> f16 {`
`642`	`647`	`lhs % rhs`
`643`	`648`	`}`
`644`	`649`	`}`