unitforge 0.5.6__tar.gz → 0.5.7__tar.gz

{unitforge-0.5.6 → unitforge-0.5.7}/Cargo.lock

@@ -351,7 +351,7 @@ checksum = "5a5f39404a5da50712a4c1eecf25e90dd62b613502b7e925fd4e4d19b5c96512"
 
 [[package]]
 name = "unitforge"
-version = "0.5.6"
+version = "0.5.7"
 dependencies = [
  "ndarray",
  "num-traits",
@@ -367,7 +367,7 @@ dependencies = [
 
 [[package]]
 name = "unitforge_macros"
-version = "0.5.6"
+version = "0.5.7"
 dependencies = [
  "regex",
 ]

{unitforge-0.5.6 → unitforge-0.5.7}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "unitforge"
-version = "0.5.6"
+version = "0.5.7"
 edition = "2021"
 authors = ["Dr.Q team <info@askdrq.com>", "Henrik Stromberg <henrik@askdrq.com>"]
 description = "A library for unit and quantity consistent computations in Rust"
@@ -20,7 +20,7 @@ pyo3 = { version = "0.28.3", features = ["extension-module", "auto-initialize",
 numpy = { version = "0.28.0", optional = true }
 strum = { version = "0.28.0", optional = true }
 strum_macros = { version = "0.28.0", optional = true }
-unitforge_macros = { version = "0.5.6", path = "unitforge_macros" }
+unitforge_macros = { version = "0.5.7", path = "unitforge_macros" }
 
 [features]
 default = []

{unitforge-0.5.6 → unitforge-0.5.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: unitforge
-Version: 0.5.6
+Version: 0.5.7
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Rust
 Classifier: License :: OSI Approved :: MIT License

{unitforge-0.5.6 → unitforge-0.5.7}/python/unitforge/__init__.pyi

@@ -1707,6 +1707,45 @@ class InverseStress:
     def __str__(self) -> str: ...
     def __rtruediv__(self, lhs: float) -> "Stress": ...
 
+class InverseTemperatureUnit:
+    _K: ClassVar["InverseTemperatureUnit"]
+    _mK: ClassVar["InverseTemperatureUnit"]
+
+class InverseTemperature:
+    def __init__(self, value: float, unit: "InverseTemperatureUnit") -> None: ...
+    @classmethod
+    def zero(cls: Type["InverseTemperature"]) -> "InverseTemperature": ...
+    def to(self, unit: "InverseTemperatureUnit") -> float: ...
+    def close_abs(self, other: "InverseTemperature", threshold: "InverseTemperature") -> bool: ...
+    def close_rel(self, other: "InverseTemperature", threshold: float) -> bool: ...
+    def __neg__(self) -> "InverseTemperature": ...
+    def __abs__(self) -> "InverseTemperature": ...
+    def __add__(self, rhs: "InverseTemperature") -> "InverseTemperature": ...
+    def __sub__(self, rhs: "InverseTemperature") -> "InverseTemperature": ...
+    @overload
+    def __mul__(self, rhs: float) -> "InverseTemperature": ...
+    @overload
+    def __mul__(self, rhs: Vector3) -> Vector3: ...
+    @overload
+    def __mul__(self, rhs: "Temperature") -> "Strain": ...
+    @overload
+    def __mul__(self, rhs: Any) -> Any: ...
+    @overload
+    def __truediv__(self, rhs: float) -> "InverseTemperature": ...
+    @overload
+    def __truediv__(self, rhs: "InverseTemperature") -> float: ...
+    @overload
+    def __truediv__(self, rhs: Any) -> Any: ...
+    @overload
+    def __mod__(self, rhs: float) -> "InverseTemperature": ...
+    @overload
+    def __mod__(self, rhs: "InverseTemperature") -> float: ...
+    @overload
+    def __mod__(self, rhs: Any) -> Any: ...
+    def __rmul__(self, rhs: float) -> "InverseTemperature": ...
+    def __repr__(self) -> str: ...
+    def __str__(self) -> str: ...
+
 class MassUnit:
     mg: ClassVar["MassUnit"]
     g: ClassVar["MassUnit"]
@@ -2074,14 +2113,22 @@ class Strain:
     @overload
     def __truediv__(self, rhs: float) -> "Strain": ...
     @overload
+    def __truediv__(self, rhs: "InverseTemperature") -> "Temperature": ...
+    @overload
     def __truediv__(self, rhs: "Strain") -> float: ...
     @overload
+    def __truediv__(self, rhs: "Temperature") -> "InverseTemperature": ...
+    @overload
     def __truediv__(self, rhs: Any) -> Any: ...
     @overload
     def __mod__(self, rhs: float) -> "Strain": ...
     @overload
+    def __mod__(self, rhs: "InverseTemperature") -> "Temperature": ...
+    @overload
     def __mod__(self, rhs: "Strain") -> float: ...
     @overload
+    def __mod__(self, rhs: "Temperature") -> "InverseTemperature": ...
+    @overload
     def __mod__(self, rhs: Any) -> Any: ...
     def __rmul__(self, rhs: float) -> "Strain": ...
     def __repr__(self) -> str: ...
@@ -2520,7 +2567,8 @@ class StressSquared:
 class TemperatureUnit:
     K: ClassVar["TemperatureUnit"]
     mK: ClassVar["TemperatureUnit"]
-    kK: ClassVar["TemperatureUnit"]
+    C: ClassVar["TemperatureUnit"]
+    F: ClassVar["TemperatureUnit"]
 
 class Temperature:
     def __init__(self, value: float, unit: "TemperatureUnit") -> None: ...
@@ -2542,6 +2590,8 @@ class Temperature:
     @overload
     def __mul__(self, rhs: "DensityRate") -> "DensityTemperatureRate": ...
     @overload
+    def __mul__(self, rhs: "InverseTemperature") -> "Strain": ...
+    @overload
     def __mul__(self, rhs: "SpecificGasConstant") -> "VelocitySquared": ...
     @overload
     def __mul__(self, rhs: "StressPerTemperature") -> "Stress": ...

{unitforge-0.5.6 → unitforge-0.5.7}/src/impl_macros.rs

@@ -1,6 +1,18 @@
 #[macro_export]
 macro_rules! impl_quantity {
     ($type:ident, $unit:ident, $display_units:expr) => {
+        $crate::impl_quantity!(
+            $type,
+            $unit,
+            $display_units,
+            $crate::internal::zero_offset_const
+        );
+    };
+    // `$offset_fn` converts a unit variant to the additive term (in base SI
+    // units) needed by affine units such as Celsius/Fahrenheit, where
+    // `base_value = value * scale + offset`. It defaults to always-zero above,
+    // so every purely multiplicative quantity is unaffected.
+    ($type:ident, $unit:ident, $display_units:expr, $offset_fn:path) => {
         use core::cmp::Ordering;
         use core::fmt;
         use core::ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Neg, Rem, Sub, SubAssign};
@@ -136,6 +148,16 @@ macro_rules! impl_quantity {
         impl $type {
             pub const fn new(value: f64, unit: $unit) -> Self {
                 let (unit_multiplier, unit_power) = unit.base_per_x_const();
+                // Affine units fold their offset in here: shifting `value` by
+                // `offset / scale` before the existing pure-scale math below
+                // yields `value * scale + offset` in base SI units. A no-op
+                // (adds 0.0) for every purely multiplicative unit.
+                let value = value
+                    + $offset_fn(unit)
+                        / $crate::internal::quantity_parts_to_value_const(
+                            unit_multiplier,
+                            unit_power,
+                        );
                 #[cfg(not(any(feature = "storage-f64", feature = "storage-f32")))]
                 {
                     let (multiplier, power) =
@@ -288,19 +310,31 @@ macro_rules! impl_quantity {
             }
 
             fn to(&self, unit: Self::Unit) -> f64 {
+                let offset = $offset_fn(unit);
                 #[cfg(not(any(feature = "storage-f64", feature = "storage-f32")))]
                 {
-                    if self.multiplier == 0.0 {
-                        return 0.0;
+                    if offset == 0.0 {
+                        if self.multiplier == 0.0 {
+                            return 0.0;
+                        }
+                        let (unit_multiplier, unit_power) = unit.base_per_x();
+                        return self.multiplier / unit_multiplier
+                            * $crate::internal::pow10_delta(self.power, unit_power);
                     }
+                    // Affine units (non-zero offset) go through `as_f64()`
+                    // instead of the mantissa/power fast path above, since
+                    // subtracting `offset` needs the plain base-SI value.
                     let (unit_multiplier, unit_power) = unit.base_per_x();
-                    self.multiplier / unit_multiplier
-                        * $crate::internal::pow10_delta(self.power, unit_power)
+                    (self.as_f64() - offset)
+                        / $crate::internal::quantity_parts_to_value_const(
+                            unit_multiplier,
+                            unit_power,
+                        )
                 }
                 #[cfg(any(feature = "storage-f64", feature = "storage-f32"))]
                 {
                     let (unit_multiplier, unit_power) = unit.base_per_x();
-                    self.as_f64()
+                    (self.as_f64() - offset)
                         / $crate::internal::quantity_parts_to_value(unit_multiplier, unit_power)
                 }
             }

{unitforge-0.5.6 → unitforge-0.5.7}/src/internal.rs

@@ -7,6 +7,13 @@ const SQRT_10: f64 = 3.162_277_660_168_379;
 #[cfg(not(any(feature = "storage-f64", feature = "storage-f32")))]
 const INV_SQRT_10: f64 = 0.31622776601683794;
 
+/// Default `PhysicsUnit` offset hook used by `impl_quantity!` for purely
+/// multiplicative units. Affine units (e.g. temperature's Celsius/Fahrenheit)
+/// supply their own `const fn(Unit) -> f64` instead.
+pub const fn zero_offset_const<U: Copy>(_unit: U) -> f64 {
+    0.0
+}
+
 const fn clamp_power_const(power: i64) -> i32 {
     if power < -(MAX_ABS_QUANTITY_POWER as i64) {
         -MAX_ABS_QUANTITY_POWER

{unitforge-0.5.6 → unitforge-0.5.7}/src/lib.rs

@@ -135,6 +135,8 @@ pub mod quantities {
     pub use stress_squared::*;
     pub mod temperature;
     pub use temperature::*;
+    pub mod inverse_temperature;
+    pub use inverse_temperature::*;
     pub mod time;
     pub use time::*;
     pub mod universal_gas_constant;

unitforge-0.5.7/src/quantities/inverse_temperature.rs

@@ -0,0 +1,39 @@
+use crate::impl_macros::macros::*;
+
+#[cfg_attr(feature = "strum", derive(EnumIter))]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[derive(Copy, Clone, PartialEq, Debug, Hash, Eq)]
+#[cfg_attr(feature = "pyo3", pyclass(eq, eq_int, from_py_object))]
+pub enum InverseTemperatureUnit {
+    _K,
+    _mK,
+}
+
+impl InverseTemperatureUnit {
+    pub const fn base_per_x_const(self) -> (f64, i32) {
+        match self {
+            InverseTemperatureUnit::_K => (1., 0),
+            InverseTemperatureUnit::_mK => (1., 3),
+        }
+    }
+}
+
+impl PhysicsUnit for InverseTemperatureUnit {
+    fn name(&self) -> &str {
+        match &self {
+            InverseTemperatureUnit::_K => "1/K",
+            InverseTemperatureUnit::_mK => "1/mK",
+        }
+    }
+
+    fn base_per_x(&self) -> (f64, i32) {
+        (*self).base_per_x_const()
+    }
+}
+
+impl_quantity!(
+    InverseTemperature,
+    InverseTemperatureUnit,
+    [InverseTemperatureUnit::_K]
+);
+impl_div_with_self_to_f64!(InverseTemperature);

unitforge-0.5.7/src/quantities/temperature.rs

@@ -0,0 +1,59 @@
+use crate::impl_macros::macros::*;
+
+#[cfg_attr(feature = "strum", derive(EnumIter))]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[derive(Copy, Clone, PartialEq, Debug, Hash, Eq)]
+#[cfg_attr(feature = "pyo3", pyclass(eq, eq_int, from_py_object))]
+pub enum TemperatureUnit {
+    K,
+    mK,
+    C,
+    F,
+}
+
+impl TemperatureUnit {
+    /// Scale only, in the sense of `kelvin = value * multiplier * 10^power + base_offset_const()`.
+    /// Celsius shares Kelvin's scale; Fahrenheit's degree is 5/9 of a Kelvin.
+    pub const fn base_per_x_const(self) -> (f64, i32) {
+        match self {
+            TemperatureUnit::K => (1., 0),
+            TemperatureUnit::mK => (1., -3),
+            TemperatureUnit::C => (1., 0),
+            TemperatureUnit::F => (5. / 9., 0),
+        }
+    }
+
+    /// Additive term (kelvin) applied on top of `base_per_x_const`'s scaling,
+    /// i.e. `kelvin = value * scale + base_offset_const()`. Zero for every
+    /// linear unit; only Celsius/Fahrenheit are affine.
+    pub const fn base_offset_const(self) -> f64 {
+        match self {
+            TemperatureUnit::K | TemperatureUnit::mK => 0.0,
+            TemperatureUnit::C => 273.15,
+            TemperatureUnit::F => 273.15 - 32. * 5. / 9.,
+        }
+    }
+}
+
+impl PhysicsUnit for TemperatureUnit {
+    fn name(&self) -> &str {
+        match &self {
+            TemperatureUnit::K => "K",
+            TemperatureUnit::mK => "mK",
+            TemperatureUnit::C => "°C",
+            TemperatureUnit::F => "°F",
+        }
+    }
+
+    fn base_per_x(&self) -> (f64, i32) {
+        (*self).base_per_x_const()
+    }
+}
+
+impl_quantity!(
+    Temperature,
+    TemperatureUnit,
+    [TemperatureUnit::K],
+    TemperatureUnit::base_offset_const
+);
+impl_div_with_self_to_f64!(Temperature);

{unitforge-0.5.6 → unitforge-0.5.7}/src/relations.rs

@@ -72,6 +72,7 @@ impl_mul_relation_with_other!(DensityRate, Temperature, DensityTemperatureRate);
 impl_mul_relation_with_other!(SpecificGasConstant, DensityTemperatureRate, StressRate);
 impl_mul_relation_with_other!(DensityRate, SpecificGasConstant, StressRatePerTemperature);
 impl_mul_relation_with_other!(StressRatePerTemperature, Temperature, StressRate);
+impl_mul_relation_with_other!(InverseTemperature, Temperature, Strain);
 impl_mul!(InverseDistance, Distance, f64);
 impl_mul!(InverseAngle, Angle, f64);
 impl_mul!(InverseStress, Stress, f64);

{unitforge-0.5.6 → unitforge-0.5.7}/tests/quantities.rs

@@ -262,6 +262,62 @@ mod test_thermo_and_rates {
         ));
     }
 
+    #[test]
+    fn temperature_converts_affine_celsius_and_fahrenheit_units() {
+        let boiling = Temperature::new(100.0, TemperatureUnit::C);
+        assert!(crate::approx_eq(
+            boiling.to(TemperatureUnit::K),
+            373.15,
+            1e-9
+        ));
+        assert!(crate::approx_eq(
+            boiling.to(TemperatureUnit::F),
+            212.0,
+            1e-9
+        ));
+
+        let freezing = Temperature::new(32.0, TemperatureUnit::F);
+        assert!(crate::approx_eq(freezing.to(TemperatureUnit::C), 0.0, 1e-9));
+        assert!(crate::approx_eq(
+            freezing.to(TemperatureUnit::K),
+            273.15,
+            1e-9
+        ));
+
+        let absolute_zero = Temperature::new(-273.15, TemperatureUnit::C);
+        assert!(crate::approx_eq(
+            absolute_zero.to(TemperatureUnit::K),
+            0.0,
+            1e-9
+        ));
+
+        let minus_forty = Temperature::new(-40.0, TemperatureUnit::C);
+        assert!(crate::approx_eq(
+            minus_forty.to(TemperatureUnit::F),
+            -40.0,
+            1e-9
+        ));
+
+        // Arithmetic stays defined purely in Kelvin, unaffected by the unit
+        // used at construction time.
+        let diff = boiling - freezing;
+        assert!(crate::approx_eq(diff.to(TemperatureUnit::K), 100.0, 1e-9));
+    }
+
+    #[test]
+    fn inverse_temperature_converts_units_and_relates_to_temperature() {
+        let expansion_coefficient = InverseTemperature::new(2.0, InverseTemperatureUnit::_mK);
+        assert!(crate::approx_eq(
+            expansion_coefficient.to(InverseTemperatureUnit::_K),
+            2000.0,
+            1e-9
+        ));
+
+        let temperature = Temperature::new(0.5, TemperatureUnit::mK);
+        let strain = expansion_coefficient * temperature;
+        assert!(crate::approx_eq(strain.to(StrainUnit::m_m), 1.0, 1e-9));
+    }
+
     #[test]
     fn molar_mass_converts_common_units() {
         let molar_mass = MolarMass::new(28.97, MolarMassUnit::g_mol);

{unitforge-0.5.6 → unitforge-0.5.7}/unitforge_macros/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "unitforge_macros"
-version = "0.5.6"
+version = "0.5.7"
 edition = "2021"
 authors = ["Dr.Q team <info@askdrq.com>", "Henrik Stromberg <henrik@askdrq.com>"]
 description = "Proc macros for generating units, quantities, and Python bindings in unitforge"

unitforge-0.5.6/src/quantities/temperature.rs

@@ -1,38 +0,0 @@
-use crate::impl_macros::macros::*;
-
-#[cfg_attr(feature = "strum", derive(EnumIter))]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-#[derive(Copy, Clone, PartialEq, Debug, Hash, Eq)]
-#[cfg_attr(feature = "pyo3", pyclass(eq, eq_int, from_py_object))]
-pub enum TemperatureUnit {
-    K,
-    mK,
-    kK,
-}
-
-impl TemperatureUnit {
-    pub const fn base_per_x_const(self) -> (f64, i32) {
-        match self {
-            TemperatureUnit::K => (1., 0),
-            TemperatureUnit::mK => (1., -3),
-            TemperatureUnit::kK => (1., 3),
-        }
-    }
-}
-
-impl PhysicsUnit for TemperatureUnit {
-    fn name(&self) -> &str {
-        match &self {
-            TemperatureUnit::K => "K",
-            TemperatureUnit::mK => "mK",
-            TemperatureUnit::kK => "kK",
-        }
-    }
-
-    fn base_per_x(&self) -> (f64, i32) {
-        (*self).base_per_x_const()
-    }
-}
-
-impl_quantity!(Temperature, TemperatureUnit, [TemperatureUnit::K]);
-impl_div_with_self_to_f64!(Temperature);