NAUM-4 impl PartialOrd for Term

crates/api/CHANGELOG.md

@@ -22,6 +22,7 @@ adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 - NAUM-4: Derive `PartialOrd` for `Composition`
 - NAUM-4: `impl From<Dimension> for Composition`
 - NAUM-4: Derive `Hash` for `Property`
+- NAUM-4: `impl PartialOrd for Term`
 - Added `Unit::into_terms()` for cases where you only need the `Term`s of the `Unit`.
 - Added `unit` constant: `UNITY`
 - Added `term` constants: `UNITY`, `UNITY_ARRAY`, and `UNITY_ARRAY_REF`.

crates/api/src/term.rs

@@ -6,6 +6,7 @@ mod invert;
 mod is_compatible_with;
 pub(crate) mod num_traits;
 mod partial_eq;
+mod partial_ord;
 mod reducible;
 mod ucum_unit;
 

crates/api/src/term/partial_eq.rs

@@ -1,9 +1,7 @@
-use crate::{is_compatible_with::IsCompatibleWith, ucum_unit::UcumUnit, Term};
 use approx::ulps_eq;
 
-//-----------------------------------------------------------------------------
-// impl PartialEq
-//-----------------------------------------------------------------------------
+use crate::{is_compatible_with::IsCompatibleWith, ucum_unit::UcumUnit, Term};
+
 /// `Term`s are `PartialEq` if
 ///
 /// a) they are compatible

crates/api/src/term/partial_ord.rs

@@ -0,0 +1,69 @@
+use crate::{is_compatible_with::IsCompatibleWith, ucum_unit::UcumUnit, Term};
+
+/// `Term`s are `PartialOrd` if
+///
+/// a) they are compatible
+/// b) their `scalar()` values are comparable
+///
+/// ```rust
+/// use std::cmp::Ordering;
+/// use wise_units::{Atom, Prefix, Term};
+///
+/// let lhs = Term {
+///     factor: Some(1000),
+///     prefix: None,
+///     atom: Some(Atom::Meter),
+///     exponent: None,
+///     annotation: None
+/// };
+/// let rhs = Term {
+///     factor: None,
+///     prefix: Some(Prefix::Kilo),
+///     atom: Some(Atom::Meter),
+///     exponent: None,
+///     annotation: None
+/// };
+/// assert_eq!(lhs.partial_cmp(&rhs), Some(Ordering::Equal));
+///
+/// let lhs = Term {
+///     factor: None,
+///     prefix: None,
+///     atom: Some(Atom::Meter),
+///     exponent: None,
+///     annotation: None
+/// };
+/// let rhs = Term {
+///     factor: None,
+///     prefix: Some(Prefix::Kilo),
+///     atom: Some(Atom::Meter),
+///     exponent: None,
+///     annotation: None
+/// };
+/// assert_eq!(lhs.partial_cmp(&rhs), Some(Ordering::Less));
+///
+/// let lhs = Term {
+///     factor: None,
+///     prefix: None,
+///     atom: Some(Atom::Meter),
+///     exponent: None,
+///     annotation: None
+/// };
+/// let rhs = Term {
+///     factor: None,
+///     prefix: None,
+///     atom: Some(Atom::Gram),
+///     exponent: None,
+///     annotation: None
+/// };
+/// assert_eq!(lhs.partial_cmp(&rhs), None);
+/// ```
+///
+impl PartialOrd for Term {
+    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+        if !self.is_compatible_with(other) {
+            return None;
+        }
+
+        self.scalar().partial_cmp(&other.scalar())
+    }
+}