unitforge 0.5.2__tar.gz → 0.5.3__tar.gz

{unitforge-0.5.2 → unitforge-0.5.3}/Cargo.lock

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

{unitforge-0.5.2 → unitforge-0.5.3}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "unitforge"
-version = "0.5.2"
+version = "0.5.3"
 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.2", path = "unitforge_macros" }
+unitforge_macros = { version = "0.5.3", path = "unitforge_macros" }
 
 [features]
 default = []

{unitforge-0.5.2 → unitforge-0.5.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: unitforge
-Version: 0.5.2
+Version: 0.5.3
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Rust
 Classifier: License :: OSI Approved :: MIT License
@@ -9,7 +9,9 @@ Classifier: Topic :: Scientific/Engineering :: Physics
 Requires-Dist: numpy>=2.2.0
 Summary: A library for unit and quantity consistent computations in Rust
 Keywords: units,quantities,simulation,physics
+Author: Dr.Q team <info@askdrq.com>, Henrik Stromberg <henrik@askdrq.com>
 Author-email: "Dr.Q team" <info@askdrq.com>, Henrik Stromberg <henrik@askdrq.com>
+License: MIT
 Requires-Python: >=3.7
 Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
 Project-URL: Repository, https://gitlab.com/henrikjstromberg/unitforge

{unitforge-0.5.2 → unitforge-0.5.3}/scripts/generate_python_stubs.py

@@ -372,6 +372,18 @@ def render_quantity_stub(
         lines.append(f'    def __truediv__(self, rhs: "{rhs}") -> {res}: ...')
     lines.append("    @overload")
     lines.append("    def __truediv__(self, rhs: Any) -> Any: ...")
+    lines.append("    @overload")
+    lines.append(f'    def __mod__(self, rhs: float) -> "{q}": ...')
+    for rhs in sorted(div_ops):
+        if rhs not in quantity_names:
+            continue
+        res = _format_result_annotation(div_ops[rhs], quantity_names)
+        if res is None:
+            continue
+        lines.append("    @overload")
+        lines.append(f'    def __mod__(self, rhs: "{rhs}") -> {res}: ...')
+    lines.append("    @overload")
+    lines.append("    def __mod__(self, rhs: Any) -> Any: ...")
     lines.append(f'    def __rmul__(self, rhs: float) -> "{q}": ...')
     lines.append("    def __repr__(self) -> str: ...")
     lines.append("    def __str__(self) -> str: ...")

{unitforge-0.5.2 → unitforge-0.5.3}/src/errors.rs

@@ -88,6 +88,7 @@ pub enum QuantityOperationError {
     SubError,
     MulError,
     DivError,
+    ModError,
     PowError,
     SqrtError,
     ComparisonError,
@@ -102,6 +103,7 @@ impl fmt::Display for QuantityOperationError {
             QuantityOperationError::SubError => write!(f, "Subtraction operation failed"),
             QuantityOperationError::MulError => write!(f, "Multiplication operation failed"),
             QuantityOperationError::DivError => write!(f, "Division operation failed"),
+            QuantityOperationError::ModError => write!(f, "Modulo operation failed"),
             QuantityOperationError::PowError => write!(f, "Power operation failed"),
             QuantityOperationError::SqrtError => write!(f, "Sqrt operation failed"),
             QuantityOperationError::ComparisonError => write!(f, "Comparison operation failed"),

{unitforge-0.5.2 → unitforge-0.5.3}/src/impl_macros.rs

@@ -3,7 +3,7 @@ macro_rules! impl_quantity {
     ($type:ident, $unit:ident, $display_units:expr) => {
         use core::cmp::Ordering;
         use core::fmt;
-        use core::ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Neg, Sub, SubAssign};
+        use core::ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Neg, Rem, Sub, SubAssign};
         #[cfg(feature = "ndarray")]
         use ndarray::{Array1, Array2, ArrayView1, ArrayView2};
         use num_traits::FromPrimitive;
@@ -434,6 +434,22 @@ macro_rules! impl_quantity {
                 }
             }
 
+            fn __mod__(lhs: PyRef<Self>, rhs: Py<PyAny>) -> PyResult<Py<PyAny>> {
+                let py = lhs.py();
+                let rhs_ref = rhs.bind(py);
+                let lhs_ref = lhs.into_pyobject(py)?;
+                let rhs_quantity = Quantity::from_py_any(rhs_ref)
+                    .map_err(|e| PyTypeError::new_err(e.to_string()))?;
+                let lhs_quantity = Quantity::from_py_any(&lhs_ref)
+                    .map_err(|e| PyTypeError::new_err(e.to_string()))?;
+                match lhs_quantity % rhs_quantity {
+                    Ok(value) => Ok(value.to_pyobject(py)?),
+                    Err(_) => Err(PyTypeError::new_err(
+                        "Modulo of given objects is not possible.",
+                    )),
+                }
+            }
+
             fn __rmul__(&self, rhs: f64) -> PyResult<Self> {
                 Ok(*self * rhs)
             }
@@ -645,6 +661,32 @@ macro_rules! impl_quantity {
             }
         }
 
+        impl Rem<f64> for $type {
+            type Output = Self;
+
+            fn rem(self, rhs: f64) -> Self::Output {
+                #[cfg(not(any(feature = "storage-f64", feature = "storage-f32")))]
+                {
+                    let (rhs_multiplier, rhs_power) = Self::split_value(rhs);
+                    let (multiplier, power) = $crate::internal::quantity_parts_rem(
+                        self.multiplier,
+                        self.power,
+                        rhs_multiplier,
+                        rhs_power,
+                    );
+                    Self::from_parts(multiplier, power)
+                }
+                #[cfg(feature = "storage-f64")]
+                {
+                    Self::from_base_value(self.value % rhs)
+                }
+                #[cfg(feature = "storage-f32")]
+                {
+                    Self::from_base_value(f64::from(self.value % rhs as f32))
+                }
+            }
+        }
+
         impl Mul<f64> for $type {
             type Output = Self;
 
@@ -1079,6 +1121,31 @@ macro_rules! impl_div_with_self_to_f64 {
                 }
             }
         }
+
+        impl core::ops::Rem<$lhs> for $lhs {
+            type Output = f64;
+
+            fn rem(self, rhs: Self) -> Self::Output {
+                #[cfg(not(any(feature = "storage-f64", feature = "storage-f32")))]
+                {
+                    let (multiplier, power) = $crate::internal::quantity_parts_rem(
+                        self.multiplier,
+                        self.power,
+                        rhs.multiplier,
+                        rhs.power,
+                    );
+                    $crate::internal::quantity_parts_to_value(multiplier, power)
+                }
+                #[cfg(feature = "storage-f64")]
+                {
+                    self.value % rhs.value
+                }
+                #[cfg(feature = "storage-f32")]
+                {
+                    f64::from(self.value % rhs.value)
+                }
+            }
+        }
     };
 }
 
@@ -1341,6 +1408,33 @@ macro_rules! impl_div {
             }
         }
 
+        impl core::ops::Rem<$rhs> for $lhs {
+            type Output = $result;
+
+            fn rem(self, rhs: $rhs) -> Self::Output {
+                #[cfg(not(any(feature = "storage-f64", feature = "storage-f32")))]
+                {
+                    let (multiplier, power) = $crate::internal::quantity_parts_rem(
+                        self.multiplier,
+                        self.power,
+                        rhs.multiplier,
+                        rhs.power,
+                    );
+                    <$result>::from_exponential(multiplier, power)
+                }
+                #[cfg(feature = "storage-f64")]
+                {
+                    <$result as $crate::PhysicsQuantity>::from_raw(self.value % rhs.value)
+                }
+                #[cfg(feature = "storage-f32")]
+                {
+                    <$result as $crate::PhysicsQuantity>::from_raw(f64::from(
+                        self.value % rhs.value,
+                    ))
+                }
+            }
+        }
+
         #[cfg(feature = "ndarray")]
         impl DivArray1<$rhs> for Array1<$lhs> {
             type Output = Array1<$result>;

{unitforge-0.5.2 → unitforge-0.5.3}/src/internal.rs

@@ -242,6 +242,66 @@ pub fn pow10_delta(lhs: i32, rhs: i32) -> f64 {
     pow10(saturating_power_sub(lhs, rhs))
 }
 
+#[cfg(not(any(feature = "storage-f64", feature = "storage-f32")))]
+pub fn quantity_parts_rem(
+    lhs_multiplier: f64,
+    lhs_power: i32,
+    rhs_multiplier: f64,
+    rhs_power: i32,
+) -> (f64, i32) {
+    if lhs_multiplier.is_nan() || rhs_multiplier.is_nan() {
+        return (f64::NAN, 0);
+    }
+
+    if rhs_multiplier == 0.0 {
+        return (f64::NAN, 0);
+    }
+
+    if lhs_multiplier == 0.0 {
+        return (0.0, 0);
+    }
+
+    if lhs_multiplier.is_infinite() {
+        return (f64::NAN, 0);
+    }
+
+    if rhs_multiplier.is_infinite() {
+        return canonicalize_quantity_parts(lhs_multiplier, lhs_power);
+    }
+
+    let lhs_abs = lhs_multiplier.abs();
+    let rhs_abs = rhs_multiplier.abs();
+    let common_power = lhs_power.max(rhs_power);
+    let scaled_lhs = lhs_abs * pow10_delta(lhs_power, common_power);
+    let scaled_rhs = rhs_abs * pow10_delta(rhs_power, common_power);
+
+    if scaled_lhs < scaled_rhs {
+        return canonicalize_quantity_parts(lhs_multiplier, lhs_power);
+    }
+
+    if scaled_lhs == scaled_rhs {
+        return (0.0, 0);
+    }
+
+    let sign = if lhs_multiplier.is_sign_negative() {
+        -1.0
+    } else {
+        1.0
+    };
+    let delta = i64::from(lhs_power) - i64::from(rhs_power);
+    let rem_multiplier = if delta >= 0 {
+        let mut rem = lhs_abs % rhs_abs;
+        for _ in 0..delta {
+            rem = (rem * 10.0) % rhs_abs;
+        }
+        rem
+    } else {
+        lhs_abs * pow10_delta(lhs_power, rhs_power) % rhs_abs
+    };
+
+    canonicalize_quantity_parts(sign * rem_multiplier, rhs_power)
+}
+
 #[cfg(feature = "no_std")]
 pub fn sqrt(value: f64) -> f64 {
     if value < 0.0 {

{unitforge-0.5.2 → unitforge-0.5.3}/src/lib.rs

@@ -73,6 +73,12 @@ pub mod quantities {
     pub use compliance::*;
     pub mod density;
     pub use density::*;
+    pub mod density_rate;
+    pub use density_rate::*;
+    pub mod density_temperature;
+    pub use density_temperature::*;
+    pub mod density_temperature_rate;
+    pub use density_temperature_rate::*;
     pub mod distance;
     pub use distance::*;
     pub mod force;
@@ -115,6 +121,12 @@ pub mod quantities {
     pub use strain::*;
     pub mod stress;
     pub use stress::*;
+    pub mod stress_per_temperature;
+    pub use stress_per_temperature::*;
+    pub mod stress_rate;
+    pub use stress_rate::*;
+    pub mod stress_rate_per_temperature;
+    pub use stress_rate_per_temperature::*;
     pub mod stress_squared;
     pub use stress_squared::*;
     pub mod temperature;

unitforge-0.5.3/src/quantities/density_rate.rs

@@ -0,0 +1,32 @@
+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 DensityRateUnit {
+    kg_mcbs,
+}
+
+impl DensityRateUnit {
+    pub const fn base_per_x_const(self) -> (f64, i32) {
+        match self {
+            DensityRateUnit::kg_mcbs => (1., 0),
+        }
+    }
+}
+
+impl PhysicsUnit for DensityRateUnit {
+    fn name(&self) -> &str {
+        match &self {
+            DensityRateUnit::kg_mcbs => "kg/(m³*s)",
+        }
+    }
+
+    fn base_per_x(&self) -> (f64, i32) {
+        (*self).base_per_x_const()
+    }
+}
+
+impl_quantity!(DensityRate, DensityRateUnit, [DensityRateUnit::kg_mcbs]);
+impl_div_with_self_to_f64!(DensityRate);

unitforge-0.5.3/src/quantities/density_temperature.rs

@@ -0,0 +1,36 @@
+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 DensityTemperatureUnit {
+    kgK_mcb,
+}
+
+impl DensityTemperatureUnit {
+    pub const fn base_per_x_const(self) -> (f64, i32) {
+        match self {
+            DensityTemperatureUnit::kgK_mcb => (1., 0),
+        }
+    }
+}
+
+impl PhysicsUnit for DensityTemperatureUnit {
+    fn name(&self) -> &str {
+        match &self {
+            DensityTemperatureUnit::kgK_mcb => "kg*K/m³",
+        }
+    }
+
+    fn base_per_x(&self) -> (f64, i32) {
+        (*self).base_per_x_const()
+    }
+}
+
+impl_quantity!(
+    DensityTemperature,
+    DensityTemperatureUnit,
+    [DensityTemperatureUnit::kgK_mcb]
+);
+impl_div_with_self_to_f64!(DensityTemperature);

unitforge-0.5.3/src/quantities/density_temperature_rate.rs

@@ -0,0 +1,36 @@
+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 DensityTemperatureRateUnit {
+    kgK_mcbs,
+}
+
+impl DensityTemperatureRateUnit {
+    pub const fn base_per_x_const(self) -> (f64, i32) {
+        match self {
+            DensityTemperatureRateUnit::kgK_mcbs => (1., 0),
+        }
+    }
+}
+
+impl PhysicsUnit for DensityTemperatureRateUnit {
+    fn name(&self) -> &str {
+        match &self {
+            DensityTemperatureRateUnit::kgK_mcbs => "kg*K/(m³*s)",
+        }
+    }
+
+    fn base_per_x(&self) -> (f64, i32) {
+        (*self).base_per_x_const()
+    }
+}
+
+impl_quantity!(
+    DensityTemperatureRate,
+    DensityTemperatureRateUnit,
+    [DensityTemperatureRateUnit::kgK_mcbs]
+);
+impl_div_with_self_to_f64!(DensityTemperatureRate);

unitforge-0.5.3/src/quantities/pressure_rate.rs

@@ -0,0 +1,4 @@
+use crate::impl_macros::macros::*;
+use crate::{StressRate, StressRateUnit};
+
+make_alias!(StressRate, StressRateUnit, PressureRate, PressureRateUnit);

unitforge-0.5.3/src/quantities/stress_per_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 StressPerTemperatureUnit {
+    Pa_K,
+    MPa_K,
+}
+
+impl StressPerTemperatureUnit {
+    pub const fn base_per_x_const(self) -> (f64, i32) {
+        match self {
+            StressPerTemperatureUnit::Pa_K => (1., 0),
+            StressPerTemperatureUnit::MPa_K => (1., 6),
+        }
+    }
+}
+
+impl PhysicsUnit for StressPerTemperatureUnit {
+    fn name(&self) -> &str {
+        match &self {
+            StressPerTemperatureUnit::Pa_K => "Pa/K",
+            StressPerTemperatureUnit::MPa_K => "MPa/K",
+        }
+    }
+
+    fn base_per_x(&self) -> (f64, i32) {
+        (*self).base_per_x_const()
+    }
+}
+
+impl_quantity!(
+    StressPerTemperature,
+    StressPerTemperatureUnit,
+    [StressPerTemperatureUnit::Pa_K]
+);
+impl_div_with_self_to_f64!(StressPerTemperature);

unitforge-0.5.3/src/quantities/stress_rate.rs

@@ -0,0 +1,50 @@
+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 StressRateUnit {
+    Pa_s,
+    kPa_s,
+    MPa_s,
+    GPa_s,
+    bar_s,
+    psi_s,
+    bar_min,
+}
+
+impl StressRateUnit {
+    pub const fn base_per_x_const(self) -> (f64, i32) {
+        match self {
+            StressRateUnit::Pa_s => (1., 0),
+            StressRateUnit::kPa_s => (1., 3),
+            StressRateUnit::MPa_s => (1., 6),
+            StressRateUnit::GPa_s => (1., 9),
+            StressRateUnit::bar_s => (1., 5),
+            StressRateUnit::psi_s => (6.895, 3),
+            StressRateUnit::bar_min => (1.0 / 60.0, 5),
+        }
+    }
+}
+
+impl PhysicsUnit for StressRateUnit {
+    fn name(&self) -> &str {
+        match &self {
+            StressRateUnit::Pa_s => "Pa/s",
+            StressRateUnit::kPa_s => "kPa/s",
+            StressRateUnit::MPa_s => "MPa/s",
+            StressRateUnit::GPa_s => "GPa/s",
+            StressRateUnit::bar_s => "bar/s",
+            StressRateUnit::psi_s => "psi/s",
+            StressRateUnit::bar_min => "bar/min",
+        }
+    }
+
+    fn base_per_x(&self) -> (f64, i32) {
+        (*self).base_per_x_const()
+    }
+}
+
+impl_quantity!(StressRate, StressRateUnit, [StressRateUnit::MPa_s]);
+impl_div_with_self_to_f64!(StressRate);

unitforge-0.5.3/src/quantities/stress_rate_per_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 StressRatePerTemperatureUnit {
+    Pa_sK,
+    MPa_sK,
+}
+
+impl StressRatePerTemperatureUnit {
+    pub const fn base_per_x_const(self) -> (f64, i32) {
+        match self {
+            StressRatePerTemperatureUnit::Pa_sK => (1., 0),
+            StressRatePerTemperatureUnit::MPa_sK => (1., 6),
+        }
+    }
+}
+
+impl PhysicsUnit for StressRatePerTemperatureUnit {
+    fn name(&self) -> &str {
+        match &self {
+            StressRatePerTemperatureUnit::Pa_sK => "Pa/(s*K)",
+            StressRatePerTemperatureUnit::MPa_sK => "MPa/(s*K)",
+        }
+    }
+
+    fn base_per_x(&self) -> (f64, i32) {
+        (*self).base_per_x_const()
+    }
+}
+
+impl_quantity!(
+    StressRatePerTemperature,
+    StressRatePerTemperatureUnit,
+    [StressRatePerTemperatureUnit::Pa_sK]
+);
+impl_div_with_self_to_f64!(StressRatePerTemperature);

{unitforge-0.5.2 → unitforge-0.5.3}/src/quantities.template.rs

@@ -1,7 +1,7 @@
 use core::cmp::Ordering;
 use core::fmt;
 use core::fmt::{Display, Formatter};
-use core::ops::{Add, Div, Mul, Neg, Sub};
+use core::ops::{Add, Div, Mul, Neg, Rem, Sub};
 #[cfg(feature = "pyo3")]
 use pyo3::{Bound, PyAny, prelude::*};
 
@@ -107,6 +107,18 @@ impl Div for Quantity {
     }
 }
 
+impl Rem for Quantity {
+    type Output = crate::QuantityOperationResult<Quantity>;
+    fn rem(self, other: Quantity) -> crate::QuantityOperationResult<Quantity> {
+        use Quantity::*;
+        match (self, other) {
+            (FloatQuantity(v_lhs), FloatQuantity(v_rhs)) => Ok(FloatQuantity(v_lhs % v_rhs)),
+            // __MOD_MATCHES__
+            _ => Err(crate::QuantityOperationError::ModError)
+        }
+    }
+}
+
 impl Add for Quantity {
     type Output = crate::QuantityOperationResult<Quantity>;
     fn add(self, other: Quantity) -> crate::QuantityOperationResult<Quantity> {

{unitforge-0.5.2 → unitforge-0.5.3}/src/relations.rs

@@ -43,7 +43,10 @@ impl_mul_relation_with_other!(ForcePerVolume, Area, Stiffness);
 impl_mul_relation_with_other!(ForcePerVolume, Distance, Stress);
 impl_mul_relation_with_other!(InverseDistance, Stress, ForcePerVolume);
 impl_mul_relation_with_other!(InverseDistance, ForceDistance, Force);
-impl_mul_relation_with_other!(PressureRate, Time, Stress);
+impl_mul_relation_with_other!(StressRate, Time, Stress);
+impl_mul_relation_with_other!(Stress, Frequency, StressRate);
+impl_mul_relation_with_other!(InverseStress, StressRate, Frequency);
+impl_mul_relation_with_other!(ForcePerVolume, Velocity, StressRate);
 impl_mul_relation_with_other!(Stress, Distance, Stiffness);
 impl_mul_relation_with_other!(StressSquared, Area, ForceStress);
 impl_mul_relation_with_other!(Velocity, Distance, Time);
@@ -60,6 +63,15 @@ impl_mul_relation_with_other!(Velocity, AngularVelocity, Acceleration);
 impl_mul_relation_with_other!(SpecificGasConstant, MolarMass, UniversalGasConstant);
 impl_mul_relation_with_other!(SpecificGasConstant, Temperature, VelocitySquared);
 impl_mul_relation_with_other!(Density, VelocitySquared, Stress);
+impl_mul_relation_with_other!(Density, Temperature, DensityTemperature);
+impl_mul_relation_with_other!(SpecificGasConstant, DensityTemperature, Stress);
+impl_mul_relation_with_other!(Density, SpecificGasConstant, StressPerTemperature);
+impl_mul_relation_with_other!(StressPerTemperature, Temperature, Stress);
+impl_mul_relation_with_other!(DensityRate, VelocitySquared, StressRate);
+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!(InverseDistance, Distance, f64);
 impl_mul!(InverseAngle, Angle, f64);
 impl_mul!(InverseStress, Stress, f64);