add f128

Author: usamoi

build.rs

@@ -10,4 +10,6 @@ fn main() {
     // FIXME: use autocfg to emit it
     println!("cargo:rustc-cfg=has_f16");
     println!("cargo:rustc-check-cfg=cfg(has_f16)");
+    println!("cargo:rustc-cfg=has_f128");
+    println!("cargo:rustc-check-cfg=cfg(has_f128)");
 }

src/bounds.rs

@@ -1,3 +1,5 @@
+#[cfg(has_f128)]
+use core::f128;
 #[cfg(has_f16)]
 use core::f16;
 use core::num::Wrapping;
@@ -130,6 +132,8 @@ impl<T: Bounded> Bounded for Wrapping<T> {
 bounded_impl!(f16, f16::MIN, f16::MAX);
 bounded_impl!(f32, f32::MIN, f32::MAX);
 bounded_impl!(f64, f64::MIN, f64::MAX);
+#[cfg(has_f128)]
+bounded_impl!(f128, f128::MIN, f128::MAX);
 
 macro_rules! for_each_tuple_ {
     ( $m:ident !! ) => (

src/cast.rs

@@ -1,3 +1,5 @@
+#[cfg(has_f128)]
+use core::f128;
 #[cfg(has_f16)]
 use core::f16;
 use core::mem::size_of;
@@ -138,6 +140,15 @@ pub trait ToPrimitive {
             None => self.to_u64().as_ref().and_then(ToPrimitive::to_f64),
         }
     }
+
+    /// Converts the value of `self` to an `f128`. Overflows may map to positive
+    /// or negative inifinity, otherwise `None` is returned if the value cannot
+    /// be represented by an `f128`.
+    #[cfg(has_f128)]
+    #[inline]
+    fn to_f128(&self) -> Option<f128> {
+        self.to_f64().as_ref().and_then(ToPrimitive::to_f128)
+    }
 }
 
 macro_rules! impl_to_primitive_int_to_int {
@@ -205,6 +216,11 @@ macro_rules! impl_to_primitive_int {
             fn to_f64(&self) -> Option<f64> {
                 Some(*self as f64)
             }
+            #[cfg(has_f128)]
+            #[inline]
+            fn to_f128(&self) -> Option<f128> {
+                Some(*self as f128)
+            }
         }
     };
 }
@@ -280,6 +296,11 @@ macro_rules! impl_to_primitive_uint {
             fn to_f64(&self) -> Option<f64> {
                 Some(*self as f64)
             }
+            #[cfg(has_f128)]
+            #[inline]
+            fn to_f128(&self) -> Option<f128> {
+                Some(*self as f128)
+            }
         }
     };
 }
@@ -442,6 +463,8 @@ macro_rules! impl_to_primitive_float {
                 fn to_f16 -> f16;
                 fn to_f32 -> f32;
                 fn to_f64 -> f64;
+                #[cfg(has_f128)]
+                fn to_f128 -> f128;
             }
         }
     };
@@ -451,6 +474,8 @@ macro_rules! impl_to_primitive_float {
 impl_to_primitive_float!(f16);
 impl_to_primitive_float!(f32);
 impl_to_primitive_float!(f64);
+#[cfg(has_f128)]
+impl_to_primitive_float!(f128);
 
 /// A generic trait for converting a number to a value.
 ///
@@ -575,6 +600,14 @@ pub trait FromPrimitive: Sized {
             None => n.to_u64().and_then(FromPrimitive::from_u64),
         }
     }
+
+    /// Converts a `f128` to return an optional value of this type. If the
+    /// value cannot be represented by this type, then `None` is returned.
+    #[cfg(has_f128)]
+    #[inline]
+    fn from_f128(n: f128) -> Option<Self> {
+        FromPrimitive::from_f64(n as f64)
+    }
 }
 
 macro_rules! impl_from_primitive {
@@ -643,6 +676,11 @@ macro_rules! impl_from_primitive {
             fn from_f64(n: f64) -> Option<$T> {
                 n.$to_ty()
             }
+            #[cfg(has_f128)]
+            #[inline]
+            fn from_f128(n: f128) -> Option<$T> {
+                n.$to_ty()
+            }
         }
     };
 }
@@ -663,6 +701,8 @@ impl_from_primitive!(u128, to_u128);
 impl_from_primitive!(f16, to_f16);
 impl_from_primitive!(f32, to_f32);
 impl_from_primitive!(f64, to_f64);
+#[cfg(has_f128)]
+impl_from_primitive!(f128, to_f128);
 
 macro_rules! impl_from_primitive_nonzero {
     ($T:ty, $to_ty:ident) => {
@@ -772,6 +812,8 @@ impl<T: ToPrimitive> ToPrimitive for Wrapping<T> {
         fn to_f16 -> f16;
         fn to_f32 -> f32;
         fn to_f64 -> f64;
+        #[cfg(has_f128)]
+        fn to_f128 -> f128;
     }
 }
 
@@ -805,6 +847,8 @@ impl<T: FromPrimitive> FromPrimitive for Wrapping<T> {
         fn from_f16(f16);
         fn from_f32(f32);
         fn from_f64(f64);
+        #[cfg(has_f128)]
+        fn from_f128(f128);
     }
 }
 
@@ -867,6 +911,8 @@ impl_num_cast!(isize, to_isize);
 impl_num_cast!(f16, to_f16);
 impl_num_cast!(f32, to_f32);
 impl_num_cast!(f64, to_f64);
+#[cfg(has_f128)]
+impl_num_cast!(f128, to_f128);
 
 macro_rules! impl_num_cast_nonzero {
     ($T:ty, $conv:ident) => {
@@ -950,21 +996,23 @@ macro_rules! impl_as_primitive {
     };
 }
 
-impl_as_primitive!(u8 => { char, #[cfg(has_f16)] f16, f32, f64 });
-impl_as_primitive!(i8 => { #[cfg(has_f16)] f16, f32, f64 });
-impl_as_primitive!(u16 => { #[cfg(has_f16)] f16, f32, f64 });
-impl_as_primitive!(i16 => { #[cfg(has_f16)] f16, f32, f64 });
-impl_as_primitive!(u32 => { #[cfg(has_f16)] f16, f32, f64 });
-impl_as_primitive!(i32 => { #[cfg(has_f16)] f16, f32, f64 });
-impl_as_primitive!(u64 => { #[cfg(has_f16)] f16, f32, f64 });
-impl_as_primitive!(i64 => { #[cfg(has_f16)] f16, f32, f64 });
-impl_as_primitive!(u128 => { #[cfg(has_f16)] f16, f32, f64 });
-impl_as_primitive!(i128 => { #[cfg(has_f16)] f16, f32, f64 });
-impl_as_primitive!(usize => { #[cfg(has_f16)] f16, f32, f64 });
-impl_as_primitive!(isize => { #[cfg(has_f16)] f16, f32, f64 });
+impl_as_primitive!(u8 => { char, #[cfg(has_f16)] f16, f32, f64, #[cfg(has_f128)] f128 });
+impl_as_primitive!(i8 => { #[cfg(has_f16)] f16, f32, f64, #[cfg(has_f128)] f128 });
+impl_as_primitive!(u16 => { #[cfg(has_f16)] f16, f32, f64, #[cfg(has_f128)] f128 });
+impl_as_primitive!(i16 => { #[cfg(has_f16)] f16, f32, f64, #[cfg(has_f128)] f128 });
+impl_as_primitive!(u32 => { #[cfg(has_f16)] f16, f32, f64, #[cfg(has_f128)] f128 });
+impl_as_primitive!(i32 => { #[cfg(has_f16)] f16, f32, f64, #[cfg(has_f128)] f128 });
+impl_as_primitive!(u64 => { #[cfg(has_f16)] f16, f32, f64, #[cfg(has_f128)] f128 });
+impl_as_primitive!(i64 => { #[cfg(has_f16)] f16, f32, f64, #[cfg(has_f128)] f128 });
+impl_as_primitive!(u128 => { #[cfg(has_f16)] f16, f32, f64, #[cfg(has_f128)] f128 });
+impl_as_primitive!(i128 => { #[cfg(has_f16)] f16, f32, f64, #[cfg(has_f128)] f128 });
+impl_as_primitive!(usize => { #[cfg(has_f16)] f16, f32, f64, #[cfg(has_f128)] f128 });
+impl_as_primitive!(isize => { #[cfg(has_f16)] f16, f32, f64, #[cfg(has_f128)] f128 });
 #[cfg(has_f16)]
-impl_as_primitive!(f16 => { f16, f32, f64 });
-impl_as_primitive!(f32 => { #[cfg(has_f16)] f16, f32, f64 });
-impl_as_primitive!(f64 => { #[cfg(has_f16)] f16, f32, f64 });
+impl_as_primitive!(f16 => { f16, f32, f64, #[cfg(has_f128)] f128 });
+impl_as_primitive!(f32 => { #[cfg(has_f16)] f16, f32, f64, #[cfg(has_f128)] f128 });
+impl_as_primitive!(f64 => { #[cfg(has_f16)] f16, f32, f64, #[cfg(has_f128)] f128 });
+#[cfg(has_f128)]
+impl_as_primitive!(f128 => { #[cfg(has_f16)] f16, f32, f64, f128 });
 impl_as_primitive!(char => { char });
 impl_as_primitive!(bool => {});