unitforge 0.5.4__tar.gz → 0.5.6__tar.gz

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

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

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

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

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

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

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

@@ -2066,6 +2066,8 @@ class Strain:
     @overload
     def __mul__(self, rhs: "Distance") -> "Distance": ...
     @overload
+    def __mul__(self, rhs: "Strain") -> "StrainSquared": ...
+    @overload
     def __mul__(self, rhs: "Stress") -> "Stress": ...
     @overload
     def __mul__(self, rhs: Any) -> Any: ...
@@ -2085,6 +2087,47 @@ class Strain:
     def __repr__(self) -> str: ...
     def __str__(self) -> str: ...
 
+class StrainSquaredUnit:
+    msq_msq: ClassVar["StrainSquaredUnit"]
+
+class StrainSquared:
+    def __init__(self, value: float, unit: "StrainSquaredUnit") -> None: ...
+    @classmethod
+    def zero(cls: Type["StrainSquared"]) -> "StrainSquared": ...
+    def to(self, unit: "StrainSquaredUnit") -> float: ...
+    def close_abs(self, other: "StrainSquared", threshold: "StrainSquared") -> bool: ...
+    def close_rel(self, other: "StrainSquared", threshold: float) -> bool: ...
+    def __neg__(self) -> "StrainSquared": ...
+    def __abs__(self) -> "StrainSquared": ...
+    def __add__(self, rhs: "StrainSquared") -> "StrainSquared": ...
+    def __sub__(self, rhs: "StrainSquared") -> "StrainSquared": ...
+    @overload
+    def __mul__(self, rhs: float) -> "StrainSquared": ...
+    @overload
+    def __mul__(self, rhs: Vector3) -> Vector3: ...
+    @overload
+    def __mul__(self, rhs: Any) -> Any: ...
+    @overload
+    def __truediv__(self, rhs: float) -> "StrainSquared": ...
+    @overload
+    def __truediv__(self, rhs: "Strain") -> "Strain": ...
+    @overload
+    def __truediv__(self, rhs: "StrainSquared") -> float: ...
+    @overload
+    def __truediv__(self, rhs: Any) -> Any: ...
+    @overload
+    def __mod__(self, rhs: float) -> "StrainSquared": ...
+    @overload
+    def __mod__(self, rhs: "Strain") -> "Strain": ...
+    @overload
+    def __mod__(self, rhs: "StrainSquared") -> float: ...
+    @overload
+    def __mod__(self, rhs: Any) -> Any: ...
+    def __rmul__(self, rhs: float) -> "StrainSquared": ...
+    def __repr__(self) -> str: ...
+    def __str__(self) -> str: ...
+    def sqrt(self) -> "Strain": ...
+
 class StressUnit:
     Pa: ClassVar["StressUnit"]
     kPa: ClassVar["StressUnit"]

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

@@ -44,6 +44,18 @@ macro_rules! impl_quantity {
             pub(crate) kind_id: u32,
         }
 
+        impl core::hash::Hash for $type {
+            #[cfg(not(any(feature = "storage-f64", feature = "storage-f32")))]
+            fn hash<H: core::hash::Hasher>(&self, state: &mut H) {
+                core::hash::Hash::hash(&self.multiplier.to_bits(), state);
+                core::hash::Hash::hash(&self.power, state);
+            }
+            #[cfg(any(feature = "storage-f64", feature = "storage-f32"))]
+            fn hash<H: core::hash::Hasher>(&self, state: &mut H) {
+                core::hash::Hash::hash(&self.value.to_bits(), state);
+            }
+        }
+
         impl $type {
             #[cfg(not(any(feature = "storage-f64", feature = "storage-f32")))]
             fn from_parts(multiplier: f64, power: i32) -> Self {

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

@@ -119,6 +119,8 @@ pub mod quantities {
     pub use rotational_stiffness::*;
     pub mod strain;
     pub use strain::*;
+    pub mod strain_squared;
+    pub use strain_squared::*;
     pub mod stress;
     pub use stress::*;
     pub mod stress_cubed;

unitforge-0.5.6/src/quantities/strain_squared.rs

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

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

@@ -82,6 +82,7 @@ impl_mul!(Stress, Strain, Stress);
 impl_mul_relation_with_self!(Distance, Area);
 impl_mul_relation_with_self!(Area, AreaOfMoment);
 impl_mul_relation_with_self!(InverseDistance, InverseArea);
+impl_mul_relation_with_self!(Strain, StrainSquared);
 impl_mul_relation_with_self!(Stress, StressSquared);
 impl_mul_relation_with_other!(Stress, StressSquared, StressCubed);
 impl_div!(StressSquared, StressCubed, InverseStress);

{unitforge-0.5.4 → unitforge-0.5.6}/tests/quantity_core/relations.rs

@@ -6,6 +6,8 @@ use unitforge::quantities::{
     InverseStress, InverseStressUnit, Stress, StressSquared, StressSquaredUnit, StressUnit,
 };
 #[cfg(not(any(feature = "storage-f64", feature = "storage-f32")))]
+use unitforge::quantities::{Strain, StrainSquaredUnit, StrainUnit};
+#[cfg(not(any(feature = "storage-f64", feature = "storage-f32")))]
 use unitforge::Sqrt;
 use unitforge::{PhysicsQuantity, Quantity, Unit};
 
@@ -76,3 +78,14 @@ fn force_stress_from_stress_squared_times_area() {
 
     assert!(approx_eq(result.to(ForceStressUnit::Nsq_msq), 6.0, 1e-12));
 }
+
+#[test]
+#[cfg(not(any(feature = "storage-f64", feature = "storage-f32")))]
+fn strain_squared_relations() {
+    let strain = Strain::new(2.0, StrainUnit::m_m);
+    let strain_squared = strain * strain;
+
+    assert_eq!(strain_squared.to(StrainSquaredUnit::msq_msq), 4.0);
+    assert_eq!(strain_squared / strain, strain);
+    assert_eq!(strain_squared.sqrt(), strain);
+}

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

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