Implement more numeric traits for OrderedFloat

`OrderedFloat<T>` now implements: * `Float` * `Num` * `NumCast` * `FromPrimitive` * `ToPrimitive` * `Add<T>` * `Sub<T>` * `Mul<T>` * `Div<T>` * `Rem<T>` * `Rem<Self>` * `One` Trait bounds on some existing trait impls for `OrderedFloat<T>` have been relaxed. Fixes #73.

Author: mbrubeck

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ordered-float"
-version = "2.0.1"
+version = "2.1.0"
 authors = ["Jonathan Reem <jonathan.reem@gmail.com>", "Matt Brubeck <mbrubeck@limpet.net>"]
 license = "MIT"
 description = "Wrappers for total ordering on floats"

src/lib.rs

@@ -173,39 +173,87 @@ impl<T: Float> DerefMut for OrderedFloat<T> {
 
 impl<T: Float> Eq for OrderedFloat<T> {}
 
-impl<T: Float> Add for OrderedFloat<T> {
- type Output = Self;
+impl<T: Add> Add for OrderedFloat<T> {
+ type Output = OrderedFloat<T::Output>;
 
- fn add(self, other: Self) -> Self {
+ fn add(self, other: Self) -> Self::Output {
  OrderedFloat(self.0 + other.0)
  }
 }
 
-impl<T: Float> Sub for OrderedFloat<T> {
- type Output = Self;
+impl<T: Add> Add<T> for OrderedFloat<T> {
+ type Output = OrderedFloat<T::Output>;
 
- fn sub(self, other: Self) -> Self {
+ fn add(self, other: T) -> Self::Output {
+ OrderedFloat(self.0 + other)
+ }
+}
+
+impl<T: Sub> Sub for OrderedFloat<T> {
+ type Output = OrderedFloat<T::Output>;
+
+ fn sub(self, other: Self) -> Self::Output {
  OrderedFloat(self.0 - other.0)
  }
 }
 
-impl<T: Float> Mul for OrderedFloat<T> {
- type Output = Self;
+impl<T: Sub> Sub<T> for OrderedFloat<T> {
+ type Output = OrderedFloat<T::Output>;
 
- fn mul(self, other: Self) -> Self {
+ fn sub(self, other: T) -> Self::Output {
+ OrderedFloat(self.0 - other)
+ }
+}
+
+impl<T: Mul> Mul for OrderedFloat<T> {
+ type Output = OrderedFloat<T::Output>;
+
+ fn mul(self, other: Self) -> Self::Output {
  OrderedFloat(self.0 * other.0)
  }
 }
 
-impl<T: Float> Div for OrderedFloat<T> {
- type Output = Self;
+impl<T: Mul> Mul<T> for OrderedFloat<T> {
+ type Output = OrderedFloat<T::Output>;
 
- fn div(self, other: Self) -> Self {
+ fn mul(self, other: T) -> Self::Output {
+ OrderedFloat(self.0 * other)
+ }
+}
+
+impl<T: Div> Div for OrderedFloat<T> {
+ type Output = OrderedFloat<T::Output>;
+
+ fn div(self, other: Self) -> Self::Output {
  OrderedFloat(self.0 / other.0)
  }
 }
 
-impl<T: Float> Bounded for OrderedFloat<T> {
+impl<T: Div> Div<T> for OrderedFloat<T> {
+ type Output = OrderedFloat<T::Output>;
+
+ fn div(self, other: T) -> Self::Output {
+ OrderedFloat(self.0 / other)
+ }
+}
+
+impl<T: Rem> Rem for OrderedFloat<T> {
+ type Output = OrderedFloat<T::Output>;
+
+ fn rem(self, other: Self) -> Self::Output {
+ OrderedFloat(self.0 % other.0)
+ }
+}
+
+impl<T: Rem> Rem<T> for OrderedFloat<T> {
+ type Output = OrderedFloat<T::Output>;
+
+ fn rem(self, other: T) -> Self::Output {
+ OrderedFloat(self.0 % other)
+ }
+}
+
+impl<T: Bounded> Bounded for OrderedFloat<T> {
  fn min_value() -> Self {
  OrderedFloat(T::min_value())
  }
@@ -215,7 +263,7 @@ impl<T: Float> Bounded for OrderedFloat<T> {
  }
 }
 
-impl<T: Float + FromStr> FromStr for OrderedFloat<T> {
+impl<T: FromStr> FromStr for OrderedFloat<T> {
  type Err = T::Err;
 
  /// Convert a &str to `OrderedFloat`. Returns an error if the string fails to parse.
@@ -232,20 +280,128 @@ impl<T: Float + FromStr> FromStr for OrderedFloat<T> {
  }
 }
 
-impl<T: Float> Neg for OrderedFloat<T> {
- type Output = Self;
+impl<T: Neg> Neg for OrderedFloat<T> {
+ type Output = OrderedFloat<T::Output>;
 
- fn neg(self) -> Self {
+ fn neg(self) -> Self::Output {
  OrderedFloat(-self.0)
  }
 }
 
-impl<T: Float> Zero for OrderedFloat<T> {
+impl<T: Zero> Zero for OrderedFloat<T> {
  fn zero() -> Self { OrderedFloat(T::zero()) }
 
  fn is_zero(&self) -> bool { self.0.is_zero() }
 }
 
+impl<T: One> One for OrderedFloat<T> {
+ fn one() -> Self { OrderedFloat(T::one()) }
+}
+
+impl<T: NumCast> NumCast for OrderedFloat<T> {
+ fn from<F: ToPrimitive>(n: F) -> Option<Self> {
+ T::from(n).map(OrderedFloat)
+ }
+}
+
+impl<T: FromPrimitive> FromPrimitive for OrderedFloat<T> {
+ fn from_i64(n: i64) -> Option<Self> { T::from_i64(n).map(OrderedFloat) }
+ fn from_u64(n: u64) -> Option<Self> { T::from_u64(n).map(OrderedFloat) }
+ fn from_isize(n: isize) -> Option<Self> { T::from_isize(n).map(OrderedFloat) }
+ fn from_i8(n: i8) -> Option<Self> { T::from_i8(n).map(OrderedFloat) }
+ fn from_i16(n: i16) -> Option<Self> { T::from_i16(n).map(OrderedFloat) }
+ fn from_i32(n: i32) -> Option<Self> { T::from_i32(n).map(OrderedFloat) }
+ fn from_usize(n: usize) -> Option<Self> { T::from_usize(n).map(OrderedFloat) }
+ fn from_u8(n: u8) -> Option<Self> { T::from_u8(n).map(OrderedFloat) }
+ fn from_u16(n: u16) -> Option<Self> { T::from_u16(n).map(OrderedFloat) }
+ fn from_u32(n: u32) -> Option<Self> { T::from_u32(n).map(OrderedFloat) }
+ fn from_f32(n: f32) -> Option<Self> { T::from_f32(n).map(OrderedFloat) }
+ fn from_f64(n: f64) -> Option<Self> { T::from_f64(n).map(OrderedFloat) }
+}
+
+impl<T: ToPrimitive> ToPrimitive for OrderedFloat<T> {
+ fn to_i64(&self) -> Option<i64> { self.0.to_i64() }
+ fn to_u64(&self) -> Option<u64> { self.0.to_u64() }
+ fn to_isize(&self) -> Option<isize> { self.0.to_isize() }
+ fn to_i8(&self) -> Option<i8> { self.0.to_i8() }
+ fn to_i16(&self) -> Option<i16> { self.0.to_i16() }
+ fn to_i32(&self) -> Option<i32> { self.0.to_i32() }
+ fn to_usize(&self) -> Option<usize> { self.0.to_usize() }
+ fn to_u8(&self) -> Option<u8> { self.0.to_u8() }
+ fn to_u16(&self) -> Option<u16> { self.0.to_u16() }
+ fn to_u32(&self) -> Option<u32> { self.0.to_u32() }
+ fn to_f32(&self) -> Option<f32> { self.0.to_f32() }
+ fn to_f64(&self) -> Option<f64> { self.0.to_f64() }
+}
+
+impl<T: Float> Float for OrderedFloat<T> {
+ fn nan() -> Self { OrderedFloat(T::nan()) }
+ fn infinity() -> Self { OrderedFloat(T::infinity()) }
+ fn neg_infinity() -> Self { OrderedFloat(T::neg_infinity()) }
+ fn neg_zero() -> Self { OrderedFloat(T::neg_zero()) }
+ fn min_value() -> Self { OrderedFloat(T::min_value()) }
+ fn min_positive_value() -> Self { OrderedFloat(T::min_positive_value()) }
+ fn max_value() -> Self { OrderedFloat(T::max_value()) }
+ fn is_nan(self) -> bool { self.0.is_nan() }
+ fn is_infinite(self) -> bool { self.0.is_infinite() }
+ fn is_finite(self) -> bool { self.0.is_finite() }
+ fn is_normal(self) -> bool { self.0.is_normal() }
+ fn classify(self) -> std::num::FpCategory { self.0.classify() }
+ fn floor(self) -> Self { OrderedFloat(self.0.floor()) }
+ fn ceil(self) -> Self { OrderedFloat(self.0.ceil()) }
+ fn round(self) -> Self { OrderedFloat(self.0.round()) }
+ fn trunc(self) -> Self { OrderedFloat(self.0.trunc()) }
+ fn fract(self) -> Self { OrderedFloat(self.0.fract()) }
+ fn abs(self) -> Self { OrderedFloat(self.0.abs()) }
+ fn signum(self) -> Self { OrderedFloat(self.0.signum()) }
+ fn is_sign_positive(self) -> bool { self.0.is_sign_positive() }
+ fn is_sign_negative(self) -> bool { self.0.is_sign_negative() }
+ fn mul_add(self, a: Self, b: Self) -> Self { OrderedFloat(self.0.mul_add(a.0, b.0)) }
+ fn recip(self) -> Self { OrderedFloat(self.0.recip()) }
+ fn powi(self, n: i32) -> Self { OrderedFloat(self.0.powi(n)) }
+ fn powf(self, n: Self) -> Self { OrderedFloat(self.0.powf(n.0)) }
+ fn sqrt(self) -> Self { OrderedFloat(self.0.sqrt()) }
+ fn exp(self) -> Self { OrderedFloat(self.0.exp()) }
+ fn exp2(self) -> Self { OrderedFloat(self.0.exp2()) }
+ fn ln(self) -> Self { OrderedFloat(self.0.ln()) }
+ fn log(self, base: Self) -> Self { OrderedFloat(self.0.log(base.0)) }
+ fn log2(self) -> Self { OrderedFloat(self.0.log2()) }
+ fn log10(self) -> Self { OrderedFloat(self.0.log10()) }
+ fn max(self, other: Self) -> Self { OrderedFloat(self.0.max(other.0)) }
+ fn min(self, other: Self) -> Self { OrderedFloat(self.0.min(other.0)) }
+ fn abs_sub(self, other: Self) -> Self { OrderedFloat(self.0.abs_sub(other.0)) }
+ fn cbrt(self) -> Self { OrderedFloat(self.0.cbrt()) }
+ fn hypot(self, other: Self) -> Self { OrderedFloat(self.0.hypot(other.0)) }
+ fn sin(self) -> Self { OrderedFloat(self.0.sin()) }
+ fn cos(self) -> Self { OrderedFloat(self.0.cos()) }
+ fn tan(self) -> Self { OrderedFloat(self.0.tan()) }
+ fn asin(self) -> Self { OrderedFloat(self.0.asin()) }
+ fn acos(self) -> Self { OrderedFloat(self.0.acos()) }
+ fn atan(self) -> Self { OrderedFloat(self.0.atan()) }
+ fn atan2(self, other: Self) -> Self { OrderedFloat(self.0.atan2(other.0)) }
+ fn sin_cos(self) -> (Self, Self) {
+ let (a, b) = self.0.sin_cos();
+ (OrderedFloat(a), OrderedFloat(b))
+ }
+ fn exp_m1(self) -> Self { OrderedFloat(self.0.exp_m1()) }
+ fn ln_1p(self) -> Self { OrderedFloat(self.0.ln_1p()) }
+ fn sinh(self) -> Self { OrderedFloat(self.0.sinh()) }
+ fn cosh(self) -> Self { OrderedFloat(self.0.cosh()) }
+ fn tanh(self) -> Self { OrderedFloat(self.0.tanh()) }
+ fn asinh(self) -> Self { OrderedFloat(self.0.asinh()) }
+ fn acosh(self) -> Self { OrderedFloat(self.0.acosh()) }
+ fn atanh(self) -> Self { OrderedFloat(self.0.atanh()) }
+ fn integer_decode(self) -> (u64, i16, i8) { self.0.integer_decode() }
+}
+
+
+impl<T: Float + Num> Num for OrderedFloat<T> {
+ type FromStrRadixErr = T::FromStrRadixErr;
+ fn from_str_radix(str: &str, radix: u32) -> Result<Self, Self::FromStrRadixErr> {
+ T::from_str_radix(str, radix).map(OrderedFloat)
+ }
+}
+
 /// A wrapper around Floats providing an implementation of Ord and Hash.
 ///
 /// A NaN value cannot be stored in this type.