unitforge 0.3.13__tar.gz → 0.3.15__tar.gz

{unitforge-0.3.13 → unitforge-0.3.15}/Cargo.lock

@@ -322,15 +322,15 @@ dependencies = [
 
 [[package]]
 name = "strum"
-version = "0.27.2"
+version = "0.28.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "af23d6f6c1a224baef9d3f61e287d2761385a5b88fdab4eb4c6f11aeb54c4bcf"
+checksum = "9628de9b8791db39ceda2b119bbe13134770b56c138ec1d3af810d045c04f9bd"
 
 [[package]]
 name = "strum_macros"
-version = "0.27.2"
+version = "0.28.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7695ce3845ea4b33927c055a39dc438a45b059f7c1b3d91d38d10355fb8cbca7"
+checksum = "ab85eea0270ee17587ed4156089e10b9e6880ee688791d45a905f5b1ca36f664"
 dependencies = [
  "heck",
  "proc-macro2",
@@ -369,7 +369,7 @@ checksum = "7264e107f553ccae879d21fbea1d6724ac785e8c3bfc762137959b5802826ef3"
 
 [[package]]
 name = "unitforge"
-version = "0.3.13"
+version = "0.3.15"
 dependencies = [
  "ndarray",
  "num-traits",
@@ -384,7 +384,7 @@ dependencies = [
 
 [[package]]
 name = "unitforge_macros"
-version = "0.3.13"
+version = "0.3.15"
 dependencies = [
  "regex",
 ]

{unitforge-0.3.13 → unitforge-0.3.15}/Cargo.toml

@@ -4,7 +4,7 @@ crate-type = ["cdylib", "rlib"]
 
 [package]
 name = "unitforge"
-version = "0.3.13"
+version = "0.3.15"
 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"
@@ -21,9 +21,9 @@ serde = { version = "1", optional = true, features = ["derive"] }
 serde_json = { version = "1.0.140", optional = true }
 pyo3 = { version = "0.26.0", features = ["extension-module", "auto-initialize", "multiple-pymethods"], optional = true }
 numpy = { version = "0.26.0", optional = true }
-strum = { version = "0.27.2", optional = true }
-strum_macros = { version = "0.27.2", optional = true }
-unitforge_macros = { version = "0.3.13", path = "unitforge_macros" }
+strum = { version = "0.28.0", optional = true }
+strum_macros = { version = "0.28.0", optional = true }
+unitforge_macros = { version = "0.3.15", path = "unitforge_macros" }
 
 [features]
 serde = ["dep:serde", "dep:serde_json", "ndarray/serde"]

{unitforge-0.3.13 → unitforge-0.3.15}/PKG-INFO

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

{unitforge-0.3.13 → unitforge-0.3.15}/src/impl_macros.rs

@@ -1,6 +1,19 @@
 #[macro_export]
 macro_rules! impl_quantity {
     ($type:ident, $unit:ident, $display_units:expr) => {
+        use ndarray::{Array1, Array2, ArrayView1, ArrayView2};
+        use num_traits::Zero;
+        use std::collections::HashSet;
+        use num_traits::{Float, FromPrimitive};
+        #[cfg(feature = "serde")]
+        use serde::{Deserialize, Serialize};
+        use std::cmp::Ordering;
+        use std::fmt;
+        use std::ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Neg, Sub, SubAssign};
+        use $crate::prelude::*;
+
+        #[cfg(feature = "pyo3")]
+        use pyo3::pyclass;
         #[cfg(feature = "pyo3")]
         use pyo3::{
             basic::CompareOp, exceptions::PyValueError, pymethods, types::PyType, Bound,
@@ -9,6 +22,8 @@ macro_rules! impl_quantity {
 
         #[cfg(feature = "strum")]
         use strum::IntoEnumIterator;
+        #[cfg(feature = "strum")]
+        use strum_macros::EnumIter;
         use $crate::small_linalg::{Matrix3, Vector3};
         #[cfg(feature = "pyo3")]
         use $crate::Quantity;
@@ -581,10 +596,30 @@ macro_rules! impl_quantity {
 
         #[cfg(feature = "strum")]
         impl $type {
-            pub fn optimal_unit(&self) -> Option<$unit> {
+            pub fn optimal_unit(
+                &self,
+                choices: impl Into<Option<HashSet<$unit>>>,
+            ) -> Option<$unit> {
+                let choices = choices.into().unwrap_or_else(|| $unit::iter().collect());
+                let mut min_value = f64::INFINITY;
+                let mut best_unit = None;
+                for unit in choices {
+                    let deviation = (self.to(unit).abs() - 1.).abs();
+                    if deviation < min_value {
+                        min_value = deviation;
+                        best_unit = Some(unit);
+                    }
+                }
+                best_unit
+            }
+        }
+
+        #[cfg(not(feature = "strum"))]
+        impl $type {
+            pub fn optimal_unit(&self, choices: HashSet<$unit>) -> Option<$unit> {
                 let mut min_value = f64::INFINITY;
                 let mut best_unit = None;
-                for unit in $unit::iter() {
+                for unit in choices {
                     let deviation = (self.to(unit).abs() - 1.).abs();
                     if deviation < min_value {
                         min_value = deviation;

{unitforge-0.3.13 → unitforge-0.3.15}/src/quantities/acceleration.rs

@@ -1,22 +1,8 @@
 use crate::impl_macros::macros::*;
-use crate::prelude::*;
-use ndarray::{Array1, Array2, ArrayView1, ArrayView2};
-use num_traits::identities::Zero;
-use num_traits::{Float, FromPrimitive};
-#[cfg(feature = "pyo3")]
-use pyo3::pyclass;
-#[cfg(feature = "serde")]
-use serde::{Deserialize, Serialize};
-use std::cmp::Ordering;
-use std::fmt;
-use std::ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Neg, Sub, SubAssign};
-
-#[cfg(feature = "strum")]
-use strum_macros::EnumIter;
 
 #[cfg_attr(feature = "strum", derive(EnumIter))]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-#[derive(Copy, Clone, PartialEq, Debug)]
+#[derive(Copy, Clone, PartialEq, Debug, Hash, Eq)]
 #[cfg_attr(feature = "pyo3", pyclass(eq, eq_int))]
 pub enum AccelerationUnit {
     m_ssq,

{unitforge-0.3.13 → unitforge-0.3.15}/src/quantities/angle.rs

@@ -1,23 +1,11 @@
 use crate::impl_macros::macros::*;
-use crate::prelude::*;
 use crate::PhysicsUnit;
-use ndarray::{Array1, Array2, ArrayView1, ArrayView2};
-use num_traits::identities::Zero;
-use num_traits::{Float, FloatConst, FromPrimitive};
-#[cfg(feature = "pyo3")]
-use pyo3::pyclass;
-#[cfg(feature = "serde")]
-use serde::{Deserialize, Serialize};
-use std::cmp::Ordering;
+use num_traits::FloatConst;
 use std::f64::consts::PI;
-use std::fmt;
-use std::ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Neg, Sub, SubAssign};
-#[cfg(feature = "strum")]
-use strum_macros::EnumIter;
 
 #[cfg_attr(feature = "strum", derive(EnumIter))]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-#[derive(Copy, Clone, PartialEq, Debug)]
+#[derive(Copy, Clone, PartialEq, Debug, Hash, Eq)]
 #[cfg_attr(feature = "pyo3", pyclass(eq, eq_int))]
 pub enum AngleUnit {
     rad,

{unitforge-0.3.13 → unitforge-0.3.15}/src/quantities/angular_acceleration.rs

@@ -1,23 +1,10 @@
 use crate::impl_macros::macros::*;
-use crate::prelude::*;
 use crate::PhysicsUnit;
-use ndarray::{Array1, Array2, ArrayView1, ArrayView2};
-use num_traits::identities::Zero;
-use num_traits::{Float, FromPrimitive};
-#[cfg(feature = "pyo3")]
-use pyo3::pyclass;
-#[cfg(feature = "serde")]
-use serde::{Deserialize, Serialize};
-use std::cmp::Ordering;
 use std::f64::consts::PI;
-use std::fmt;
-use std::ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Neg, Sub, SubAssign};
-#[cfg(feature = "strum")]
-use strum_macros::EnumIter;
 
 #[cfg_attr(feature = "strum", derive(EnumIter))]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-#[derive(Copy, Clone, PartialEq, Debug)]
+#[derive(Copy, Clone, PartialEq, Debug, Hash, Eq)]
 #[cfg_attr(feature = "pyo3", pyclass(eq, eq_int))]
 pub enum AngularAccelerationUnit {
     rad_ssq,

{unitforge-0.3.13 → unitforge-0.3.15}/src/quantities/angular_velocity.rs

@@ -1,23 +1,10 @@
 use crate::impl_macros::macros::*;
-use crate::prelude::*;
 use crate::PhysicsUnit;
-use ndarray::{Array1, Array2, ArrayView1, ArrayView2};
-use num_traits::identities::Zero;
-use num_traits::{Float, FromPrimitive};
-#[cfg(feature = "pyo3")]
-use pyo3::pyclass;
-#[cfg(feature = "serde")]
-use serde::{Deserialize, Serialize};
-use std::cmp::Ordering;
 use std::f64::consts::PI;
-use std::fmt;
-use std::ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Neg, Sub, SubAssign};
-#[cfg(feature = "strum")]
-use strum_macros::EnumIter;
 
 #[cfg_attr(feature = "strum", derive(EnumIter))]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-#[derive(Copy, Clone, PartialEq, Debug)]
+#[derive(Copy, Clone, PartialEq, Debug, Hash, Eq)]
 #[cfg_attr(feature = "pyo3", pyclass(eq, eq_int))]
 pub enum AngularVelocityUnit {
     rad_s,

{unitforge-0.3.13 → unitforge-0.3.15}/src/quantities/area.rs

@@ -1,22 +1,8 @@
 use crate::impl_macros::macros::*;
-use crate::prelude::*;
-use ndarray::{Array1, Array2, ArrayView1, ArrayView2};
-use num_traits::identities::Zero;
-use num_traits::{Float, FromPrimitive};
-#[cfg(feature = "pyo3")]
-use pyo3::pyclass;
-#[cfg(feature = "serde")]
-use serde::{Deserialize, Serialize};
-use std::cmp::Ordering;
-use std::fmt;
-use std::ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Neg, Sub, SubAssign};
-
-#[cfg(feature = "strum")]
-use strum_macros::EnumIter;
 
 #[cfg_attr(feature = "strum", derive(EnumIter))]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-#[derive(Copy, Clone, PartialEq, Debug)]
+#[derive(Copy, Clone, PartialEq, Debug, Hash, Eq)]
 #[cfg_attr(feature = "pyo3", pyclass(eq, eq_int))]
 pub enum AreaUnit {
     kmsq,

{unitforge-0.3.13 → unitforge-0.3.15}/src/quantities/area_of_moment.rs

@@ -1,21 +1,8 @@
 use crate::impl_macros::macros::*;
-use crate::prelude::*;
-use ndarray::{Array1, Array2, ArrayView1, ArrayView2};
-use num_traits::identities::Zero;
-use num_traits::{Float, FromPrimitive};
-#[cfg(feature = "pyo3")]
-use pyo3::pyclass;
-#[cfg(feature = "serde")]
-use serde::{Deserialize, Serialize};
-use std::cmp::Ordering;
-use std::fmt;
-use std::ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Neg, Sub, SubAssign};
-#[cfg(feature = "strum")]
-use strum_macros::EnumIter;
 
 #[cfg_attr(feature = "strum", derive(EnumIter))]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-#[derive(Copy, Clone, PartialEq, Debug)]
+#[derive(Copy, Clone, PartialEq, Debug, Hash, Eq)]
 #[cfg_attr(feature = "pyo3", pyclass(eq, eq_int))]
 pub enum AreaOfMomentUnit {
     mhc,

{unitforge-0.3.13 → unitforge-0.3.15}/src/quantities/charge.rs

@@ -1,21 +1,8 @@
 use crate::impl_macros::macros::*;
-use crate::prelude::*;
-use ndarray::{Array1, Array2, ArrayView1, ArrayView2};
-use num_traits::identities::Zero;
-use num_traits::{Float, FromPrimitive};
-#[cfg(feature = "pyo3")]
-use pyo3::pyclass;
-#[cfg(feature = "serde")]
-use serde::{Deserialize, Serialize};
-use std::cmp::Ordering;
-use std::fmt;
-use std::ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Neg, Sub, SubAssign};
-#[cfg(feature = "strum")]
-use strum_macros::EnumIter;
 
 #[cfg_attr(feature = "strum", derive(EnumIter))]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-#[derive(Copy, Clone, PartialEq, Debug)]
+#[derive(Copy, Clone, PartialEq, Debug, Hash, Eq)]
 #[cfg_attr(feature = "pyo3", pyclass(eq, eq_int))]
 pub enum ChargeUnit {
     C,

{unitforge-0.3.13 → unitforge-0.3.15}/src/quantities/compliance.rs

@@ -1,21 +1,8 @@
 use crate::impl_macros::macros::*;
-use crate::prelude::*;
-use ndarray::{Array1, Array2, ArrayView1, ArrayView2};
-use num_traits::identities::Zero;
-use num_traits::{Float, FromPrimitive};
-#[cfg(feature = "pyo3")]
-use pyo3::pyclass;
-#[cfg(feature = "serde")]
-use serde::{Deserialize, Serialize};
-use std::cmp::Ordering;
-use std::fmt;
-use std::ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Neg, Sub, SubAssign};
-#[cfg(feature = "strum")]
-use strum_macros::EnumIter;
 
 #[cfg_attr(feature = "strum", derive(EnumIter))]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-#[derive(Copy, Clone, PartialEq, Debug)]
+#[derive(Copy, Clone, PartialEq, Debug, Hash, Eq)]
 #[cfg_attr(feature = "pyo3", pyclass(eq, eq_int))]
 pub enum ComplianceUnit {
     m_N,

{unitforge-0.3.13 → unitforge-0.3.15}/src/quantities/density.rs

@@ -1,21 +1,8 @@
 use crate::impl_macros::macros::*;
-use crate::prelude::*;
-use ndarray::{Array1, Array2, ArrayView1, ArrayView2};
-use num_traits::identities::Zero;
-use num_traits::{Float, FromPrimitive};
-#[cfg(feature = "pyo3")]
-use pyo3::pyclass;
-#[cfg(feature = "serde")]
-use serde::{Deserialize, Serialize};
-use std::cmp::Ordering;
-use std::fmt;
-use std::ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Neg, Sub, SubAssign};
-#[cfg(feature = "strum")]
-use strum_macros::EnumIter;
 
 #[cfg_attr(feature = "strum", derive(EnumIter))]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-#[derive(Copy, Clone, PartialEq, Debug)]
+#[derive(Copy, Clone, PartialEq, Debug, Hash, Eq)]
 #[cfg_attr(feature = "pyo3", pyclass(eq, eq_int))]
 pub enum DensityUnit {
     kg_dmcb,

{unitforge-0.3.13 → unitforge-0.3.15}/src/quantities/distance.rs

@@ -1,22 +1,9 @@
 use crate::impl_macros::macros::*;
-use crate::prelude::*;
 use crate::quantities::*;
-use ndarray::{Array1, Array2, ArrayView1, ArrayView2};
-use num_traits::identities::Zero;
-use num_traits::{Float, FromPrimitive};
-#[cfg(feature = "pyo3")]
-use pyo3::pyclass;
-#[cfg(feature = "serde")]
-use serde::{Deserialize, Serialize};
-use std::cmp::Ordering;
-use std::fmt;
-use std::ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Neg, Sub, SubAssign};
-#[cfg(feature = "strum")]
-use strum_macros::EnumIter;
 
 #[cfg_attr(feature = "strum", derive(EnumIter))]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-#[derive(Copy, Clone, PartialEq, Debug)]
+#[derive(Copy, Clone, PartialEq, Debug, Hash, Eq)]
 #[cfg_attr(feature = "pyo3", pyclass(eq, eq_int))]
 pub enum DistanceUnit {
     km,

{unitforge-0.3.13 → unitforge-0.3.15}/src/quantities/force.rs

@@ -1,21 +1,8 @@
 use crate::impl_macros::macros::*;
-use crate::prelude::*;
-use ndarray::{Array1, Array2, ArrayView1, ArrayView2};
-use num_traits::identities::Zero;
-use num_traits::{Float, FromPrimitive};
-#[cfg(feature = "pyo3")]
-use pyo3::pyclass;
-#[cfg(feature = "serde")]
-use serde::{Deserialize, Serialize};
-use std::cmp::Ordering;
-use std::fmt;
-use std::ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Neg, Sub, SubAssign};
-#[cfg(feature = "strum")]
-use strum_macros::EnumIter;
 
 #[cfg_attr(feature = "strum", derive(EnumIter))]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-#[derive(Copy, Clone, PartialEq, Debug)]
+#[derive(Copy, Clone, PartialEq, Debug, Hash, Eq)]
 #[cfg_attr(feature = "pyo3", pyclass(eq, eq_int))]
 pub enum ForceUnit {
     GN,

{unitforge-0.3.13 → unitforge-0.3.15}/src/quantities/force_area.rs

@@ -1,21 +1,8 @@
 use crate::impl_macros::macros::*;
-use crate::prelude::*;
-use ndarray::{Array1, Array2, ArrayView1, ArrayView2};
-use num_traits::identities::Zero;
-use num_traits::{Float, FromPrimitive};
-#[cfg(feature = "pyo3")]
-use pyo3::pyclass;
-#[cfg(feature = "serde")]
-use serde::{Deserialize, Serialize};
-use std::cmp::Ordering;
-use std::fmt;
-use std::ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Neg, Sub, SubAssign};
-#[cfg(feature = "strum")]
-use strum_macros::EnumIter;
 
 #[cfg_attr(feature = "strum", derive(EnumIter))]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-#[derive(Copy, Clone, PartialEq, Debug)]
+#[derive(Copy, Clone, PartialEq, Debug, Hash, Eq)]
 #[cfg_attr(feature = "pyo3", pyclass(eq, eq_int))]
 pub enum ForceAreaUnit {
     Nmsq,

{unitforge-0.3.13 → unitforge-0.3.15}/src/quantities/force_distance.rs

@@ -1,22 +1,9 @@
 use crate::impl_macros::macros::*;
-use crate::prelude::*;
 use crate::quantities::*;
-use ndarray::{Array1, Array2, ArrayView1, ArrayView2};
-use num_traits::identities::Zero;
-use num_traits::{Float, FromPrimitive};
-#[cfg(feature = "pyo3")]
-use pyo3::pyclass;
-#[cfg(feature = "serde")]
-use serde::{Deserialize, Serialize};
-use std::cmp::Ordering;
-use std::fmt;
-use std::ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Neg, Sub, SubAssign};
-#[cfg(feature = "strum")]
-use strum_macros::EnumIter;
 
 #[cfg_attr(feature = "strum", derive(EnumIter))]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-#[derive(Copy, Clone, PartialEq, Debug)]
+#[derive(Copy, Clone, PartialEq, Debug, Hash, Eq)]
 #[cfg_attr(feature = "pyo3", pyclass(eq, eq_int))]
 pub enum ForceDistanceUnit {
     Nm,

{unitforge-0.3.13 → unitforge-0.3.15}/src/quantities/force_div_distance_power_four.rs

@@ -1,21 +1,8 @@
 use crate::impl_macros::macros::*;
-use crate::prelude::*;
-use ndarray::{Array1, Array2, ArrayView1, ArrayView2};
-use num_traits::identities::Zero;
-use num_traits::{Float, FromPrimitive};
-#[cfg(feature = "pyo3")]
-use pyo3::pyclass;
-#[cfg(feature = "serde")]
-use serde::{Deserialize, Serialize};
-use std::cmp::Ordering;
-use std::fmt;
-use std::ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Neg, Sub, SubAssign};
-#[cfg(feature = "strum")]
-use strum_macros::EnumIter;
 
 #[cfg_attr(feature = "strum", derive(EnumIter))]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-#[derive(Copy, Clone, PartialEq, Debug)]
+#[derive(Copy, Clone, PartialEq, Debug, Hash, Eq)]
 #[cfg_attr(feature = "pyo3", pyclass(eq, eq_int))]
 pub enum ForcePerDistancePowerFourUnit {
     N_mmhc,

{unitforge-0.3.13 → unitforge-0.3.15}/src/quantities/force_per_volume.rs

@@ -1,21 +1,8 @@
 use crate::impl_macros::macros::*;
-use crate::prelude::*;
-use ndarray::{Array1, Array2, ArrayView1, ArrayView2};
-use num_traits::identities::Zero;
-use num_traits::{Float, FromPrimitive};
-#[cfg(feature = "pyo3")]
-use pyo3::pyclass;
-#[cfg(feature = "serde")]
-use serde::{Deserialize, Serialize};
-use std::cmp::Ordering;
-use std::fmt;
-use std::ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Neg, Sub, SubAssign};
-#[cfg(feature = "strum")]
-use strum_macros::EnumIter;
 
 #[cfg_attr(feature = "strum", derive(EnumIter))]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-#[derive(Copy, Clone, PartialEq, Debug)]
+#[derive(Copy, Clone, PartialEq, Debug, Hash, Eq)]
 #[cfg_attr(feature = "pyo3", pyclass(eq, eq_int))]
 pub enum ForcePerVolumeUnit {
     N_mcb,

{unitforge-0.3.13 → unitforge-0.3.15}/src/quantities/force_stress.rs

@@ -1,21 +1,8 @@
 use crate::impl_macros::macros::*;
-use crate::prelude::*;
-use ndarray::{Array1, Array2, ArrayView1, ArrayView2};
-use num_traits::identities::Zero;
-use num_traits::{Float, FromPrimitive};
-#[cfg(feature = "pyo3")]
-use pyo3::pyclass;
-#[cfg(feature = "serde")]
-use serde::{Deserialize, Serialize};
-use std::cmp::Ordering;
-use std::fmt;
-use std::ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Neg, Sub, SubAssign};
-#[cfg(feature = "strum")]
-use strum_macros::EnumIter;
 
 #[cfg_attr(feature = "strum", derive(EnumIter))]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-#[derive(Copy, Clone, PartialEq, Debug)]
+#[derive(Copy, Clone, PartialEq, Debug, Hash, Eq)]
 #[cfg_attr(feature = "pyo3", pyclass(eq, eq_int))]
 pub enum ForceStressUnit {
     Nsq_msq,

{unitforge-0.3.13 → unitforge-0.3.15}/src/quantities/force_volume.rs

@@ -1,21 +1,8 @@
 use crate::impl_macros::macros::*;
-use crate::prelude::*;
-use ndarray::{Array1, Array2, ArrayView1, ArrayView2};
-use num_traits::identities::Zero;
-use num_traits::{Float, FromPrimitive};
-#[cfg(feature = "pyo3")]
-use pyo3::pyclass;
-#[cfg(feature = "serde")]
-use serde::{Deserialize, Serialize};
-use std::cmp::Ordering;
-use std::fmt;
-use std::ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Neg, Sub, SubAssign};
-#[cfg(feature = "strum")]
-use strum_macros::EnumIter;
 
 #[cfg_attr(feature = "strum", derive(EnumIter))]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-#[derive(Copy, Clone, PartialEq, Debug)]
+#[derive(Copy, Clone, PartialEq, Debug, Hash, Eq)]
 #[cfg_attr(feature = "pyo3", pyclass(eq, eq_int))]
 pub enum ForceVolumeUnit {
     Nmcb,

{unitforge-0.3.13 → unitforge-0.3.15}/src/quantities/inverse_area.rs

@@ -1,22 +1,9 @@
 use crate::impl_macros::macros::*;
-use crate::prelude::*;
 use crate::Area;
-use ndarray::{Array1, Array2, ArrayView1, ArrayView2};
-use num_traits::identities::Zero;
-use num_traits::{Float, FromPrimitive};
-#[cfg(feature = "pyo3")]
-use pyo3::pyclass;
-#[cfg(feature = "serde")]
-use serde::{Deserialize, Serialize};
-use std::cmp::Ordering;
-use std::fmt;
-use std::ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Neg, Sub, SubAssign};
-#[cfg(feature = "strum")]
-use strum_macros::EnumIter;
 
 #[cfg_attr(feature = "strum", derive(EnumIter))]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-#[derive(Copy, Clone, PartialEq, Debug)]
+#[derive(Copy, Clone, PartialEq, Debug, Hash, Eq)]
 #[cfg_attr(feature = "pyo3", pyclass(eq, eq_int))]
 pub enum InverseAreaUnit {
     _msq,

{unitforge-0.3.13 → unitforge-0.3.15}/src/quantities/inverse_distance.rs

@@ -1,22 +1,9 @@
 use crate::impl_macros::macros::*;
-use crate::prelude::*;
 use crate::quantities::*;
-use ndarray::{Array1, Array2, ArrayView1, ArrayView2};
-use num_traits::identities::Zero;
-use num_traits::{Float, FromPrimitive};
-#[cfg(feature = "pyo3")]
-use pyo3::pyclass;
-#[cfg(feature = "serde")]
-use serde::{Deserialize, Serialize};
-use std::cmp::Ordering;
-use std::fmt;
-use std::ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Neg, Sub, SubAssign};
-#[cfg(feature = "strum")]
-use strum_macros::EnumIter;
 
 #[cfg_attr(feature = "strum", derive(EnumIter))]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-#[derive(Copy, Clone, PartialEq, Debug)]
+#[derive(Copy, Clone, PartialEq, Debug, Hash, Eq)]
 #[cfg_attr(feature = "pyo3", pyclass(eq, eq_int))]
 pub enum InverseDistanceUnit {
     _km,

{unitforge-0.3.13 → unitforge-0.3.15}/src/quantities/inverse_stress.rs

@@ -1,22 +1,9 @@
 use crate::impl_macros::macros::*;
-use crate::prelude::*;
 use crate::Stress;
-use ndarray::{Array1, Array2, ArrayView1, ArrayView2};
-use num_traits::identities::Zero;
-use num_traits::{Float, FromPrimitive};
-#[cfg(feature = "pyo3")]
-use pyo3::pyclass;
-#[cfg(feature = "serde")]
-use serde::{Deserialize, Serialize};
-use std::cmp::Ordering;
-use std::fmt;
-use std::ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Neg, Sub, SubAssign};
-#[cfg(feature = "strum")]
-use strum_macros::EnumIter;
 
 #[cfg_attr(feature = "strum", derive(EnumIter))]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-#[derive(Copy, Clone, PartialEq, Debug)]
+#[derive(Copy, Clone, PartialEq, Debug, Hash, Eq)]
 #[cfg_attr(feature = "pyo3", pyclass(eq, eq_int))]
 pub enum InverseStressUnit {
     _Pa,

{unitforge-0.3.13 → unitforge-0.3.15}/src/quantities/mass.rs

@@ -1,22 +1,9 @@
 use crate::impl_macros::macros::*;
-use crate::prelude::*;
 use crate::quantities::*;
-use ndarray::{Array1, Array2, ArrayView1, ArrayView2};
-use num_traits::identities::Zero;
-use num_traits::{Float, FromPrimitive};
-#[cfg(feature = "pyo3")]
-use pyo3::pyclass;
-#[cfg(feature = "serde")]
-use serde::{Deserialize, Serialize};
-use std::cmp::Ordering;
-use std::fmt;
-use std::ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Neg, Sub, SubAssign};
-#[cfg(feature = "strum")]
-use strum_macros::EnumIter;
 
 #[cfg_attr(feature = "strum", derive(EnumIter))]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-#[derive(Copy, Clone, PartialEq, Debug)]
+#[derive(Copy, Clone, PartialEq, Debug, Hash, Eq)]
 #[cfg_attr(feature = "pyo3", pyclass(eq, eq_int))]
 pub enum MassUnit {
     mg,

{unitforge-0.3.13 → unitforge-0.3.15}/src/quantities/mass_div_time_squared_volume.rs

@@ -1,21 +1,8 @@
 use crate::impl_macros::macros::*;
-use crate::prelude::*;
-use ndarray::{Array1, Array2, ArrayView1, ArrayView2};
-use num_traits::identities::Zero;
-use num_traits::{Float, FromPrimitive};
-#[cfg(feature = "pyo3")]
-use pyo3::pyclass;
-#[cfg(feature = "serde")]
-use serde::{Deserialize, Serialize};
-use std::cmp::Ordering;
-use std::fmt;
-use std::ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Neg, Sub, SubAssign};
-#[cfg(feature = "strum")]
-use strum_macros::EnumIter;
 
 #[cfg_attr(feature = "strum", derive(EnumIter))]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-#[derive(Copy, Clone, PartialEq, Debug)]
+#[derive(Copy, Clone, PartialEq, Debug, Hash, Eq)]
 #[cfg_attr(feature = "pyo3", pyclass(eq, eq_int))]
 pub enum MassDivTimeSquaredVolumeUnit {
     kg_ssqmq,

{unitforge-0.3.13 → unitforge-0.3.15}/src/quantities/mass_per_distance.rs

@@ -1,21 +1,8 @@
 use crate::impl_macros::macros::*;
-use crate::prelude::*;
-use ndarray::{Array1, Array2, ArrayView1, ArrayView2};
-use num_traits::identities::Zero;
-use num_traits::{Float, FromPrimitive};
-#[cfg(feature = "pyo3")]
-use pyo3::pyclass;
-#[cfg(feature = "serde")]
-use serde::{Deserialize, Serialize};
-use std::cmp::Ordering;
-use std::fmt;
-use std::ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Neg, Sub, SubAssign};
-#[cfg(feature = "strum")]
-use strum_macros::EnumIter;
 
 #[cfg_attr(feature = "strum", derive(EnumIter))]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-#[derive(Copy, Clone, PartialEq, Debug)]
+#[derive(Copy, Clone, PartialEq, Debug, Hash, Eq)]
 #[cfg_attr(feature = "pyo3", pyclass(eq, eq_int))]
 pub enum MassPerDistanceUnit {
     kg_m,

{unitforge-0.3.13 → unitforge-0.3.15}/src/quantities/rotational_stiffness.rs

@@ -1,22 +1,9 @@
 use crate::impl_macros::macros::*;
-use crate::prelude::*;
 use crate::PhysicsUnit;
-use ndarray::{Array1, Array2, ArrayView1, ArrayView2};
-use num_traits::identities::Zero;
-use num_traits::{Float, FromPrimitive};
-#[cfg(feature = "pyo3")]
-use pyo3::pyclass;
-#[cfg(feature = "serde")]
-use serde::{Deserialize, Serialize};
-use std::cmp::Ordering;
-use std::fmt;
-use std::ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Neg, Sub, SubAssign};
-#[cfg(feature = "strum")]
-use strum_macros::EnumIter;
 
 #[cfg_attr(feature = "strum", derive(EnumIter))]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-#[derive(Copy, Clone, PartialEq, Debug)]
+#[derive(Copy, Clone, PartialEq, Debug, Hash, Eq)]
 #[cfg_attr(feature = "pyo3", pyclass(eq, eq_int))]
 pub enum RotationalStiffnessUnit {
     Nmm_deg,

{unitforge-0.3.13 → unitforge-0.3.15}/src/quantities/stiffness.rs

@@ -1,22 +1,9 @@
 use crate::impl_macros::macros::*;
-use crate::prelude::*;
 use crate::PhysicsUnit;
-use ndarray::{Array1, Array2, ArrayView1, ArrayView2};
-use num_traits::identities::Zero;
-use num_traits::{Float, FromPrimitive};
-#[cfg(feature = "pyo3")]
-use pyo3::pyclass;
-#[cfg(feature = "serde")]
-use serde::{Deserialize, Serialize};
-use std::cmp::Ordering;
-use std::fmt;
-use std::ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Neg, Sub, SubAssign};
-#[cfg(feature = "strum")]
-use strum_macros::EnumIter;
 
 #[cfg_attr(feature = "strum", derive(EnumIter))]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-#[derive(Copy, Clone, PartialEq, Debug)]
+#[derive(Copy, Clone, PartialEq, Debug, Hash, Eq)]
 #[cfg_attr(feature = "pyo3", pyclass(eq, eq_int))]
 pub enum StiffnessUnit {
     N_mm,

{unitforge-0.3.13 → unitforge-0.3.15}/src/quantities/strain.rs

@@ -1,22 +1,9 @@
 use crate::impl_macros::macros::*;
-use crate::prelude::*;
 use crate::{Distance, PhysicsUnit, Stress};
-use ndarray::{Array1, Array2, ArrayView1, ArrayView2};
-use num_traits::identities::Zero;
-use num_traits::{Float, FromPrimitive};
-#[cfg(feature = "pyo3")]
-use pyo3::pyclass;
-#[cfg(feature = "serde")]
-use serde::{Deserialize, Serialize};
-use std::cmp::Ordering;
-use std::fmt;
-use std::ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Neg, Sub, SubAssign};
-#[cfg(feature = "strum")]
-use strum_macros::EnumIter;
 
 #[cfg_attr(feature = "strum", derive(EnumIter))]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-#[derive(Copy, Clone, PartialEq, Debug)]
+#[derive(Copy, Clone, PartialEq, Debug, Hash, Eq)]
 #[cfg_attr(feature = "pyo3", pyclass(eq, eq_int))]
 pub enum StrainUnit {
     m_m,

{unitforge-0.3.13 → unitforge-0.3.15}/src/quantities/stress.rs

@@ -1,22 +1,9 @@
 use crate::impl_macros::macros::*;
-use crate::prelude::*;
 use crate::quantities::*;
-use ndarray::{Array1, Array2, ArrayView1, ArrayView2};
-use num_traits::identities::Zero;
-use num_traits::{Float, FromPrimitive};
-#[cfg(feature = "pyo3")]
-use pyo3::pyclass;
-#[cfg(feature = "serde")]
-use serde::{Deserialize, Serialize};
-use std::cmp::Ordering;
-use std::fmt;
-use std::ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Neg, Sub, SubAssign};
-#[cfg(feature = "strum")]
-use strum_macros::EnumIter;
 
 #[cfg_attr(feature = "strum", derive(EnumIter))]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-#[derive(Copy, Clone, PartialEq, Debug)]
+#[derive(Copy, Clone, PartialEq, Debug, Hash, Eq)]
 #[cfg_attr(feature = "pyo3", pyclass(eq, eq_int))]
 pub enum StressUnit {
     Pa,

{unitforge-0.3.13 → unitforge-0.3.15}/src/quantities/stress_squared.rs

@@ -1,21 +1,8 @@
 use crate::impl_macros::macros::*;
-use crate::prelude::*;
-use ndarray::{Array1, Array2, ArrayView1, ArrayView2};
-use num_traits::identities::Zero;
-use num_traits::{Float, FromPrimitive};
-#[cfg(feature = "pyo3")]
-use pyo3::pyclass;
-#[cfg(feature = "serde")]
-use serde::{Deserialize, Serialize};
-use std::cmp::Ordering;
-use std::fmt;
-use std::ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Neg, Sub, SubAssign};
-#[cfg(feature = "strum")]
-use strum_macros::EnumIter;
 
 #[cfg_attr(feature = "strum", derive(EnumIter))]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-#[derive(Copy, Clone, PartialEq, Debug)]
+#[derive(Copy, Clone, PartialEq, Debug, Hash, Eq)]
 #[cfg_attr(feature = "pyo3", pyclass(eq, eq_int))]
 pub enum StressSquaredUnit {
     Nsq_mmhc,

{unitforge-0.3.13 → unitforge-0.3.15}/src/quantities/time.rs

@@ -1,21 +1,8 @@
 use crate::impl_macros::macros::*;
-use crate::prelude::*;
-use ndarray::{Array1, Array2, ArrayView1, ArrayView2};
-use num_traits::identities::Zero;
-use num_traits::{Float, FromPrimitive};
-#[cfg(feature = "pyo3")]
-use pyo3::pyclass;
-#[cfg(feature = "serde")]
-use serde::{Deserialize, Serialize};
-use std::cmp::Ordering;
-use std::fmt;
-use std::ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Neg, Sub, SubAssign};
-#[cfg(feature = "strum")]
-use strum_macros::EnumIter;
 
 #[cfg_attr(feature = "strum", derive(EnumIter))]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-#[derive(Copy, Clone, PartialEq, Debug)]
+#[derive(Copy, Clone, PartialEq, Debug, Hash, Eq)]
 #[cfg_attr(feature = "pyo3", pyclass(eq, eq_int))]
 pub enum TimeUnit {
     ns,

{unitforge-0.3.13 → unitforge-0.3.15}/src/quantities/velocity.rs

@@ -1,21 +1,8 @@
 use crate::impl_macros::macros::*;
-use crate::prelude::*;
-use ndarray::{Array1, Array2, ArrayView1, ArrayView2};
-use num_traits::identities::Zero;
-use num_traits::{Float, FromPrimitive};
-#[cfg(feature = "pyo3")]
-use pyo3::pyclass;
-#[cfg(feature = "serde")]
-use serde::{Deserialize, Serialize};
-use std::cmp::Ordering;
-use std::fmt;
-use std::ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Neg, Sub, SubAssign};
-#[cfg(feature = "strum")]
-use strum_macros::EnumIter;
 
 #[cfg_attr(feature = "strum", derive(EnumIter))]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-#[derive(Copy, Clone, PartialEq, Debug)]
+#[derive(Copy, Clone, PartialEq, Debug, Hash, Eq)]
 #[cfg_attr(feature = "pyo3", pyclass(eq, eq_int))]
 pub enum VelocityUnit {
     km_s,

{unitforge-0.3.13 → unitforge-0.3.15}/src/quantities/velocity_squared.rs

@@ -1,22 +1,9 @@
 use crate::impl_macros::macros::*;
-use crate::prelude::*;
 use crate::quantities::*;
-use ndarray::{Array1, Array2, ArrayView1, ArrayView2};
-use num_traits::identities::Zero;
-use num_traits::{Float, FromPrimitive};
-#[cfg(feature = "pyo3")]
-use pyo3::pyclass;
-#[cfg(feature = "serde")]
-use serde::{Deserialize, Serialize};
-use std::cmp::Ordering;
-use std::fmt;
-use std::ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Neg, Sub, SubAssign};
-#[cfg(feature = "strum")]
-use strum_macros::EnumIter;
 
 #[cfg_attr(feature = "strum", derive(EnumIter))]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-#[derive(Copy, Clone, PartialEq, Debug)]
+#[derive(Copy, Clone, PartialEq, Debug, Hash, Eq)]
 #[cfg_attr(feature = "pyo3", pyclass(eq, eq_int))]
 pub enum VelocitySquaredUnit {
     msq_ssq,

{unitforge-0.3.13 → unitforge-0.3.15}/src/quantities/voltage.rs

@@ -1,21 +1,8 @@
 use crate::impl_macros::macros::*;
-use crate::prelude::*;
-use ndarray::{Array1, Array2, ArrayView1, ArrayView2};
-use num_traits::identities::Zero;
-use num_traits::{Float, FromPrimitive};
-#[cfg(feature = "pyo3")]
-use pyo3::pyclass;
-#[cfg(feature = "serde")]
-use serde::{Deserialize, Serialize};
-use std::cmp::Ordering;
-use std::fmt;
-use std::ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Neg, Sub, SubAssign};
-#[cfg(feature = "strum")]
-use strum_macros::EnumIter;
 
 #[cfg_attr(feature = "strum", derive(EnumIter))]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-#[derive(Copy, Clone, PartialEq, Debug)]
+#[derive(Copy, Clone, PartialEq, Debug, Hash, Eq)]
 #[cfg_attr(feature = "pyo3", pyclass(eq, eq_int))]
 pub enum VoltageUnit {
     V,

{unitforge-0.3.13 → unitforge-0.3.15}/src/quantities/volume.rs

@@ -1,21 +1,8 @@
 use crate::impl_macros::macros::*;
-use crate::prelude::*;
-use ndarray::{Array1, Array2, ArrayView1, ArrayView2};
-use num_traits::identities::Zero;
-use num_traits::{Float, FromPrimitive};
-#[cfg(feature = "pyo3")]
-use pyo3::pyclass;
-#[cfg(feature = "serde")]
-use serde::{Deserialize, Serialize};
-use std::cmp::Ordering;
-use std::fmt;
-use std::ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Neg, Sub, SubAssign};
-#[cfg(feature = "strum")]
-use strum_macros::EnumIter;
 
 #[cfg_attr(feature = "strum", derive(EnumIter))]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-#[derive(Copy, Clone, PartialEq, Debug)]
+#[derive(Copy, Clone, PartialEq, Debug, Hash, Eq)]
 #[cfg_attr(feature = "pyo3", pyclass(eq, eq_int))]
 pub enum VolumeUnit {
     kmcb,

{unitforge-0.3.13 → unitforge-0.3.15}/src/tests/quantity_unit_tests.rs

@@ -105,7 +105,28 @@ mod tests {
     #[test]
     fn test_optimal_unit() {
         let area = Area::new(0.0001, AreaUnit::msq);
-        let optimal_unit = area.optimal_unit().unwrap();
+        let optimal_unit = area.optimal_unit(None).unwrap();
+        assert_eq!(optimal_unit, AreaUnit::cmsq)
+    }
+
+    #[cfg(feature = "strum")]
+    #[test]
+    fn test_optimal_unit_with_selection_strum() {
+        let area = Area::new(0.0001, AreaUnit::msq);
+        let optimal_unit = area.optimal_unit(Some(vec![AreaUnit::kmsq, AreaUnit::cmsq, AreaUnit::nmsq].into_iter().collect())).unwrap();
+        assert_eq!(optimal_unit, AreaUnit::cmsq)
+    }
+
+    #[test]
+    fn test_optimal_unit_with_selection() {
+        let area = Area::new(0.0001, AreaUnit::msq);
+        let optimal_unit = area
+            .optimal_unit(
+                vec![AreaUnit::kmsq, AreaUnit::cmsq, AreaUnit::nmsq]
+                    .into_iter()
+                    .collect::<std::collections::HashSet<_>>(),
+            )
+            .unwrap();
         assert_eq!(optimal_unit, AreaUnit::cmsq)
     }
 }

{unitforge-0.3.13 → unitforge-0.3.15}/unitforge_macros/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "unitforge_macros"
-version = "0.3.13"
+version = "0.3.15"
 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.3.13 → unitforge-0.3.15}/unitforge_macros/src/lib.rs

@@ -244,6 +244,75 @@ fn parse_unit_variants(files: &[String], unit_name: &str) -> Result<Vec<String>,
     Err(format!("Enum {unit_name} not found in quantity source files"))
 }
 
+fn fnv1a32(input: &str) -> u32 {
+    const OFFSET_BASIS: u32 = 0x811C9DC5;
+    const FNV_PRIME: u32 = 0x01000193;
+
+    let mut hash = OFFSET_BASIS;
+    for byte in input.as_bytes() {
+        hash ^= *byte as u32;
+        hash = hash.wrapping_mul(FNV_PRIME);
+    }
+    hash
+}
+
+fn stable_non_zero_hash(namespace: &str, name: &str) -> u32 {
+    let key = format!("{namespace}:{name}");
+    let mut hash = fnv1a32(&key);
+    if hash == 0 {
+        hash = fnv1a32(&format!("{key}#"));
+        if hash == 0 {
+            hash = 1;
+        }
+    }
+    hash
+}
+
+fn stable_quantity_kind_id(quantity_name: &str) -> u32 {
+    stable_non_zero_hash("unitforge.quantity", quantity_name)
+}
+
+fn stable_unit_variant_id(unit_name: &str, variant_name: &str) -> i32 {
+    let hash = stable_non_zero_hash(
+        "unitforge.unit_variant",
+        &format!("{unit_name}.{variant_name}"),
+    );
+    (hash & 0x7FFF_FFFF) as i32
+}
+
+fn ensure_stable_id_collisions(
+    quantity_names: &[String],
+    unit_variants_by_name: &HashMap<String, Vec<String>>,
+) -> Result<(), String> {
+    let mut quantity_ids: HashMap<u32, String> = HashMap::new();
+    for quantity_name in quantity_names {
+        let id = stable_quantity_kind_id(quantity_name);
+        if let Some(existing) = quantity_ids.insert(id, quantity_name.clone()) {
+            if existing != *quantity_name {
+                return Err(format!(
+                    "Quantity kind id collision: '{existing}' and '{quantity_name}' both map to id {id}"
+                ));
+            }
+        }
+    }
+
+    for (unit_name, variants) in unit_variants_by_name {
+        let mut variant_ids: HashMap<i32, String> = HashMap::new();
+        for variant_name in variants {
+            let id = stable_unit_variant_id(unit_name, variant_name);
+            if let Some(existing) = variant_ids.insert(id, variant_name.clone()) {
+                if existing != *variant_name {
+                    return Err(format!(
+                        "Unit variant id collision in {unit_name}: '{existing}' and '{variant_name}' both map to id {id}"
+                    ));
+                }
+            }
+        }
+    }
+
+    Ok(())
+}
+
 fn write_quantity_code(
     template: &str,
     files: &[String],
@@ -283,6 +352,7 @@ fn write_quantity_code(
         let variants = parse_unit_variants(files, &unit_name)?;
         unit_variants_by_name.insert(unit_name, variants);
     }
+    ensure_stable_id_collisions(quantity_names, &unit_variants_by_name)?;
 
     let mul_macro_re = Regex::new(r"impl_mul!\(\s*(\w+),\s*(\w+),\s*(\w+)\)").unwrap();
     let div_macro_re = Regex::new(r"impl_div!\(\s*(\w+),\s*(\w+),\s*(\w+)\)").unwrap();
@@ -294,8 +364,8 @@ fn write_quantity_code(
     let mul_self_rel_re = Regex::new(r"impl_mul_relation_with_self!\(\s*(\w+),\s*(\w+)\)").unwrap();
 
     let mut first = true;
-    for (index, struct_name) in quantity_names.iter().enumerate() {
-        let quantity_kind_id = (index + 1) as u32;
+    for struct_name in quantity_names {
+        let quantity_kind_id = stable_quantity_kind_id(struct_name);
         let unit_name = format!("{struct_name}Unit");
         let unit_variant_list = unit_variants_by_name
             .get(&unit_name)
@@ -371,12 +441,13 @@ fn write_quantity_code(
 
         let mut variant_to_id_match = String::new();
         let mut id_to_variant_match = String::new();
-        for (variant_index, variant_name) in unit_variant_list.iter().enumerate() {
+        for variant_name in unit_variant_list {
+            let variant_id = stable_unit_variant_id(&unit_name, variant_name);
             variant_to_id_match += &format!(
-                "            {struct_name}Unit::{variant_name} => {variant_index},\n"
+                "            {struct_name}Unit::{variant_name} => {variant_id},\n"
             );
             id_to_variant_match += &format!(
-                "            {variant_index} => Some({struct_name}Unit::{variant_name}),\n"
+                "            {variant_id} => Some({struct_name}Unit::{variant_name}),\n"
             );
         }
         unit_variant_id_impls += &format!(