unitforge 0.4.3__tar.gz → 0.5.1__tar.gz

{unitforge-0.4.3 → unitforge-0.5.1}/Cargo.lock

@@ -231,9 +231,9 @@ checksum = "60a357793950651c4ed0f3f52338f53b2f809f32d83a07f72909fa13e4c6c1e3"
 
 [[package]]
 name = "regex"
-version = "1.11.1"
+version = "1.12.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b544ef1b4eac5dc2db33ea63606ae9ffcfac26c1416a2806ae0bf5f56b201191"
+checksum = "e10754a14b9137dd7b1e3e5b0493cc9171fdd105e0ab477f51b72e7f3ac0e276"
 dependencies = [
  "aho-corasick",
  "memchr",
@@ -243,9 +243,9 @@ dependencies = [
 
 [[package]]
 name = "regex-automata"
-version = "0.4.9"
+version = "0.4.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "809e8dc61f6de73b46c85f4c96486310fe304c434cfa43669d7b40f711150908"
+checksum = "6e1dd4122fc1595e8162618945476892eefca7b88c52820e74af6262213cae8f"
 dependencies = [
  "aho-corasick",
  "memchr",
@@ -351,7 +351,7 @@ checksum = "5a5f39404a5da50712a4c1eecf25e90dd62b613502b7e925fd4e4d19b5c96512"
 
 [[package]]
 name = "unitforge"
-version = "0.4.3"
+version = "0.5.1"
 dependencies = [
  "ndarray",
  "num-traits",
@@ -367,7 +367,7 @@ dependencies = [
 
 [[package]]
 name = "unitforge_macros"
-version = "0.4.3"
+version = "0.5.1"
 dependencies = [
  "regex",
 ]

{unitforge-0.4.3 → unitforge-0.5.1}/Cargo.toml

@@ -1,10 +1,6 @@
-[lib]
-name = "unitforge"
-crate-type = ["cdylib", "rlib"]
-
 [package]
 name = "unitforge"
-version = "0.4.3"
+version = "0.5.1"
 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"
@@ -24,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.4.3", path = "unitforge_macros" }
+unitforge_macros = { version = "0.5.1", path = "unitforge_macros" }
 
 [features]
 default = []
@@ -38,6 +34,3 @@ no_std = []
 
 [workspace]
 members = ["unitforge_macros"]
-
-[profile.dev]
-panic = "abort"

{unitforge-0.4.3 → unitforge-0.5.1}/PKG-INFO

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

{unitforge-0.4.3 → unitforge-0.5.1}/scripts/generate_python_stubs.py

@@ -274,7 +274,9 @@ def render_vector3_stub() -> List[str]:
         '    def dot_vec(self, other: "Vector3") -> Any: ...',
         '    def cross(self, other: "Vector3") -> "Vector3": ...',
         "    def __mul__(self, rhs: Any) -> Vector3: ...",
+        "    def __imul__(self, rhs: Any) -> None: ...",
         "    def __truediv__(self, rhs: Any) -> Vector3: ...",
+        "    def __itruediv__(self, rhs: Any) -> None: ...",
     ]
 
 
@@ -341,6 +343,8 @@ def render_quantity_stub(
         f'    def __sub__(self, rhs: "{q}") -> "{q}": ...',
         "    @overload",
         f'    def __mul__(self, rhs: float) -> "{q}": ...',
+        "    @overload",
+        "    def __mul__(self, rhs: Vector3) -> Vector3: ...",
     ]
 
     mul_ops = operator_maps.mul.get(q, {})

{unitforge-0.4.3 → unitforge-0.5.1}/src/impl_macros.rs

@@ -16,8 +16,11 @@ macro_rules! impl_quantity {
         use pyo3::pyclass;
         #[cfg(feature = "pyo3")]
         use pyo3::{
-            basic::CompareOp, exceptions::PyValueError, pymethods, types::PyType, Bound,
-            IntoPyObject, Py, PyAny, PyRef, PyResult,
+            basic::CompareOp,
+            exceptions::PyTypeError,
+            pymethods,
+            types::{PyAnyMethods, PyType},
+            Bound, IntoPyObject, Py, PyAny, PyRef, PyResult,
         };
 
         #[cfg(feature = "strum")]
@@ -395,13 +398,21 @@ macro_rules! impl_quantity {
                 let py = lhs.py();
                 let rhs_ref = rhs.bind(py);
                 let lhs_ref = lhs.into_pyobject(py)?;
-                let rhs_quantity = Quantity::from_py_any(rhs_ref)
-                    .map_err(|e| PyValueError::new_err(e.to_string()))?;
                 let lhs_quantity = Quantity::from_py_any(&lhs_ref)
-                    .map_err(|e| PyValueError::new_err(e.to_string()))?;
+                    .map_err(|e| PyTypeError::new_err(e.to_string()))?;
+                if let Ok(rhs_vector) = rhs_ref.extract::<$crate::Vector3Py>() {
+                    return Ok(rhs_vector
+                        .mul_quantity_left(lhs_quantity)?
+                        .into_pyobject(py)?
+                        .into_any()
+                        .unbind());
+                }
+
+                let rhs_quantity = Quantity::from_py_any(rhs_ref)
+                    .map_err(|e| PyTypeError::new_err(e.to_string()))?;
                 match lhs_quantity * rhs_quantity {
                     Ok(value) => Ok(value.to_pyobject(py)?),
-                    Err(_) => Err(PyValueError::new_err(
+                    Err(_) => Err(PyTypeError::new_err(
                         "Multiplication of given objects is not possible.",
                     )),
                 }
@@ -412,12 +423,12 @@ macro_rules! impl_quantity {
                 let rhs_ref = rhs.bind(py);
                 let lhs_ref = lhs.into_pyobject(py)?;
                 let rhs_quantity = Quantity::from_py_any(rhs_ref)
-                    .map_err(|e| PyValueError::new_err(e.to_string()))?;
+                    .map_err(|e| PyTypeError::new_err(e.to_string()))?;
                 let lhs_quantity = Quantity::from_py_any(&lhs_ref)
-                    .map_err(|e| PyValueError::new_err(e.to_string()))?;
+                    .map_err(|e| PyTypeError::new_err(e.to_string()))?;
                 match lhs_quantity / rhs_quantity {
                     Ok(value) => Ok(value.to_pyobject(py)?),
-                    Err(_) => Err(PyValueError::new_err(
+                    Err(_) => Err(PyTypeError::new_err(
                         "Division of given objects is not possible.",
                     )),
                 }
@@ -435,10 +446,10 @@ macro_rules! impl_quantity {
                 let py = lhs.py();
                 let lhs_ref = lhs.into_pyobject(py)?;
                 let lhs_quantity = Quantity::from_py_any(&lhs_ref)
-                    .map_err(|e| PyValueError::new_err(e.to_string()))?;
+                    .map_err(|e| PyTypeError::new_err(e.to_string()))?;
                 match lhs_quantity.powi(rhs) {
                     Ok(value) => Ok(value.to_pyobject(py)?),
-                    Err(_) => Err(PyValueError::new_err(
+                    Err(_) => Err(PyTypeError::new_err(
                         "Power of given object is not possible.",
                     )),
                 }

{unitforge-0.4.3 → unitforge-0.5.1}/src/lib.rs

@@ -1,37 +1,6 @@
-#![cfg_attr(
-    all(
-        feature = "no_std",
-        any(feature = "storage-f64", feature = "storage-f32"),
-        not(all(feature = "storage-f64", feature = "storage-f32")),
-        not(any(
-            feature = "serde",
-            feature = "ndarray",
-            feature = "pyo3",
-            feature = "strum"
-        ))
-    ),
-    no_std
-)]
+#![cfg_attr(feature = "no_std", no_std)]
 #![allow(non_camel_case_types)]
 
-#[cfg(all(
-    feature = "no_std",
-    any(feature = "storage-f64", feature = "storage-f32"),
-    not(all(feature = "storage-f64", feature = "storage-f32")),
-    not(any(
-        feature = "serde",
-        feature = "ndarray",
-        feature = "pyo3",
-        feature = "strum"
-    )),
-    not(test),
-    not(target_os = "none")
-))]
-#[panic_handler]
-fn panic(_info: &core::panic::PanicInfo<'_>) -> ! {
-    loop {}
-}
-
 #[cfg(all(feature = "storage-f64", feature = "storage-f32"))]
 compile_error!("features `storage-f64` and `storage-f32` are mutually exclusive");
 

{unitforge-0.4.3 → unitforge-0.5.1}/src/quantities.template.rs

@@ -207,10 +207,9 @@ fn extract_f64(v: &Bound<PyAny>) -> Option<f64> {
 #[cfg(feature = "pyo3")]
 impl Quantity {
     pub fn from_py_any(v: &Bound<PyAny>) -> crate::QuantityConversionResult<Self> {
-        if let Some(inner) = extract_f64(v) {
-            Ok(Quantity::FloatQuantity(inner))
+        if let Ok(inner) = Self::from_py_any_direct(v) {
+            Ok(inner)
         }
-        // __EXTRACT_QUANTITY_MATCHES__
         else if let Ok(inner) = pyo3_capsule_api::extract_quantity_from_capsule(v) {
             Ok(inner)
         }
@@ -219,6 +218,16 @@ impl Quantity {
         }
     }
 
+    pub(crate) fn from_py_any_direct(v: &Bound<PyAny>) -> crate::QuantityConversionResult<Self> {
+        if let Some(inner) = extract_f64(v) {
+            Ok(Quantity::FloatQuantity(inner))
+        }
+        // __EXTRACT_QUANTITY_MATCHES__
+        else {
+            Err(crate::QuantityConversionError::InvalidPythonQuantity)
+        }
+    }
+
     pub fn to_pyobject(self, py: Python) -> PyResult<Py<PyAny>> {
         Ok(match self {
             Quantity::FloatQuantity(v) => v.into_pyobject(py).map(|obj| obj.into())?,
@@ -240,7 +249,9 @@ impl Display for Quantity {
 impl Unit {
 
     pub fn from_py_any(v: &Bound<PyAny>) -> crate::QuantityConversionResult<Self> {
-        // __EXTRACT_UNIT_MATCHES__
+        if let Ok(inner) = Self::from_py_any_direct(v) {
+            Ok(inner)
+        }
         else if let Ok(inner) = pyo3_capsule_api::extract_unit_from_capsule(v) {
             Ok(inner)
         }
@@ -248,6 +259,13 @@ impl Unit {
             Err(crate::QuantityConversionError::InvalidPythonUnit)
         }
     }
+
+    pub(crate) fn from_py_any_direct(v: &Bound<PyAny>) -> crate::QuantityConversionResult<Self> {
+        // __EXTRACT_UNIT_MATCHES__
+        else {
+            Err(crate::QuantityConversionError::InvalidPythonUnit)
+        }
+    }
 }
 
 #[cfg(feature = "pyo3")]
@@ -400,7 +418,7 @@ pub mod pyo3_capsule_api {
                 return Err(PyValueError::new_err("output pointer for quantity repr is null"));
             }
             let obj_bound = Bound::from_borrowed_ptr(py, obj);
-            let quantity = Quantity::from_py_any(&obj_bound)
+            let quantity = Quantity::from_py_any_direct(&obj_bound)
                 .map_err(|err| PyValueError::new_err(err.to_string()))?;
             unsafe {
                 *out = quantity_to_repr(quantity)
@@ -444,7 +462,7 @@ pub mod pyo3_capsule_api {
                 return Err(PyValueError::new_err("output pointer for unit repr is null"));
             }
             let obj_bound = Bound::from_borrowed_ptr(py, obj);
-            let unit = Unit::from_py_any(&obj_bound)
+            let unit = Unit::from_py_any_direct(&obj_bound)
                 .map_err(|err| PyValueError::new_err(err.to_string()))?;
             unsafe {
                 *out = unit_to_repr(unit);

{unitforge-0.4.3 → unitforge-0.5.1}/src/small_linalg/bindings/vector3_py.template.rs

@@ -1,5 +1,5 @@
 use std::mem::discriminant;
-use pyo3::{exceptions::PyValueError, types::PyList};
+use pyo3::{exceptions::{PyTypeError, PyValueError}, types::PyList};
 use numpy::{PyReadonlyArray1, PyArray1};
 use crate::small_linalg::Vector3;
 
@@ -38,6 +38,36 @@ impl Vector3Py {
             self.data[2]
         )
     }
+
+    fn mul_quantity_right_data(&self, rhs: Quantity) -> PyResult<[Quantity; 3]> {
+        Ok([
+            (self.data[0] * rhs).map_err(|_| PyTypeError::new_err("Cannot multiply given Quantities."))?,
+            (self.data[1] * rhs).map_err(|_| PyTypeError::new_err("Cannot multiply given Quantities."))?,
+            (self.data[2] * rhs).map_err(|_| PyTypeError::new_err("Cannot multiply given Quantities."))?,
+        ])
+    }
+
+    fn mul_quantity_left_data(&self, lhs: Quantity) -> PyResult<[Quantity; 3]> {
+        Ok([
+            (lhs * self.data[0]).map_err(|_| PyTypeError::new_err("Cannot multiply given Quantities."))?,
+            (lhs * self.data[1]).map_err(|_| PyTypeError::new_err("Cannot multiply given Quantities."))?,
+            (lhs * self.data[2]).map_err(|_| PyTypeError::new_err("Cannot multiply given Quantities."))?,
+        ])
+    }
+
+    fn div_quantity_right_data(&self, rhs: Quantity) -> PyResult<[Quantity; 3]> {
+        Ok([
+            (self.data[0] / rhs).map_err(|_| PyTypeError::new_err("Cannot divide given Quantities."))?,
+            (self.data[1] / rhs).map_err(|_| PyTypeError::new_err("Cannot divide given Quantities."))?,
+            (self.data[2] / rhs).map_err(|_| PyTypeError::new_err("Cannot divide given Quantities."))?,
+        ])
+    }
+
+    pub fn mul_quantity_left(&self, lhs: Quantity) -> PyResult<Self> {
+        Ok(Vector3Py {
+            data: self.mul_quantity_left_data(lhs)?,
+        })
+    }
 }
 
 #[pymethods]
@@ -127,7 +157,7 @@ impl Vector3Py {
 
     fn __add__(&self, other: &Vector3Py) -> PyResult<Self> {
         if discriminant(&self.data[0]) != discriminant(&other.data[0]) {
-            Err(PyValueError::new_err("The passed values must be of the same quantity.".to_string()))
+            Err(PyTypeError::new_err("The passed values must be of the same quantity.".to_string()))
         } else {
             Ok(Vector3Py {
                 data: [self.data[0].add(other.data[0]).unwrap(),
@@ -139,7 +169,7 @@ impl Vector3Py {
 
     fn __sub__(&self, other: &Vector3Py) -> PyResult<Self> {
         if discriminant(&self.data[0]) != discriminant(&other.data[0]) {
-            Err(PyValueError::new_err("The passed values must be of the same quantity.".to_string()))
+            Err(PyTypeError::new_err("The passed values must be of the same quantity.".to_string()))
         } else {
             Ok(Vector3Py {
                 data: [self.data[0].sub(other.data[0]).unwrap(),
@@ -338,20 +368,36 @@ impl Vector3Py {
     fn __mul__(&self, py: Python, rhs: Py<PyAny>) -> PyResult<Self> {
         let rhs_ref = rhs.bind(py);
         let rhs_quantity = Quantity::from_py_any(rhs_ref)
-            .map_err(|e| PyValueError::new_err(e.to_string()))?;
-        Ok(Vector3Py { data: [
-            (self.data[0] * rhs_quantity).map_err(|_| PyValueError::new_err("Cannot multiply given Quantities."))?,
-            (self.data[1] * rhs_quantity).map_err(|_| PyValueError::new_err("Cannot multiply given Quantities."))?,
-            (self.data[2] * rhs_quantity).map_err(|_| PyValueError::new_err("Cannot multiply given Quantities."))?] })
+            .map_err(|e| PyTypeError::new_err(e.to_string()))?;
+        Ok(Vector3Py {
+            data: self.mul_quantity_right_data(rhs_quantity)?,
+        })
     }
 
     fn __truediv__(&self, py: Python, rhs: Py<PyAny>) -> PyResult<Self> {
         let rhs_ref = rhs.bind(py);
         let rhs_quantity = Quantity::from_py_any(rhs_ref)
-            .map_err(|e| PyValueError::new_err(e.to_string()))?;
-        Ok(Vector3Py { data: [
-            (self.data[0] / rhs_quantity).map_err(|_| PyValueError::new_err("Cannot divide given Quantities."))?,
-            (self.data[1] / rhs_quantity).map_err(|_| PyValueError::new_err("Cannot divide given Quantities."))?,
-            (self.data[2] / rhs_quantity).map_err(|_| PyValueError::new_err("Cannot divide given Quantities."))?] })
+            .map_err(|e| PyTypeError::new_err(e.to_string()))?;
+        Ok(Vector3Py {
+            data: self.div_quantity_right_data(rhs_quantity)?,
+        })
+    }
+
+    fn __imul__(&mut self, py: Python, rhs: Py<PyAny>) -> PyResult<()> {
+        let rhs_ref = rhs.bind(py);
+        let rhs_quantity = Quantity::from_py_any(rhs_ref)
+            .map_err(|e| PyTypeError::new_err(e.to_string()))?;
+        let data = self.mul_quantity_right_data(rhs_quantity)?;
+        self.data = data;
+        Ok(())
+    }
+
+    fn __itruediv__(&mut self, py: Python, rhs: Py<PyAny>) -> PyResult<()> {
+        let rhs_ref = rhs.bind(py);
+        let rhs_quantity = Quantity::from_py_any(rhs_ref)
+            .map_err(|e| PyTypeError::new_err(e.to_string()))?;
+        let data = self.div_quantity_right_data(rhs_quantity)?;
+        self.data = data;
+        Ok(())
     }
 }

unitforge-0.5.1/tests/test_quantities.py

@@ -0,0 +1,86 @@
+import pytest
+from unitforge import *
+
+
+def test_inverse_stress_from_stress_division():
+    stress = Stress(2.0, StressUnit.Pa)
+    inverse = 1 / stress
+    assert isinstance(inverse, InverseStress)
+    assert inverse.to(InverseStressUnit._Pa) == pytest.approx(0.5)
+
+
+def test_stress_from_inverse_stress_division():
+    inverse = InverseStress(0.5, InverseStressUnit._Pa)
+    stress = 1 / inverse
+    assert isinstance(stress, Stress)
+    assert stress.to(StressUnit.Pa) == pytest.approx(2.0)
+
+
+def test_stress_squared_from_force_stress_over_area():
+    force = Force(2.0, ForceUnit.N)
+    stress = Stress(3.0, StressUnit.Pa)
+    area = Area(6.0, AreaUnit.msq)
+    result = (force * stress) / area
+    assert isinstance(result, StressSquared)
+    assert result.to(StressSquaredUnit.Nsq_mmhc) == pytest.approx(1.0)
+
+
+def test_force_stress_from_stress_squared_times_area():
+    stress_squared = StressSquared(2.0, StressSquaredUnit.Nsq_mmhc)
+    area = Area(3.0, AreaUnit.msq)
+    result = stress_squared * area
+    assert isinstance(result, ForceStress)
+    assert result.to(ForceStressUnit.Nsq_msq) == pytest.approx(6.0)
+
+def test_power_operator():
+    a = Distance(2., DistanceUnit.mm)
+    b = a**2
+    assert b == Area(4., AreaUnit.mmsq)
+
+
+def test_quantity_unsupported_rhs_object_raises_type_error():
+    force = Force(1., ForceUnit.N)
+    with pytest.raises(TypeError):
+        _ = force + object()
+    with pytest.raises(TypeError):
+        _ = force - object()
+    with pytest.raises(TypeError):
+        _ = force * object()
+    with pytest.raises(TypeError):
+        _ = force / object()
+
+
+def test_quantity_unsupported_relation_raises_type_error():
+    force = Force(1., ForceUnit.N)
+    time = Time(1., TimeUnit.s)
+    with pytest.raises(TypeError):
+        _ = force * time
+    with pytest.raises(TypeError):
+        _ = force / time
+
+
+def test_quantity_invalid_power_raises_type_error():
+    force = Force(1., ForceUnit.N)
+    with pytest.raises(TypeError):
+        _ = force ** 2
+
+
+def test_quantity_left_vector_multiplication():
+    result = Force(1., ForceUnit.N) * Vector3.x()
+    assert result[0] == Force(1., ForceUnit.N)
+    assert result[1] == Force(0., ForceUnit.N)
+    assert result[2] == Force(0., ForceUnit.N)
+
+
+def test_quantity_left_vector_multiplication_with_quantity_vector():
+    vec = Vector3(Distance(3., DistanceUnit.mm), Distance(4., DistanceUnit.mm), Distance(12., DistanceUnit.mm))
+    result = Force(2., ForceUnit.N) * vec
+    assert result[0].to(ForceDistanceUnit.Nm) == 0.006
+    assert result[1].to(ForceDistanceUnit.Nm) == 0.008
+    assert result[2].to(ForceDistanceUnit.Nm) == 0.024
+
+
+def test_quantity_left_vector_multiplication_unsupported_relation_raises_type_error():
+    vec = Vector3(Time(1., TimeUnit.s), Time(2., TimeUnit.s), Time(3., TimeUnit.s))
+    with pytest.raises(TypeError):
+        _ = Force(1., ForceUnit.N) * vec

{unitforge-0.4.3 → unitforge-0.5.1}/tests/test_small_linalg.py

@@ -53,7 +53,7 @@ class TestVectorAdd():
         assert c[2] == 8.
 
     def test_vector_add_failing(self):
-        with pytest.raises(ValueError, match="The passed values must be of the same quantity."):
+        with pytest.raises(TypeError, match="The passed values must be of the same quantity."):
             a = Vector3(1., 12., 3.)
             b = Vector3(Distance(2., DistanceUnit.mm), Distance(2., DistanceUnit.mm), Distance(2., DistanceUnit.mm))
             _ = a + b
@@ -80,7 +80,7 @@ def test_vector_shared_unit():
     assert vec[2].to(ForceUnit.kN) == 3.
 
 def test_vector_sub_failing():
-    with pytest.raises(ValueError, match="The passed values must be of the same quantity."):
+    with pytest.raises(TypeError, match="The passed values must be of the same quantity."):
         a = Vector3(1., 12., 3.)
         b = Vector3(Distance(2., DistanceUnit.mm), Distance(2., DistanceUnit.mm), Distance(2., DistanceUnit.mm))
         _ = a - b
@@ -185,6 +185,22 @@ def test_vector_mul():
     assert res[1].to(ForceDistanceUnit.Nm) == 0.008
     assert res[2].to(ForceDistanceUnit.Nm) == 0.024
 
+def test_vector_float_mul_quantity():
+    res = Vector3.x() * Force(1., ForceUnit.N)
+    assert res[0] == Force(1., ForceUnit.N)
+    assert res[1] == Force(0., ForceUnit.N)
+    assert res[2] == Force(0., ForceUnit.N)
+
+def test_vector_mul_unsupported_rhs_raises_type_error():
+    vec = Vector3(Distance(3., DistanceUnit.mm), Distance(4., DistanceUnit.mm), Distance(12., DistanceUnit.mm))
+    with pytest.raises(TypeError):
+        _ = vec * object()
+
+def test_vector_mul_unsupported_quantity_relation_raises_type_error():
+    vec = Vector3(Force(3., ForceUnit.N), Force(4., ForceUnit.N), Force(12., ForceUnit.N))
+    with pytest.raises(TypeError):
+        _ = vec * Time(1., TimeUnit.s)
+
 def test_vector_div():
     vec = Vector3(Force(3., ForceUnit.N), Force(4., ForceUnit.N), Force(12., ForceUnit.N))
     res = vec / Area(2., AreaUnit.mmsq)
@@ -192,6 +208,36 @@ def test_vector_div():
     assert res[1].to(StressUnit.MPa) == 2.
     assert res[2].to(StressUnit.MPa) == 6.
 
+def test_vector_div_unsupported_rhs_raises_type_error():
+    vec = Vector3(Force(3., ForceUnit.N), Force(4., ForceUnit.N), Force(12., ForceUnit.N))
+    with pytest.raises(TypeError):
+        _ = vec / object()
+
+def test_vector_imul_quantity_mutates_in_place():
+    vec = Vector3.x()
+    original_id = id(vec)
+    vec *= Force(2., ForceUnit.N)
+    assert id(vec) == original_id
+    assert vec[0] == Force(2., ForceUnit.N)
+    assert vec[1] == Force(0., ForceUnit.N)
+    assert vec[2] == Force(0., ForceUnit.N)
+
+def test_vector_itruediv_quantity_mutates_in_place():
+    vec = Vector3(Force(3., ForceUnit.N), Force(4., ForceUnit.N), Force(12., ForceUnit.N))
+    original_id = id(vec)
+    vec /= Area(2., AreaUnit.mmsq)
+    assert id(vec) == original_id
+    assert vec[0].to(StressUnit.MPa) == 1.5
+    assert vec[1].to(StressUnit.MPa) == 2.
+    assert vec[2].to(StressUnit.MPa) == 6.
+
+def test_vector_imul_unsupported_quantity_leaves_vector_unchanged():
+    vec = Vector3(Force(3., ForceUnit.N), Force(4., ForceUnit.N), Force(12., ForceUnit.N))
+    before = vec.to_list()
+    with pytest.raises(TypeError):
+        vec *= Time(1., TimeUnit.s)
+    assert vec.to_list() == before
+
 def test_vector_matrix_zero():
     mat = Matrix3.zero()
     for i in range(3):
@@ -229,6 +275,13 @@ def test_matrix_str():
     mat = Matrix3.from_list([[1, 3, 4], [5, 7, 3], [7, 8, 9]], ForceUnit.N)
     assert str(mat) == 'Matrix3: [\n[ForceQuantity(1 N), ForceQuantity(3 N), ForceQuantity(4 N)]\n[ForceQuantity(5 N), ForceQuantity(7 N), ForceQuantity(3 N)]\n[ForceQuantity(7 N), ForceQuantity(8 N), ForceQuantity(9 N)]]'
 
+def test_matrix_missing_binary_arithmetic_raises_type_error():
+    mat = Matrix3.zero()
+    with pytest.raises(TypeError):
+        _ = mat + mat
+    with pytest.raises(TypeError):
+        _ = mat * 2.
+
 
 class TestMatrixListInterface:
     def test_matrix_from_list(self):

{unitforge-0.4.3 → unitforge-0.5.1}/unitforge_macros/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "unitforge_macros"
-version = "0.4.3"
+version = "0.5.1"
 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"
@@ -12,4 +12,4 @@ keywords = ["units", "quantities", "simulation", "physics"]
 proc-macro = true
 
 [dependencies]
-regex = "1.11.1"
+regex = "1.12.3"

unitforge-0.4.3/tests/test_quantities.py

@@ -1,38 +0,0 @@
-import pytest
-from unitforge import *
-
-
-def test_inverse_stress_from_stress_division():
-    stress = Stress(2.0, StressUnit.Pa)
-    inverse = 1 / stress
-    assert isinstance(inverse, InverseStress)
-    assert inverse.to(InverseStressUnit._Pa) == pytest.approx(0.5)
-
-
-def test_stress_from_inverse_stress_division():
-    inverse = InverseStress(0.5, InverseStressUnit._Pa)
-    stress = 1 / inverse
-    assert isinstance(stress, Stress)
-    assert stress.to(StressUnit.Pa) == pytest.approx(2.0)
-
-
-def test_stress_squared_from_force_stress_over_area():
-    force = Force(2.0, ForceUnit.N)
-    stress = Stress(3.0, StressUnit.Pa)
-    area = Area(6.0, AreaUnit.msq)
-    result = (force * stress) / area
-    assert isinstance(result, StressSquared)
-    assert result.to(StressSquaredUnit.Nsq_mmhc) == pytest.approx(1.0)
-
-
-def test_force_stress_from_stress_squared_times_area():
-    stress_squared = StressSquared(2.0, StressSquaredUnit.Nsq_mmhc)
-    area = Area(3.0, AreaUnit.msq)
-    result = stress_squared * area
-    assert isinstance(result, ForceStress)
-    assert result.to(ForceStressUnit.Nsq_msq) == pytest.approx(6.0)
-
-def test_power_operator():
-    a = Distance(2., DistanceUnit.mm)
-    b = a**2
-    assert b == Area(4., AreaUnit.mmsq)