Merge pull request #464 from marvin-hansen/main

feat(deep_causality_num): Added is_nan, is_infinite, and is_finite to RealFieldd

Author: marvin-hansen

deep_causality_num/src/algebra/field_real.rs

@@ -29,6 +29,59 @@ pub trait RealField:
     /// Returns the `NaN` value.
     fn nan() -> Self;
 
+    /// Returns `true` if this value is `NaN` and false otherwise.
+    ///
+    /// ```
+    /// use deep_causality_num::Float;
+    /// use core::f64;
+    ///
+    /// let nan = f64::NAN;
+    /// let f = 7.0;
+    ///
+    /// assert!(nan.is_nan());
+    /// assert!(!f.is_nan());
+    /// ```
+    fn is_nan(self) -> bool;
+
+    /// Returns `true` if this value is positive infinity or negative infinity and
+    /// false otherwise.
+    ///
+    /// ```
+    /// use deep_causality_num::Float;
+    /// use core::f32;
+    ///
+    /// let f = 7.0f32;
+    /// let inf: f32 = Float::infinity();
+    /// let neg_inf: f32 = Float::neg_infinity();
+    /// let nan: f32 = f32::NAN;
+    ///
+    /// assert!(!f.is_infinite());
+    /// assert!(!nan.is_infinite());
+    ///
+    /// assert!(inf.is_infinite());
+    /// assert!(neg_inf.is_infinite());
+    /// ```
+    fn is_infinite(self) -> bool;
+
+    /// Returns `true` if this number is neither infinite nor `NaN`.
+    ///
+    /// ```
+    /// use deep_causality_num::Float;
+    /// use core::f32;
+    ///
+    /// let f = 7.0f32;
+    /// let inf: f32 = Float::infinity();
+    /// let neg_inf: f32 = Float::neg_infinity();
+    /// let nan: f32 = f32::NAN;
+    ///
+    /// assert!(f.is_finite());
+    ///
+    /// assert!(!nan.is_finite());
+    /// assert!(!inf.is_finite());
+    /// assert!(!neg_inf.is_finite());
+    /// ```
+    fn is_finite(self) -> bool;
+
     fn clamp(self, min: Self, max: Self) -> Self;
 
     /// Computes the principal square root of a number.
@@ -266,14 +319,21 @@ impl RealField for f32 {
         f32::NAN
     }
 
-    #[inline]
-    fn clamp(self, min: Self, max: Self) -> Self {
-        f32::clamp(self, min, max)
+    fn is_nan(self) -> bool {
+        f32::is_nan(self)
+    }
+
+    fn is_infinite(self) -> bool {
+        f32::is_infinite(self)
+    }
+
+    fn is_finite(self) -> bool {
+        f32::is_finite(self)
     }
 
     #[inline]
-    fn abs(self) -> Self {
-        self.abs()
+    fn clamp(self, min: Self, max: Self) -> Self {
+        f32::clamp(self, min, max)
     }
 
     #[inline]
@@ -285,6 +345,11 @@ impl RealField for f32 {
         return libm::sqrtf(self);
     }
 
+    #[inline]
+    fn abs(self) -> Self {
+        self.abs()
+    }
+
     #[inline]
     fn floor(self) -> Self {
         #[cfg(feature = "std")]
@@ -357,6 +422,11 @@ impl RealField for f32 {
         return libm::sinf(self);
     }
 
+    #[inline]
+    fn asin(self) -> Self {
+        f32::asin(self)
+    }
+
     #[inline]
     fn cos(self) -> Self {
         #[cfg(feature = "std")]
@@ -411,6 +481,11 @@ impl RealField for f32 {
         return libm::tanhf(self);
     }
 
+    #[inline]
+    fn atan(self) -> Self {
+        f32::atan(self)
+    }
+
     #[inline]
     fn atan2(self, other: Self) -> Self {
         #[cfg(feature = "std")]
@@ -429,20 +504,10 @@ impl RealField for f32 {
     fn e() -> Self {
         core::f32::consts::E
     }
-
     #[inline]
     fn epsilon() -> Self {
         f32::EPSILON
     }
-
-    #[inline]
-    fn atan(self) -> Self {
-        f32::atan(self)
-    }
-    #[inline]
-    fn asin(self) -> Self {
-        f32::asin(self)
-    }
 }
 
 // -----------------------------------------------------------------------------
@@ -632,4 +697,16 @@ impl RealField for f64 {
     fn asin(self) -> Self {
         f64::asin(self)
     }
+
+    fn is_nan(self) -> bool {
+        f64::is_nan(self)
+    }
+
+    fn is_infinite(self) -> bool {
+        f64::is_infinite(self)
+    }
+
+    fn is_finite(self) -> bool {
+        f64::is_finite(self)
+    }
 }

deep_causality_num/src/float_106/traits_algebra.rs

@@ -101,6 +101,18 @@ impl RealField for Float106 {
         <Self as Float>::nan()
     }
 
+    fn is_nan(self) -> bool {
+        self.hi.is_nan()
+    }
+
+    fn is_infinite(self) -> bool {
+        self.hi.is_infinite()
+    }
+
+    fn is_finite(self) -> bool {
+        self.hi.is_finite()
+    }
+
     #[inline]
     fn clamp(self, min: Self, max: Self) -> Self {
         if self < min {

deep_causality_topology/src/types/gauge/gauge_field_lattice/ops_metropolis.rs

@@ -11,7 +11,7 @@
 use crate::types::gauge::link_variable::random::RandomField;
 use crate::{GaugeGroup, LatticeCell, LatticeGaugeField, LinkVariable, TopologyError};
 use deep_causality_num::{
-    ComplexField, DivisionAlgebra, Field, Float, FromPrimitive, RealField, ToPrimitive,
+    ComplexField, DivisionAlgebra, Field, FromPrimitive, RealField, ToPrimitive,
 };
 // use deep_causality_tensor::TensorData; // Removed
 use std::fmt::Debug;
@@ -24,7 +24,7 @@ impl<
     G: GaugeGroup,
     const D: usize,
     M: Field + Copy + Default + PartialOrd + Debug + ComplexField<R> + DivisionAlgebra<R>,
-    R: RealField + FromPrimitive + ToPrimitive + Float,
+    R: RealField + FromPrimitive + ToPrimitive,
 > LatticeGaugeField<G, D, M, R>
 {
     /// Perform a single Metropolis update on a link.