add sin_pi_f16, cos_pi_f16, and sin_cos_pi_f16

[vector-math.git] / src / f16.rs

diff --git a/src/f16.rs b/src/f16.rs
index 5bc1119443466e949640876b70e54c6bf15f24d6..e9541b416f1546e5f7195baa01f3a528f7e6bdf5 100644 (file)
--- a/src/f16.rs
+++ b/src/f16.rs
@@ -2,7 +2,10 @@ use core::ops::{
     Add, AddAssign, Div, DivAssign, Mul, MulAssign, Neg, Rem, RemAssign, Sub, SubAssign,
 };
 
-use crate::traits::{ConvertTo, Float};
+use crate::{
+    scalar::Value,
+    traits::{ConvertFrom, ConvertTo, Float},
+};
 
 #[cfg(feature = "f16")]
 use half::f16 as F16Impl;
@@ -64,9 +67,9 @@ macro_rules! impl_f16_from {
                 }
             }
 
-            impl ConvertTo<F16> for $ty {
-                fn to(self) -> F16 {
-                    self.into()
+            impl ConvertFrom<$ty> for F16 {
+                fn cvt_from(v: $ty) -> F16 {
+                    v.into()
                 }
             }
         )*
@@ -82,9 +85,9 @@ macro_rules! impl_from_f16 {
                 }
             }
 
-            impl ConvertTo<$ty> for F16 {
-                fn to(self) -> $ty {
-                    self.into()
+            impl ConvertFrom<F16> for $ty {
+                fn cvt_from(v: F16) -> Self {
+                    v.into()
                 }
             }
         )*
@@ -98,12 +101,12 @@ impl_from_f16![f32, f64,];
 macro_rules! impl_int_to_f16 {
     ($($int:ident),*) => {
         $(
-            impl ConvertTo<F16> for $int {
-                fn to(self) -> F16 {
+            impl ConvertFrom<$int> for F16 {
+                fn cvt_from(v: $int) -> Self {
                     // f32 has enough mantissa bits such that f16 overflows to
                     // infinity before f32 stops being able to properly
                     // represent integer values, making the below conversion correct.
-                    (self as f32).to()
+                    F16::cvt_from(v as f32)
                 }
             }
         )*
@@ -113,9 +116,9 @@ macro_rules! impl_int_to_f16 {
 macro_rules! impl_f16_to_int {
     ($($int:ident),*) => {
         $(
-            impl ConvertTo<$int> for F16 {
-                fn to(self) -> $int {
-                    f32::from(self) as $int
+            impl ConvertFrom<F16> for $int {
+                fn cvt_from(v: F16) -> Self {
+                    f32::from(v) as $int
                 }
             }
         )*
@@ -125,15 +128,15 @@ macro_rules! impl_f16_to_int {
 impl_int_to_f16![i16, u16, i32, u32, i64, u64, i128, u128];
 impl_f16_to_int![i8, u8, i16, u16, i32, u32, i64, u64, i128, u128];
 
-impl ConvertTo<F16> for f32 {
-    fn to(self) -> F16 {
-        f16_impl!(F16(F16Impl::from_f32(self)), [])
+impl ConvertFrom<f32> for F16 {
+    fn cvt_from(v: f32) -> Self {
+        f16_impl!(F16(F16Impl::from_f32(v)), [v])
     }
 }
 
-impl ConvertTo<F16> for f64 {
-    fn to(self) -> F16 {
-        f16_impl!(F16(F16Impl::from_f64(self)), [])
+impl ConvertFrom<f64> for F16 {
+    fn cvt_from(v: f64) -> Self {
+        f16_impl!(F16(F16Impl::from_f64(v)), [v])
     }
 }
 
@@ -173,60 +176,104 @@ impl_bin_op_using_f32! {
     Rem, rem, RemAssign, rem_assign;
 }
 
-impl Float for F16 {
+impl F16 {
+    pub fn from_bits(v: u16) -> Self {
+        #[cfg(feature = "f16")]
+        return F16(F16Impl::from_bits(v));
+        #[cfg(not(feature = "f16"))]
+        return F16(v);
+    }
+    pub fn to_bits(self) -> u16 {
+        #[cfg(feature = "f16")]
+        return self.0.to_bits();
+        #[cfg(not(feature = "f16"))]
+        return self.0;
+    }
+    pub fn abs(self) -> Self {
+        f16_impl!(Self::from_bits(self.to_bits() & 0x7FFF), [])
+    }
+    pub fn trunc(self) -> Self {
+        f32::from(self).trunc().to()
+    }
+
+    pub fn ceil(self) -> Self {
+        f32::from(self).ceil().to()
+    }
+
+    pub fn floor(self) -> Self {
+        f32::from(self).floor().to()
+    }
+
+    pub fn round(self) -> Self {
+        f32::from(self).round().to()
+    }
+
+    #[cfg(feature = "fma")]
+    pub fn fma(self, a: Self, b: Self) -> Self {
+        (f64::from(self) * f64::from(a) + f64::from(b)).to()
+    }
+
+    pub fn is_nan(self) -> bool {
+        f16_impl!(self.0.is_nan(), [])
+    }
+
+    pub fn is_infinite(self) -> bool {
+        f16_impl!(self.0.is_infinite(), [])
+    }
+
+    pub fn is_finite(self) -> bool {
+        f16_impl!(self.0.is_finite(), [])
+    }
+}
+
+impl Float for Value<F16> {
     type FloatEncoding = F16;
-    type BitsType = u16;
-    type SignedBitsType = i16;
+    type BitsType = Value<u16>;
+    type SignedBitsType = Value<i16>;
 
     fn abs(self) -> Self {
-        f16_impl!(Self::from_bits(self.to_bits() & 0x7FFF), [])
+        Value(self.0.abs())
     }
 
     fn trunc(self) -> Self {
-        f32::from(self).trunc().to()
+        Value(self.0.trunc())
     }
 
     fn ceil(self) -> Self {
-        f32::from(self).ceil().to()
+        Value(self.0.ceil())
     }
 
     fn floor(self) -> Self {
-        f32::from(self).floor().to()
+        Value(self.0.floor())
     }
 
     fn round(self) -> Self {
-        f32::from(self).round().to()
+        Value(self.0.round())
     }
 
     #[cfg(feature = "fma")]
     fn fma(self, a: Self, b: Self) -> Self {
-        (f64::from(self) * f64::from(a) + f64::from(b)).to()
+        Value(self.0.fma(a.0, b.0))
     }
 
     fn is_nan(self) -> Self::Bool {
-        f16_impl!(self.0.is_nan(), [])
+        Value(self.0.is_nan())
     }
 
     fn is_infinite(self) -> Self::Bool {
-        f16_impl!(self.0.is_infinite(), [])
+        Value(self.0.is_infinite())
     }
 
     fn is_finite(self) -> Self::Bool {
-        f16_impl!(self.0.is_finite(), [])
+        Value(self.0.is_finite())
     }
 
     fn from_bits(v: Self::BitsType) -> Self {
-        #[cfg(feature = "f16")]
-        return F16(F16Impl::from_bits(v));
-        #[cfg(not(feature = "f16"))]
-        return F16(v);
+        Value(F16::from_bits(v.0))
     }
 
     fn to_bits(self) -> Self::BitsType {
-        #[cfg(feature = "f16")]
-        return self.0.to_bits();
-        #[cfg(not(feature = "f16"))]
-        return self.0;
+        Value(self.0.to_bits())
     }
 }