Merge branch 'reem:master' into master

Author: mdepta42

.github/workflows/tests.yaml

@@ -22,21 +22,17 @@ jobs:
           rustup toolchain install ${{ matrix.rust }} --profile=minimal
           rustup override set ${{ matrix.rust }}
 
-      - name: Install rustfmt + clippy
-        if: matrix.rust == 'stable'
-        run: |
-          # remove non-rustup-managed versions already present in default image
-          rm -f /home/runner/.cargo/bin/{rustfmt,cargo-fmt}
-
-          rustup toolchain install ${{ matrix.rust }} --profile=minimal --component=clippy,rustfmt
-
       - name: Check Fmt
         if: matrix.rust == 'stable'
-        run: cargo fmt --check
+        run: |
+          rustup component add rustfmt
+          cargo fmt --check
 
       - name: Check Lints (all features)
         if: matrix.rust == 'stable'
-        run: cargo clippy --tests --features ${{ env.all_features }}
+        run: |
+          rustup component add clippy
+          cargo clippy --tests --features ${{ env.all_features }}
 
       - name: Test (default features)
         run: cargo test

.travis.yml

@@ -1,6 +1,6 @@
 [package]
 name        = "ordered-float"
-version     = "5.0.0"
+version     = "5.1.0"
 authors     = [
   "Jonathan Reem <[email protected]>",
   "Matt Brubeck <[email protected]>",

Cargo.lock

@@ -24,6 +24,8 @@ use core::ops::{
 use core::str::FromStr;
 
 pub use num_traits::float::FloatCore;
+#[cfg(any(feature = "std", feature = "libm"))]
+use num_traits::real::Real;
 use num_traits::{
     AsPrimitive, Bounded, FloatConst, FromPrimitive, Num, NumCast, One, Signed, ToPrimitive, Zero,
 };
@@ -1911,7 +1913,7 @@ impl<E: fmt::Debug + Error + 'static> Error for ParseNotNanError<E> {
 impl<E: fmt::Display> fmt::Display for ParseNotNanError<E> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
-            ParseNotNanError::ParseFloatError(e) => write!(f, "Parse error: {}", e),
+            ParseNotNanError::ParseFloatError(e) => write!(f, "Parse error: {e}"),
             ParseNotNanError::IsNaN => write!(f, "NotNan parser encounter a NaN"),
         }
     }
@@ -1957,6 +1959,170 @@ impl<T: FloatCore> NumCast for NotNan<T> {
     }
 }
 
+#[cfg(any(feature = "std", feature = "libm"))]
+impl<T: Real + FloatCore> Real for NotNan<T> {
+    fn min_value() -> Self {
+        NotNan(<T as Real>::min_value())
+    }
+    fn min_positive_value() -> Self {
+        NotNan(<T as Real>::min_positive_value())
+    }
+    fn epsilon() -> Self {
+        NotNan(Real::epsilon())
+    }
+    fn max_value() -> Self {
+        NotNan(<T as Real>::max_value())
+    }
+    fn floor(self) -> Self {
+        NotNan(Real::floor(self.0))
+    }
+    fn ceil(self) -> Self {
+        NotNan(Real::ceil(self.0))
+    }
+    fn round(self) -> Self {
+        NotNan(Real::round(self.0))
+    }
+    fn trunc(self) -> Self {
+        NotNan(Real::trunc(self.0))
+    }
+    fn fract(self) -> Self {
+        NotNan(Real::fract(self.0))
+    }
+    fn abs(self) -> Self {
+        NotNan(Real::abs(self.0))
+    }
+    fn signum(self) -> Self {
+        NotNan(Real::signum(self.0))
+    }
+    fn is_sign_positive(self) -> bool {
+        Real::is_sign_positive(self.0)
+    }
+    fn is_sign_negative(self) -> bool {
+        Real::is_sign_negative(self.0)
+    }
+    fn mul_add(self, a: Self, b: Self) -> Self {
+        NotNan(self.0.mul_add(a.0, b.0))
+    }
+    fn recip(self) -> Self {
+        NotNan(Real::recip(self.0))
+    }
+    fn powi(self, n: i32) -> Self {
+        NotNan(Real::powi(self.0, n))
+    }
+    fn powf(self, n: Self) -> Self {
+        // Panics if  self < 0 and n is not an integer
+        NotNan::new(self.0.powf(n.0)).expect("Power resulted in NaN")
+    }
+    fn sqrt(self) -> Self {
+        // Panics if self < 0
+        NotNan::new(self.0.sqrt()).expect("Square root resulted in NaN")
+    }
+    fn exp(self) -> Self {
+        NotNan(self.0.exp())
+    }
+    fn exp2(self) -> Self {
+        NotNan(self.0.exp2())
+    }
+    fn ln(self) -> Self {
+        // Panics if self <= 0
+        NotNan::new(self.0.ln()).expect("Natural logarithm resulted in NaN")
+    }
+    fn log(self, base: Self) -> Self {
+        // Panics if self <= 0 or base <= 0
+        NotNan::new(self.0.log(base.0)).expect("Logarithm resulted in NaN")
+    }
+    fn log2(self) -> Self {
+        // Panics if self <= 0
+        NotNan::new(self.0.log2()).expect("Logarithm resulted in NaN")
+    }
+    fn log10(self) -> Self {
+        // Panics if self <= 0
+        NotNan::new(self.0.log10()).expect("Logarithm resulted in NaN")
+    }
+    fn to_degrees(self) -> Self {
+        NotNan(Real::to_degrees(self.0))
+    }
+    fn to_radians(self) -> Self {
+        NotNan(Real::to_radians(self.0))
+    }
+    fn max(self, other: Self) -> Self {
+        NotNan(Real::max(self.0, other.0))
+    }
+    fn min(self, other: Self) -> Self {
+        NotNan(Real::min(self.0, other.0))
+    }
+    fn abs_sub(self, other: Self) -> Self {
+        NotNan(self.0.abs_sub(other.0))
+    }
+    fn cbrt(self) -> Self {
+        NotNan(self.0.cbrt())
+    }
+    fn hypot(self, other: Self) -> Self {
+        NotNan(self.0.hypot(other.0))
+    }
+    fn sin(self) -> Self {
+        // Panics if self is +/-infinity
+        NotNan::new(self.0.sin()).expect("Sine resulted in NaN")
+    }
+    fn cos(self) -> Self {
+        // Panics if self is +/-infinity
+        NotNan::new(self.0.cos()).expect("Cosine resulted in NaN")
+    }
+    fn tan(self) -> Self {
+        // Panics if self is +/-infinity or self == pi/2 + k*pi
+        NotNan::new(self.0.tan()).expect("Tangent resulted in NaN")
+    }
+    fn asin(self) -> Self {
+        // Panics if self < -1.0 or self > 1.0
+        NotNan::new(self.0.asin()).expect("Arcsine resulted in NaN")
+    }
+    fn acos(self) -> Self {
+        // Panics if self < -1.0 or self > 1.0
+        NotNan::new(self.0.acos()).expect("Arccosine resulted in NaN")
+    }
+    fn atan(self) -> Self {
+        NotNan(self.0.atan())
+    }
+    fn atan2(self, other: Self) -> Self {
+        NotNan(self.0.atan2(other.0))
+    }
+    fn sin_cos(self) -> (Self, Self) {
+        // Panics if self is +/-infinity
+        let (a, b) = self.0.sin_cos();
+        (
+            NotNan::new(a).expect("Sine resulted in NaN"),
+            NotNan::new(b).expect("Cosine resulted in NaN"),
+        )
+    }
+    fn exp_m1(self) -> Self {
+        NotNan(self.0.exp_m1())
+    }
+    fn ln_1p(self) -> Self {
+        // Panics if self <= -1.0
+        NotNan::new(self.0.ln_1p()).expect("Natural logarithm resulted in NaN")
+    }
+    fn sinh(self) -> Self {
+        NotNan(self.0.sinh())
+    }
+    fn cosh(self) -> Self {
+        NotNan(self.0.cosh())
+    }
+    fn tanh(self) -> Self {
+        NotNan(self.0.tanh())
+    }
+    fn asinh(self) -> Self {
+        NotNan(self.0.asinh())
+    }
+    fn acosh(self) -> Self {
+        // Panics if self < 1.0
+        NotNan::new(self.0.acosh()).expect("Arccosh resulted in NaN")
+    }
+    fn atanh(self) -> Self {
+        // Panics if self < -1.0 or self > 1.0
+        NotNan::new(self.0.atanh()).expect("Arctanh resulted in NaN")
+    }
+}
+
 macro_rules! impl_float_const_method {
     ($wrapper:expr, $method:ident) => {
         #[allow(non_snake_case)]
@@ -2333,7 +2499,7 @@ mod impl_speedy {
         fn read_from<R: Reader<'a, C>>(reader: &mut R) -> Result<Self, C::Error> {
             let value: T = reader.read_value()?;
             Self::new(value).map_err(|error| {
-                speedy::Error::custom(std::format!("failed to read NotNan: {}", error)).into()
+                speedy::Error::custom(std::format!("failed to read NotNan: {error}")).into()
             })
         }