unitforge 0.5.9__tar.gz → 0.5.11__tar.gz

{unitforge-0.5.9 → unitforge-0.5.11}/Cargo.lock

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

{unitforge-0.5.9 → unitforge-0.5.11}/Cargo.toml

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

{unitforge-0.5.9 → unitforge-0.5.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: unitforge
-Version: 0.5.9
+Version: 0.5.11
 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.9 → unitforge-0.5.11}/src/lib.rs

@@ -95,6 +95,8 @@ pub mod quantities {
     pub use frequency::*;
     pub mod heat_flux;
     pub use heat_flux::*;
+    pub mod heat_capacity;
+    pub use heat_capacity::*;
     pub mod inverse_distance;
     pub use inverse_distance::*;
     pub mod inverse_area;
@@ -107,10 +109,10 @@ pub mod quantities {
     pub use molar_mass::*;
     pub mod mass_per_distance;
     pub use mass_per_distance::*;
-    pub mod power;
-    pub use power::*;
     pub mod pressure_rate;
     pub use pressure_rate::*;
+    pub mod power;
+    pub use power::*;
     pub mod force_distance;
     pub use force_distance::*;
     pub mod force_stress;
@@ -145,6 +147,8 @@ pub mod quantities {
     pub use temperature::*;
     pub mod temperature_gradient;
     pub use temperature_gradient::*;
+    pub mod thermal_conductance;
+    pub use thermal_conductance::*;
     pub mod inverse_temperature;
     pub use inverse_temperature::*;
     pub mod thermal_conductivity;

unitforge-0.5.11/src/quantities/heat_capacity.rs

@@ -0,0 +1,76 @@
+//! Heat capacity of a finite amount of material, in energy per temperature.
+//!
+//! With `ndarray`, use scalar operators in `mapv` to divide by time and
+//! `QuantityDot` for contractions (including borrowed views). Multiplication
+//! through `MulArray1`/`MulArray2` remains elementwise.
+//!
+//! ```
+//! # #[cfg(feature = "ndarray")] {
+//! use ndarray::{arr1, Array1, Array2};
+//! use unitforge::*;
+//!
+//! let volumetric = VolumetricHeatCapacity::new(2.0, VolumetricHeatCapacityUnit::kJ_mcbK);
+//! let volume = Volume::new(0.5, VolumeUnit::mcb);
+//! let mut capacitance = Array2::<HeatCapacity>::zeros((2, 2));
+//! capacitance[(0, 0)] += volumetric * volume;
+//! let temperature = arr1(&[Temperature::new(300.0, TemperatureUnit::K); 2]);
+//! let delta_time = Time::new(2.0, TimeUnit::s);
+//! let conductance: Array2<ThermalConductance> = capacitance.mapv(|c| c / delta_time);
+//! let energy: Array1<Energy> = QuantityDot::dot(&capacitance.view(), &temperature.view());
+//! let power: Array1<Power> = energy.mapv(|e| e / delta_time);
+//! let power_from_conductance: Array1<Power> = QuantityDot::dot(&conductance, &temperature);
+//! assert!(power[0].is_close(&power_from_conductance[0], &Power::new(1e-6, PowerUnit::W)));
+//! # }
+//! ```
+//!
+//! Incompatible quantities cannot be added:
+//! ```compile_fail
+//! use unitforge::*;
+//! let capacity = HeatCapacity::new(1.0, HeatCapacityUnit::J_K);
+//! let conductance = ThermalConductance::new(1.0, ThermalConductanceUnit::W_K);
+//! let _ = capacity + conductance;
+//! ```
+//!
+//! A dimensionless divisor preserves heat capacity; converting to conductance
+//! requires a typed `Time`:
+//! ```compile_fail
+//! use unitforge::*;
+//! let capacity = HeatCapacity::new(1.0, HeatCapacityUnit::J_K);
+//! let conductance: ThermalConductance = capacity / 2.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 HeatCapacityUnit {
+    J_K,
+    kJ_K,
+}
+
+impl HeatCapacityUnit {
+    pub const fn base_per_x_const(self) -> (f64, i32) {
+        match self {
+            Self::J_K => (1.0, 0),
+            Self::kJ_K => (1.0, 3),
+        }
+    }
+}
+
+impl PhysicsUnit for HeatCapacityUnit {
+    fn name(&self) -> &str {
+        match self {
+            Self::J_K => "J/K",
+            Self::kJ_K => "kJ/K",
+        }
+    }
+
+    fn base_per_x(&self) -> (f64, i32) {
+        (*self).base_per_x_const()
+    }
+}
+
+impl_quantity!(HeatCapacity, HeatCapacityUnit, [HeatCapacityUnit::J_K]);
+impl_div_with_self_to_f64!(HeatCapacity);

unitforge-0.5.11/src/quantities/thermal_conductance.rs

@@ -0,0 +1,42 @@
+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 ThermalConductanceUnit {
+    mW_K,
+    W_K,
+    kW_K,
+}
+
+impl ThermalConductanceUnit {
+    pub const fn base_per_x_const(self) -> (f64, i32) {
+        match self {
+            ThermalConductanceUnit::mW_K => (1., -3),
+            ThermalConductanceUnit::W_K => (1., 0),
+            ThermalConductanceUnit::kW_K => (1., 3),
+        }
+    }
+}
+
+impl PhysicsUnit for ThermalConductanceUnit {
+    fn name(&self) -> &str {
+        match self {
+            ThermalConductanceUnit::mW_K => "mW/K",
+            ThermalConductanceUnit::W_K => "W/K",
+            ThermalConductanceUnit::kW_K => "kW/K",
+        }
+    }
+
+    fn base_per_x(&self) -> (f64, i32) {
+        (*self).base_per_x_const()
+    }
+}
+
+impl_quantity!(
+    ThermalConductance,
+    ThermalConductanceUnit,
+    [ThermalConductanceUnit::W_K]
+);
+impl_div_with_self_to_f64!(ThermalConductance);

{unitforge-0.5.9 → unitforge-0.5.11}/src/relations.rs

@@ -28,6 +28,16 @@ impl_mul_relation_with_other!(Distance, InverseArea, InverseDistance);
 impl_mul_relation_with_other!(InverseDistance, Area, Distance);
 impl_mul_relation_with_other!(Velocity, Time, Distance);
 impl_mul_relation_with_other!(Force, Distance, ForceDistance);
+impl_mul_relation_with_other!(Power, Time, ForceDistance);
+impl_mul_relation_with_other!(Force, Velocity, Power);
+impl_mul_relation_with_other!(HeatFlux, Area, Power);
+impl_mul_relation_with_other!(ThermalConductivity, TemperatureGradient, HeatFlux);
+impl_mul_relation_with_other!(TemperatureGradient, Distance, Temperature);
+impl_mul_relation_with_other!(ThermalConductivity, Distance, ThermalConductance);
+impl_mul_relation_with_other!(ThermalConductance, Temperature, Power);
+impl_mul_relation_with_other!(VolumetricHeatCapacity, Volume, HeatCapacity);
+impl_mul_relation_with_other!(ThermalConductance, Time, HeatCapacity);
+impl_mul_relation_with_other!(HeatCapacity, Temperature, ForceDistance);
 impl_mul_relation_with_other!(Force, Area, ForceArea);
 impl_mul_relation_with_other!(ForceArea, Distance, ForceVolume);
 impl_mul_relation_with_other!(AreaOfMoment, Stress, ForceArea);
@@ -80,12 +90,7 @@ impl_mul_relation_with_self!(Strain, StrainSquared);
 impl_mul_relation_with_self!(Stress, StressSquared);
 impl_mul_relation_with_other!(Stress, StressSquared, StressCubed);
 impl_mul_relation_with_self!(AngularVelocity, AngularAcceleration);
-impl_mul_relation_with_other!(ThermalConductivity, TemperatureGradient, HeatFlux);
-impl_mul_relation_with_other!(TemperatureGradient, Distance, Temperature);
-impl_mul_relation_with_other!(HeatFlux, Area, Power);
-impl_mul_relation_with_other!(Power, Time, ForceDistance);
 impl_mul_relation_with_other!(ForceDistance, Frequency, Power);
-impl_mul_relation_with_other!(Force, Velocity, Power);
 impl_mul_relation_with_other!(Density, SpecificHeatCapacity, VolumetricHeatCapacity);
 impl_mul_relation_with_other!(VolumetricHeatCapacity, Temperature, VolumetricEnergyDensity);
 impl_mul_relation_with_other!(SpecificHeatCapacity, Temperature, SpecificEnergy);

{unitforge-0.5.9 → unitforge-0.5.11}/tests/quantities.rs

@@ -361,6 +361,70 @@ mod test_thermo_and_rates {
         ));
     }
 
+    #[test]
+    fn thermal_quantities_convert_and_relate_to_energy() {
+        let conductivity = ThermalConductivity::new(1.0, ThermalConductivityUnit::kW_mK);
+        assert!(crate::approx_eq(
+            conductivity.to(ThermalConductivityUnit::mW_mK),
+            1_000_000.0,
+            1e-6
+        ));
+
+        let gradient = TemperatureGradient::new(2.0, TemperatureGradientUnit::K_m);
+        let flux = ThermalConductivity::new(1.0, ThermalConductivityUnit::kW_mK) * gradient;
+        assert!(crate::approx_eq(flux.to(HeatFluxUnit::kW_msq), 2.0, 1e-12));
+
+        let area = Area::new(0.5, AreaUnit::msq);
+        let power = flux * area;
+        assert!(crate::approx_eq(power.to(PowerUnit::W), 1000.0, 1e-12));
+
+        let duration = Time::new(30.0, TimeUnit::s);
+        let energy = power * duration;
+        assert!(crate::approx_eq(energy.to(EnergyUnit::J), 30_000.0, 1e-12));
+        assert!(crate::approx_eq(
+            (energy / duration).to(PowerUnit::kW),
+            1.0,
+            1e-12
+        ));
+    }
+
+    #[test]
+    fn thermal_conductance_relates_conductivity_length_and_power() {
+        let conductivity = ThermalConductivity::new(200.0, ThermalConductivityUnit::W_mK);
+        let characteristic_length = Distance::new(0.05, DistanceUnit::m);
+        let conductance = conductivity * characteristic_length;
+        assert!(crate::approx_eq(
+            conductance.to(ThermalConductanceUnit::W_K),
+            10.0,
+            1e-12
+        ));
+
+        let temperature_difference = Temperature::new(15.0, TemperatureUnit::K);
+        let power = conductance * temperature_difference;
+        assert!(crate::approx_eq(power.to(PowerUnit::W), 150.0, 1e-12));
+
+        assert!(crate::approx_eq(
+            (power / conductance).to(TemperatureUnit::K),
+            15.0,
+            1e-12
+        ));
+        assert!(crate::approx_eq(
+            (power / temperature_difference).to(ThermalConductanceUnit::W_K),
+            10.0,
+            1e-12
+        ));
+        assert!(crate::approx_eq(
+            (conductance / conductivity).to(DistanceUnit::m),
+            0.05,
+            1e-12
+        ));
+        assert!(crate::approx_eq(
+            (conductance / characteristic_length).to(ThermalConductivityUnit::W_mK),
+            200.0,
+            1e-12
+        ));
+    }
+
     #[test]
     fn specific_and_molar_gas_constants_relate_through_molar_mass() {
         let molar_mass = MolarMass::new(28.97, MolarMassUnit::g_mol);

{unitforge-0.5.9 → unitforge-0.5.11}/tests/quantity_core/metadata.rs

@@ -34,6 +34,7 @@ fn quantity_kind_id_is_stored_in_memory_optimal_layout() {
 #[test]
 fn quantity_kind_ids_are_unique_and_non_zero() {
     let ids = [
+        <HeatCapacity as QuantityKindId>::KIND_ID,
         <Acceleration as QuantityKindId>::KIND_ID,
         <Angle as QuantityKindId>::KIND_ID,
         <AngularAcceleration as QuantityKindId>::KIND_ID,

{unitforge-0.5.9 → unitforge-0.5.11}/tests/test_quantities.py

@@ -2,6 +2,35 @@ import pytest
 from unitforge import *
 
 
+def test_heat_capacity_thermal_relations():
+    volumetric = VolumetricHeatCapacity(2.0, VolumetricHeatCapacityUnit.kJ_mcbK)
+    volume = Volume(0.5, VolumeUnit.mcb)
+    capacity = volumetric * volume
+    assert isinstance(capacity, HeatCapacity)
+    assert capacity.to(HeatCapacityUnit.J_K) == pytest.approx(1000.0)
+    assert capacity.to(HeatCapacityUnit.kJ_K) == pytest.approx(1.0)
+    assert volume * volumetric == capacity
+    assert capacity / volume == volumetric
+    assert capacity / volumetric == volume
+    time = Time(2.0, TimeUnit.s)
+    conductance = capacity / time
+    assert isinstance(conductance, ThermalConductance)
+    assert conductance.to(ThermalConductanceUnit.W_K) == pytest.approx(500.0)
+    assert conductance * time == capacity
+    assert time * conductance == capacity
+    assert capacity / conductance == time
+    temperature = Temperature(300.0, TemperatureUnit.K)
+    energy = capacity * temperature
+    assert isinstance(energy, Energy)
+    assert energy.to(EnergyUnit.J) == pytest.approx(300000.0)
+    assert temperature * capacity == energy
+    assert energy / temperature == capacity
+    assert energy / capacity == temperature
+    assert (energy / time).to(PowerUnit.W) == pytest.approx(150000.0)
+    with pytest.raises(TypeError):
+        _ = capacity + conductance
+
+
 def test_inverse_stress_from_stress_division():
     stress = Stress(2.0, StressUnit.Pa)
     inverse = 1 / stress

unitforge-0.5.11/tests/thermal_transient.rs

@@ -0,0 +1,226 @@
+use num_traits::Zero;
+use unitforge::*;
+
+fn close<Q: PhysicsQuantity>(actual: Q, expected: Q) {
+    // Match the precision supported by each storage configuration.
+    let epsilon = if cfg!(feature = "storage-f32") {
+        1e-5
+    } else {
+        1e-10
+    };
+    let tolerance = expected.abs() * epsilon + Q::from_raw(epsilon);
+    assert!(
+        actual.is_close(&expected, &tolerance),
+        "physical values differ"
+    );
+}
+
+#[test]
+fn scalar_thermal_relations_in_both_orders_and_inverses() {
+    let volumetric = VolumetricHeatCapacity::new(2.0, VolumetricHeatCapacityUnit::kJ_mcbK);
+    let volume = Volume::new(0.5, VolumeUnit::mcb);
+    let capacity = HeatCapacity::new(1000.0, HeatCapacityUnit::J_K);
+    let time = Time::new(2000.0, TimeUnit::ms);
+    let conductance = ThermalConductance::new(0.5, ThermalConductanceUnit::kW_K);
+    let temperature = Temperature::new(300.0, TemperatureUnit::K);
+    let energy = Energy::new(300.0, EnergyUnit::kNm);
+
+    let assembled: HeatCapacity = volumetric * volume;
+    close(assembled, capacity);
+    close(volume * volumetric, capacity);
+    close(capacity / volume, volumetric);
+    close(capacity / volumetric, volume);
+    close(conductance * time, capacity);
+    close(time * conductance, capacity);
+    let rate: ThermalConductance = capacity / time;
+    close(rate, conductance);
+    close(capacity / conductance, time);
+    let stored_energy: Energy = capacity * temperature;
+    close(stored_energy, energy);
+    close(temperature * capacity, energy);
+    close(energy / temperature, capacity);
+    close(energy / capacity, temperature);
+    let power: Power = stored_energy / time;
+    close(power, Power::new(150000.0, PowerUnit::W));
+}
+
+#[test]
+fn capacity_units_signed_arithmetic_and_registration() {
+    let capacity = HeatCapacity::new(1.0, HeatCapacityUnit::kJ_K);
+    close(capacity, HeatCapacity::new(1000.0, HeatCapacityUnit::J_K));
+    assert_eq!(capacity.to(HeatCapacityUnit::kJ_K), 1.0);
+    assert_eq!(capacity.to(HeatCapacityUnit::J_K), 1000.0);
+    let mut accumulated = HeatCapacity::zero();
+    accumulated += capacity;
+    accumulated -= capacity * 0.25;
+    close(accumulated, HeatCapacity::new(750.0, HeatCapacityUnit::J_K));
+    close(-capacity + capacity, HeatCapacity::zero());
+    close(capacity / 2.0, 0.5 * capacity);
+    assert!(capacity > -capacity);
+    assert!((capacity / HeatCapacity::new(250.0, HeatCapacityUnit::J_K) - 4.0).abs() < 1e-5);
+    assert_ne!(HeatCapacity::KIND_ID, 0);
+    assert_ne!(HeatCapacity::KIND_ID, ThermalConductance::KIND_ID);
+    let runtime = Unit::HeatCapacityUnit(HeatCapacityUnit::kJ_K).to_quantity(1.0);
+    assert_eq!(runtime, Quantity::HeatCapacityQuantity(capacity));
+    let result = (runtime / Quantity::TimeQuantity(Time::new(2.0, TimeUnit::s))).unwrap();
+    assert_eq!(
+        result,
+        Quantity::ThermalConductanceQuantity(ThermalConductance::new(
+            500.0,
+            ThermalConductanceUnit::W_K
+        ))
+    );
+}
+
+#[test]
+fn exceptional_values_follow_quantity_semantics() {
+    let zero = HeatCapacity::zero();
+    let time_zero = Time::zero();
+    assert!((zero / time_zero).is_nan());
+    assert!((zero / zero).is_nan());
+    close(
+        HeatCapacity::new(-2.0, HeatCapacityUnit::J_K) / Time::new(2.0, TimeUnit::s),
+        ThermalConductance::new(-1.0, ThermalConductanceUnit::W_K),
+    );
+    assert!((HeatCapacity::new(1.0, HeatCapacityUnit::J_K) / time_zero)
+        .to(ThermalConductanceUnit::W_K)
+        .is_infinite());
+    assert!(HeatCapacity::nan().is_nan());
+    #[cfg(not(any(feature = "storage-f64", feature = "storage-f32")))]
+    {
+        assert!(HeatCapacity::from_exponential(1.0, MAX_ABS_QUANTITY_POWER)
+            .to(HeatCapacityUnit::J_K)
+            .is_infinite());
+        close(
+            HeatCapacity::from_exponential(1.0, -MAX_ABS_QUANTITY_POWER),
+            zero,
+        );
+    }
+}
+
+#[cfg(feature = "serde")]
+#[test]
+fn capacity_serialization_roundtrip() {
+    let original = HeatCapacity::new(-0.125, HeatCapacityUnit::kJ_K);
+    let restored: HeatCapacity =
+        serde_json::from_str(&serde_json::to_string(&original).unwrap()).unwrap();
+    close(restored, original);
+    let unit: HeatCapacityUnit =
+        serde_json::from_str(&serde_json::to_string(&HeatCapacityUnit::kJ_K).unwrap()).unwrap();
+    assert_eq!(unit, HeatCapacityUnit::kJ_K);
+}
+
+#[cfg(feature = "strum")]
+#[test]
+fn capacity_units_are_registered_for_iteration() {
+    use strum::IntoEnumIterator;
+    assert_eq!(
+        HeatCapacityUnit::iter().collect::<Vec<_>>(),
+        vec![HeatCapacityUnit::J_K, HeatCapacityUnit::kJ_K]
+    );
+}
+
+#[cfg(feature = "ndarray")]
+mod arrays {
+    use super::*;
+    use ndarray::{arr1, arr2, s, Array1, Array2};
+
+    fn capacity(value: f64) -> HeatCapacity {
+        HeatCapacity::new(value, HeatCapacityUnit::J_K)
+    }
+
+    #[test]
+    fn backward_euler_both_routes() {
+        let mut c = Array2::<HeatCapacity>::zeros((2, 2));
+        let volumetric = VolumetricHeatCapacity::new(2.0, VolumetricHeatCapacityUnit::kJ_mcbK);
+        c[(0, 0)] += volumetric * Volume::new(0.001, VolumeUnit::mcb);
+        c[(0, 1)] += HeatCapacity::new(0.001, HeatCapacityUnit::kJ_K);
+        c[(1, 0)] += capacity(1.0);
+        c[(1, 1)] += capacity(3.0);
+        let t = arr1(&[300.0, 400.0]).mapv(|v| Temperature::new(v, TemperatureUnit::K));
+        let time = Time::new(2.0, TimeUnit::s);
+        let k: Array2<ThermalConductance> = c.mapv(|v| v / time);
+        assert_eq!(k.dim(), c.dim());
+        for (actual, expected) in k.iter().zip([1.0, 0.5, 0.5, 1.5]) {
+            close(
+                *actual,
+                ThermalConductance::new(expected, ThermalConductanceUnit::W_K),
+            );
+        }
+        let energy: Array1<Energy> = QuantityDot::dot(&c, &t);
+        close(energy[0], Energy::new(1000.0, EnergyUnit::J));
+        close(energy[1], Energy::new(1500.0, EnergyUnit::J));
+        let p: Array1<Power> = energy.mapv(|v| v / time);
+        let other: Array1<Power> = QuantityDot::dot(&k, &t);
+        assert_eq!(p.len(), 2);
+        for ((a, b), expected) in p.iter().zip(other.iter()).zip([500.0, 750.0]) {
+            close(*a, Power::new(expected, PowerUnit::W));
+            close(*a, *b);
+        }
+        #[cfg(feature = "serde")]
+        {
+            let restored: Array2<HeatCapacity> =
+                serde_json::from_str(&serde_json::to_string(&c).unwrap()).unwrap();
+            assert_eq!(restored.dim(), c.dim());
+            for (a, b) in restored.iter().zip(c.iter()) {
+                close(*a, *b);
+            }
+        }
+    }
+
+    #[test]
+    fn rectangular_strided_views_and_cancellation() {
+        let c = arr2(&[[2.0, 99.0, -1.0, 99.0, 0.0], [0.0, 99.0, 3.0, 99.0, -2.0]]).mapv(capacity);
+        let c_view = c.slice(s![.., ..;2]);
+        let t = arr1(&[300.0, 99.0, 600.0, 99.0, 400.0])
+            .mapv(|v| Temperature::new(v, TemperatureUnit::K));
+        let t_view = t.slice(s![..;2]);
+        let energy: Array1<Energy> = QuantityDot::dot(&c_view, &t_view);
+        close(energy[0], Energy::zero());
+        close(energy[1], Energy::new(1000.0, EnergyUnit::J));
+        let time = Time::new(2.0, TimeUnit::s);
+        let power: Array1<Power> = energy.mapv(|v| v / time);
+        let k = c_view.mapv(|v| v / time);
+        let other: Array1<Power> = QuantityDot::dot(&k.view(), &t_view);
+        for (a, b) in power.iter().zip(other.iter()) {
+            close(*a, *b);
+        }
+        let vv: Energy = QuantityDot::dot(&c_view.row(0), &t_view);
+        close(vv, Energy::zero());
+        let vm: Array1<Energy> = QuantityDot::dot(&t_view, &c_view.t());
+        for (a, b) in vm.iter().zip(energy.iter()) {
+            close(*a, *b);
+        }
+        let temperatures = arr2(&[[300.0, 0.0], [600.0, 1.0], [400.0, -1.0]])
+            .mapv(|v| Temperature::new(v, TemperatureUnit::K));
+        let mm: Array2<Energy> = QuantityDot::dot(&c_view, &temperatures.view());
+        assert_eq!(mm.dim(), (2, 2));
+        close(mm[(0, 0)], Energy::zero());
+        close(mm[(1, 0)], energy[1]);
+        close(mm[(0, 1)], Energy::new(-1.0, EnergyUnit::J));
+        close(mm[(1, 1)], Energy::new(5.0, EnergyUnit::J));
+    }
+
+    #[test]
+    fn contraction_dimensions_must_match() {
+        let c = Array2::from_elem((2, 3), capacity(1.0));
+        let t = Array1::from_elem(2, Temperature::new(300.0, TemperatureUnit::K));
+        let tm = Array2::from_elem((2, 4), Temperature::new(300.0, TemperatureUnit::K));
+        assert!(std::panic::catch_unwind(|| QuantityDot::dot(&c.view(), &t.view())).is_err());
+        assert!(std::panic::catch_unwind(|| QuantityDot::dot(&c.view(), &tm.view())).is_err());
+        assert!(std::panic::catch_unwind(|| QuantityDot::dot(&c.row(0), &t.view())).is_err());
+        assert!(std::panic::catch_unwind(|| QuantityDot::dot(&c.row(0), &tm.view())).is_err());
+    }
+
+    #[test]
+    fn quantity_array_conversion() {
+        let c = Array2::<HeatCapacity>::from_raw(
+            arr2(&[[0.001, -0.002]]).view(),
+            HeatCapacityUnit::kJ_K,
+        );
+        close(c[(0, 0)], capacity(1.0));
+        close(c[(0, 1)], capacity(-2.0));
+        let v = Array1::<HeatCapacity>::from_raw(arr1(&[0.003]).view(), HeatCapacityUnit::kJ_K);
+        close(v[0], capacity(3.0));
+    }
+}

{unitforge-0.5.9 → unitforge-0.5.11}/tests/typecheck/mypy_smoke.py

@@ -11,6 +11,18 @@ from unitforge import (
     ForceAreaUnit,
     Force,
     ForceUnit,
+    HeatCapacity,
+    HeatCapacityUnit,
+    Power,
+    Temperature,
+    TemperatureUnit,
+    ThermalConductance,
+    Time,
+    TimeUnit,
+    Volume,
+    VolumeUnit,
+    VolumetricHeatCapacity,
+    VolumetricHeatCapacityUnit,
     Matrix3,
     Moment,
     MomentUnit,
@@ -25,6 +37,16 @@ force_scaled: Force = force * 2.0
 force_ratio: float = force / Force(3.0, ForceUnit.N)
 dynamic_product: Energy = force * distance
 
+volumetric: VolumetricHeatCapacity = VolumetricHeatCapacity(2.0, VolumetricHeatCapacityUnit.kJ_mcbK)
+volume: Volume = Volume(0.5, VolumeUnit.mcb)
+capacity: HeatCapacity = volumetric * volume
+capacity_in_kj: float = capacity.to(HeatCapacityUnit.kJ_K)
+step: Time = Time(2.0, TimeUnit.s)
+conductance: ThermalConductance = capacity / step
+temperature: Temperature = Temperature(300.0, TemperatureUnit.K)
+thermal_energy: Energy = capacity * temperature
+heat_rate: Power = thermal_energy / step
+
 vector: Vector3 = Vector3.from_list([1.0, 2.0, 3.0], ForceUnit.N)
 vector_first: Any = vector[0]
 vector_norm: Any = vector.norm()

{unitforge-0.5.9 → unitforge-0.5.11}/unitforge_macros/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "unitforge_macros"
-version = "0.5.8"
+version = "0.5.11"
 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"