Implement a number of quality of life improvements for working with quantities of dual numbers (#88)

Author: prehner

CHANGELOG.md

@@ -6,6 +6,16 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.10.4] - 2025-06-02
+### Added
+- Implemented `Display` for `Dimensionless<T>`. [#88](https://github.com/itt-ustutt/quantity/pull/88)
+- Implemented `Debug` for `Angle<T>`. [#88](https://github.com/itt-ustutt/quantity/pull/88)
+- Added  `Quantity<T, U>::inv`. [#88](https://github.com/itt-ustutt/quantity/pull/88)
+
+### Changed
+- Generalized implementation of `Quantity<T, U>::abs` to every type with `T: Signed`. [#88](https://github.com/itt-ustutt/quantity/pull/88)
+- Generalized implementation of `Quantity::from_vec` and `Quantity::linspace`. [#88](https://github.com/itt-ustutt/quantity/pull/88)
+
 ## [0.10.3] - 2025-05-07
 ### Added
 - Implemented `Deref` for `Dimensionless<T>`. [#86](https://github.com/itt-ustutt/quantity/pull/86)

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "quantity"
-version = "0.10.3"
+version = "0.10.4"
 authors = [
     "Philipp Rehner <prehner@ethz.ch>",
     "Gernot Bauer <bauer@itt.uni-stuttgart.de>",
@@ -25,6 +25,7 @@ members = ["si-units", "example/extend_quantity"]
 
 [dependencies]
 typenum = "1.17"
+num-traits = "0.2"
 document-features = "0.2"
 ## Use N-dimensional arrays from the [ndarray] crate as value of a quantity.
 ndarray = { version = "0.16", optional = true }

src/array.rs

@@ -6,10 +6,11 @@ use ndarray::{
 };
 use std::iter::FromIterator;
 use std::marker::PhantomData;
+use std::ops::{Add, Mul, Sub};
 
-impl<U> Quantity<Array1<f64>, U> {
+impl<T: Copy, U> Quantity<Array1<T>, U> {
     /// Create a one-dimensional array from a vector of scalar quantities.
-    pub fn from_vec(v: Vec<Quantity<f64, U>>) -> Self {
+    pub fn from_vec(v: Vec<Quantity<T, U>>) -> Self {
         Self(v.iter().map(|e| e.0).collect(), PhantomData)
     }
 
@@ -23,10 +24,21 @@ impl<U> Quantity<Array1<f64>, U> {
     /// let x = Length::linspace(1.0 * METER, 3.0 * METER, 5);
     /// assert_relative_eq!(x, &(arr1(&[1.0, 1.5, 2.0, 2.5, 3.0]) * METER));
     /// ```
-    pub fn linspace(start: Quantity<f64, U>, end: Quantity<f64, U>, n: usize) -> Self {
-        Self(Array1::linspace(start.0, end.0, n), PhantomData)
+    pub fn linspace(start: Quantity<T, U>, end: Quantity<T, U>, n: usize) -> Self
+    where
+        T: Mul<f64, Output = T> + Sub<Output = T> + Add<Output = T>,
+    {
+        Self(
+            Array1::linspace(0.0, 1.0, n)
+                .into_iter()
+                .map(|x| (end.0 - start.0) * x + start.0)
+                .collect(),
+            PhantomData,
+        )
     }
+}
 
+impl<U> Quantity<Array1<f64>, U> {
     /// Create a one-dimensional array with n logarithmically spaced elements from `start` to `end` (inclusive).
     ///
     /// # Example

src/fmt.rs

@@ -36,6 +36,12 @@ impl<
     }
 }
 
+impl<Inner: fmt::Display> fmt::Display for Quantity<Inner, _Dimensionless> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        self.0.fmt(f)
+    }
+}
+
 #[cfg(feature = "pyo3")]
 pub(crate) trait PrintUnit {
     const UNIT: &'static str;
@@ -186,7 +192,15 @@ static PREFIX_SYMBOLS: LazyLock<HashMap<i8, &'static str>> = LazyLock::new(|| {
 
 impl fmt::Display for Angle {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{}°", self.0.to_degrees())
+        self.0.to_degrees().fmt(f)?;
+        write!(f, "°")
+    }
+}
+
+impl<T: fmt::Debug> fmt::Debug for Angle<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        self.0.fmt(f)?;
+        write!(f, " rad")
     }
 }
 
@@ -231,4 +245,20 @@ mod tests {
         assert_eq!(format!("{}", 0.0 * KELVIN), "0 K");
         assert_eq!(format!("{:.2}", 0.0 * PASCAL), "0.00  Pa");
     }
+
+    #[test]
+    fn test_fmt_dimensionless() {
+        assert_eq!(format!("{}", BAR / PASCAL), format!("{}", 1e5));
+        assert_eq!(
+            format!("{}", RGAS / (JOULE / (MOL * KELVIN))),
+            format!("{}", 8.31446261815324)
+        );
+    }
+
+    #[test]
+    fn test_fmt_angle() {
+        assert_eq!(format!("{}", 90.0 * DEGREES), "90°");
+        assert_eq!(format!("{:.3?}", 45.0 * DEGREES), "0.785 rad");
+        assert_eq!(format!("{:.2}", 0.5 * RADIANS), "28.65°");
+    }
 }

src/ops.rs

@@ -3,6 +3,7 @@ use super::Quantity;
 use approx::{AbsDiffEq, RelativeEq};
 #[cfg(feature = "ndarray")]
 use ndarray::{Array, ArrayBase, Data, DataMut, DataOwned, Dimension};
+use num_traits::{Inv, Signed};
 use std::marker::PhantomData;
 use std::ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Neg, Sub, SubAssign};
 use typenum::{Diff, Integer, Negate, Prod, Quot, Sum, P2, P3};
@@ -401,7 +402,9 @@ impl<U> Quantity<f64, U> {
     {
         Quantity(self.0.powf(1.0 / R::I32 as f64), PhantomData)
     }
+}
 
+impl<T, U> Quantity<T, U> {
     /// Return the absolute value of `self`.
     ///
     /// # Example
@@ -410,10 +413,31 @@ impl<U> Quantity<f64, U> {
     /// # use approx::assert_relative_eq;
     /// let t = -50.0 * KELVIN;
     /// assert_relative_eq!(t.abs(), &(50.0 * KELVIN));
-    pub fn abs(self) -> Self {
+    pub fn abs(self) -> Self
+    where
+        T: Signed,
+    {
         Self(self.0.abs(), PhantomData)
     }
 
+    /// Return the multiplicative inverse of `self`.
+    ///
+    /// # Example
+    /// ```
+    /// # use quantity::PASCAL;
+    /// # use approx::assert_relative_eq;
+    /// let t = 5.0 * PASCAL;
+    /// assert_relative_eq!(t.inv(), &(0.2/PASCAL));
+    pub fn inv(self) -> Quantity<T, Negate<U>>
+    where
+        T: Inv<Output = T>,
+        U: Neg,
+    {
+        Quantity(self.0.inv(), PhantomData)
+    }
+}
+
+impl<U> Quantity<f64, U> {
     /// Returns a number that represents the sign of `self`.
     ///
     /// - `1.0` if the number is positive, `+0.0` or `INFINITY`