Merge pull request #54 from bassmanitram/feature/ordered-float

Implement feature "ordered-float"

Author: Licenser

Cargo.toml

@@ -16,6 +16,7 @@ itoa = "1"
 ryu = "1"
 halfbrown = { version = "0.2", optional = true }
 float-cmp = "0.9"
+ordered-float = { version = "4", optional = true }
 hashbrown = { version = "0.14", optional = true }
 abi_stable = { version = "0.11.0", optional = true, default-features = false }
 
@@ -27,11 +28,14 @@ default = ["custom-types", "halfbrown", "runtime-detection"]
 # Support for custom types
 custom-types = []
 
-# Support for abi-stable's `StableAbi` implementation
+# Support for abi-stable's `StableAbi` implementation - INCOMPATIBLE WITH ordered-float
 c-abi = ["abi_stable"]
 
 # use runtime detection of the CPU features where possible instead of enforcing an instruction set
 runtime-detection = []
 
+# wrap floats in ordered-float - allowing them to be Eq - INCOMPATIBLE WITH c-abi
+ordered-float = ["dep:ordered-float"]
+
 # portable simd support (as of rust 1.73 nightly only)
 portable = []

src/lib.rs

@@ -23,6 +23,9 @@ compile_error!(
     the `128bit` feature, and that they have been merged by Cargo."
 );
 
+#[cfg(all(feature = "c-abi", feature = "ordered-float"))]
+compile_error!("Combining the features `c-abi` and `ordered-float` is impossible because ordered_float::OrderedFloat does not implement `StableAbi`");
+
 use std::borrow::Cow;
 use std::fmt;
 

src/node.rs

@@ -1,17 +1,24 @@
 use crate::base::{TypedValue, ValueAsScalar};
 
 use super::{fmt, ValueType};
-use float_cmp::approx_eq;
 use std::convert::TryFrom;
 use std::ops::{Index, IndexMut};
 
+#[cfg(feature = "ordered-float")]
+use ordered_float::OrderedFloat;
+
+#[cfg(not(feature = "ordered-float"))]
+use float_cmp::approx_eq;
+
 mod cmp;
 mod from;
 
 /// Static tape node
 #[derive(Debug, Clone, Copy)]
+#[cfg_attr(feature = "ordered-float", derive(Eq))]
 #[cfg_attr(feature = "c-abi", repr(C))]
 #[cfg_attr(feature = "c-abi", derive(abi_stable::StableAbi))]
+
 pub enum StaticNode {
     /// A signed 64 bit integer.
     I64(i64),
@@ -24,7 +31,11 @@ pub enum StaticNode {
     /// An unsigned 128 bit integer.
     U128(u128),
     /// A floating point value
+    #[cfg(not(feature = "ordered-float"))]
     F64(f64),
+    #[cfg(feature = "ordered-float")]
+    /// A floating point value, as an `OrderedFloat` (not allow for Eq)
+    F64(OrderedFloat<f64>),
     /// A boolean value
     Bool(bool),
     /// The null value
@@ -191,7 +202,8 @@ impl ValueAsScalar for StaticNode {
     #[must_use]
     fn as_f64(&self) -> Option<f64> {
         match self {
-            Self::F64(i) => Some(*i),
+            #[allow(clippy::useless_conversion)] // .into() required by ordered-float
+            Self::F64(i) => Some((*i).into()),
             _ => None,
         }
     }
@@ -202,7 +214,8 @@ impl ValueAsScalar for StaticNode {
     #[allow(clippy::cast_precision_loss)]
     fn cast_f64(&self) -> Option<f64> {
         match self {
-            Self::F64(i) => Some(*i),
+            #[allow(clippy::useless_conversion)] // .into() required by ordered-float
+            Self::F64(i) => Some((*i).into()),
             Self::I64(i) => Some(*i as f64),
             Self::U64(i) => Some(*i as f64),
             _ => None,
@@ -214,7 +227,7 @@ impl ValueAsScalar for StaticNode {
     #[allow(clippy::cast_precision_loss)]
     fn cast_f64(&self) -> Option<f64> {
         match self {
-            Self::F64(i) => Some(*i),
+            Self::F64(i) => Some((*i).into()),
             Self::I64(i) => Some(*i as f64),
             Self::U64(i) => Some(*i as f64),
             Self::I128(i) => Some(*i as f64),
@@ -238,7 +251,10 @@ impl fmt::Display for StaticNode {
             Self::Bool(b) => write!(f, "{b}"),
             Self::I64(n) => write!(f, "{n}"),
             Self::U64(n) => write!(f, "{n}"),
+            #[cfg(not(feature = "ordered-float"))]
             Self::F64(n) => write!(f, "{n}"),
+            #[cfg(feature = "ordered-float")]
+            Self::F64(n) => write!(f, "{}", n.0),
         }
     }
     #[cfg(feature = "128bit")]
@@ -248,7 +264,10 @@ impl fmt::Display for StaticNode {
             Self::Bool(b) => write!(f, "{b}"),
             Self::I64(n) => write!(f, "{n}"),
             Self::U64(n) => write!(f, "{n}"),
+            #[cfg(not(feature = "ordered-float"))]
             Self::F64(n) => write!(f, "{n}"),
+            #[cfg(feature = "ordered-float")]
+            Self::F64(n) => write!(f, "{}", n.0),
             Self::I128(n) => write!(f, "{n}"),
             Self::U128(n) => write!(f, "{n}"),
         }
@@ -264,7 +283,10 @@ impl PartialEq for StaticNode {
         match (self, other) {
             (Self::Null, Self::Null) => true,
             (Self::Bool(v1), Self::Bool(v2)) => v1.eq(v2),
+            #[cfg(not(feature = "ordered-float"))]
             (Self::F64(v1), Self::F64(v2)) => approx_eq!(f64, *v1, *v2),
+            #[cfg(feature = "ordered-float")]
+            (Self::F64(v1), Self::F64(v2)) => v1.eq(v2),
             (Self::U64(v1), Self::U64(v2)) => v1.eq(v2),
             (Self::I64(v1), Self::I64(v2)) => v1.eq(v2),
             (Self::U64(v1), Self::I64(v2)) if *v2 >= 0 => (*v2 as u64).eq(v1),
@@ -280,7 +302,10 @@ impl PartialEq for StaticNode {
         match (self, other) {
             (Self::Null, Self::Null) => true,
             (Self::Bool(v1), Self::Bool(v2)) => v1.eq(v2),
+            #[cfg(not(feature = "ordered-float"))]
             (Self::F64(v1), Self::F64(v2)) => approx_eq!(f64, *v1, *v2),
+            #[cfg(feature = "ordered-float")]
+            (Self::F64(v1), Self::F64(v2)) => v1.eq(v2),
             (Self::U64(v1), Self::U64(v2)) => v1.eq(v2),
             (Self::U128(v1), Self::U128(v2)) => v1.eq(v2),
             (Self::I64(v1), Self::I64(v2)) => v1.eq(v2),

src/node/from.rs

@@ -1,3 +1,6 @@
+#[cfg(feature = "ordered-float")]
+use ordered_float::OrderedFloat;
+
 use crate::StaticNode;
 
 /********* atoms **********/
@@ -110,6 +113,7 @@ impl From<usize> for StaticNode {
 }
 
 /********* f_ **********/
+#[cfg(not(feature = "ordered-float"))]
 impl From<f32> for StaticNode {
     #[inline]
     #[must_use]
@@ -118,10 +122,29 @@ impl From<f32> for StaticNode {
     }
 }
 
+#[cfg(not(feature = "ordered-float"))]
 impl From<f64> for StaticNode {
     #[inline]
     #[must_use]
     fn from(f: f64) -> Self {
         Self::F64(f)
     }
 }
+
+#[cfg(feature = "ordered-float")]
+impl From<f32> for StaticNode {
+    #[inline]
+    #[must_use]
+    fn from(f: f32) -> Self {
+        Self::F64(OrderedFloat::from(f64::from(f)))
+    }
+}
+
+#[cfg(feature = "ordered-float")]
+impl From<f64> for StaticNode {
+    #[inline]
+    #[must_use]
+    fn from(f: f64) -> Self {
+        Self::F64(OrderedFloat::from(f))
+    }
+}