unitforge 0.3.14__tar.gz → 0.3.16__tar.gz

{unitforge-0.3.14 → unitforge-0.3.16}/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.14"
+version = "0.3.16"
 dependencies = [
  "ndarray",
  "num-traits",
@@ -384,7 +384,7 @@ dependencies = [
 
 [[package]]
 name = "unitforge_macros"
-version = "0.3.14"
+version = "0.3.16"
 dependencies = [
  "regex",
 ]

{unitforge-0.3.14 → unitforge-0.3.16}/Cargo.toml

@@ -4,7 +4,7 @@ crate-type = ["cdylib", "rlib"]
 
 [package]
 name = "unitforge"
-version = "0.3.14"
+version = "0.3.16"
 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.14", path = "unitforge_macros" }
+strum = { version = "0.28.0", optional = true }
+strum_macros = { version = "0.28.0", optional = true }
+unitforge_macros = { version = "0.3.16", path = "unitforge_macros" }
 
 [features]
 serde = ["dep:serde", "dep:serde_json", "ndarray/serde"]

{unitforge-0.3.14 → unitforge-0.3.16}/PKG-INFO

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

{unitforge-0.3.14 → unitforge-0.3.16}/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 num_traits::{Float, FromPrimitive};
+        #[cfg(feature = "serde")]
+        use serde::{Deserialize, Serialize};
+        use std::cmp::Ordering;
+        use std::collections::HashSet;
+        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,
@@ -8,7 +21,7 @@ macro_rules! impl_quantity {
         };
 
         #[cfg(feature = "strum")]
-        use strum::IntoEnumIterator;
+        use strum_macros::EnumIter;
         use $crate::small_linalg::{Matrix3, Vector3};
         #[cfg(feature = "pyo3")]
         use $crate::Quantity;
@@ -579,15 +592,14 @@ macro_rules! impl_quantity {
             }
         }
 
-        #[cfg(feature = "strum")]
         impl $type {
-            pub fn optimal_unit(&self) -> Option<$unit> {
-                let mut min_value = f64::INFINITY;
+            pub fn optimal_unit(&self, choices: HashSet<$unit>) -> Option<$unit> {
+                let mut min_value = i32::MAX;
                 let mut best_unit = None;
-                for unit in $unit::iter() {
-                    let deviation = (self.to(unit).abs() - 1.).abs();
-                    if deviation < min_value {
-                        min_value = deviation;
+                for unit in choices {
+                    let difference = (self.power - unit.base_per_x().1).abs();
+                    if difference < min_value {
+                        min_value = difference;
                         best_unit = Some(unit);
                     }
                 }

{unitforge-0.3.14 → unitforge-0.3.16}/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.14 → unitforge-0.3.16}/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.14 → unitforge-0.3.16}/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.14 → unitforge-0.3.16}/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.14 → unitforge-0.3.16}/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.14 → unitforge-0.3.16}/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.14 → unitforge-0.3.16}/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.14 → unitforge-0.3.16}/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.14 → unitforge-0.3.16}/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.14 → unitforge-0.3.16}/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.14 → unitforge-0.3.16}/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.14 → unitforge-0.3.16}/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.14 → unitforge-0.3.16}/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.14 → unitforge-0.3.16}/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.14 → unitforge-0.3.16}/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.14 → unitforge-0.3.16}/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.14 → unitforge-0.3.16}/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.14 → unitforge-0.3.16}/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.14 → unitforge-0.3.16}/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.14 → unitforge-0.3.16}/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.14 → unitforge-0.3.16}/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.14 → unitforge-0.3.16}/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.14 → unitforge-0.3.16}/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.14 → unitforge-0.3.16}/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.14 → unitforge-0.3.16}/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.14 → unitforge-0.3.16}/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.14 → unitforge-0.3.16}/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.14 → unitforge-0.3.16}/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.14 → unitforge-0.3.16}/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.14 → unitforge-0.3.16}/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.14 → unitforge-0.3.16}/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.14 → unitforge-0.3.16}/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.14 → unitforge-0.3.16}/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.14 → unitforge-0.3.16}/src/tests/quantity_unit_tests.rs

@@ -101,11 +101,16 @@ mod tests {
         assert!((result.to(ForceStressUnit::Nsq_msq) - 6.0).abs() < 1E-12);
     }
 
-    #[cfg(feature = "strum")]
     #[test]
-    fn test_optimal_unit() {
+    fn test_optimal_unit_with_selection() {
         let area = Area::new(0.0001, AreaUnit::msq);
-        let optimal_unit = area.optimal_unit().unwrap();
+        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.14 → unitforge-0.3.16}/unitforge_macros/Cargo.toml

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

@@ -241,7 +241,9 @@ fn parse_unit_variants(files: &[String], unit_name: &str) -> Result<Vec<String>,
         }
     }
 
-    Err(format!("Enum {unit_name} not found in quantity source files"))
+    Err(format!(
+        "Enum {unit_name} not found in quantity source files"
+    ))
 }
 
 fn fnv1a32(input: &str) -> u32 {
@@ -443,12 +445,10 @@ fn write_quantity_code(
         let mut id_to_variant_match = String::new();
         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_id},\n"
-            );
-            id_to_variant_match += &format!(
-                "            {variant_id} => Some({struct_name}Unit::{variant_name}),\n"
-            );
+            variant_to_id_match +=
+                &format!("            {struct_name}Unit::{variant_name} => {variant_id},\n");
+            id_to_variant_match +=
+                &format!("            {variant_id} => Some({struct_name}Unit::{variant_name}),\n");
         }
         unit_variant_id_impls += &format!(
             "impl pyo3_capsule_api::UnitVariantId for {struct_name}Unit {{\n    fn to_variant_id(self) -> i32 {{\n        match self {{\n{variant_to_id_match}        }}\n    }}\n    fn from_variant_id(variant_id: i32) -> Option<Self> {{\n        match variant_id {{\n{id_to_variant_match}            _ => None,\n        }}\n    }}\n}}\n"
@@ -559,7 +559,10 @@ fn write_quantity_code(
         .replace("// __UNIT_KIND_ID_IMPLS__", &unit_kind_id_impls)
         .replace("// __UNIT_VARIANT_ID_IMPLS__", &unit_variant_id_impls)
         .replace("// __QUANTITY_TO_REPR_MATCHES__", &quantity_to_repr_matches)
-        .replace("// __QUANTITY_FROM_REPR_MATCHES__", &quantity_from_repr_matches)
+        .replace(
+            "// __QUANTITY_FROM_REPR_MATCHES__",
+            &quantity_from_repr_matches,
+        )
         .replace("// __UNIT_TO_REPR_MATCHES__", &unit_to_repr_matches)
         .replace("// __UNIT_FROM_REPR_MATCHES__", &unit_from_repr_matches)
         .replace("// __UNIT_TO_PYOBJECT_MATCHES__", &unit_to_pyobject_matches))