[pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

python/units_python.cpp

@@ -120,43 +120,41 @@ NB_MODULE(units_llnl_ext, mod)
         .def(
             "__pow__",
             [](const units::precise_unit& unit, float pow) {
-                if (pow<1.0 && pow>0.0)
-                {
-                    if (pow==0.5)
-                    {
+                if (pow < 1.0 && pow > 0.0) {
+                    if (pow == 0.5) {
                         return units::root(unit, 2);
+                    } else {
+                        return units::root(unit, static_cast<int>(1.0 / pow));
                     }
-                    else{
-                        return units::root(unit,static_cast<int>(1.0/pow));
-                    }
-
-                }
-                else{
+
+                } else {
                     return unit.pow(int(pow));
                 }
             },
             nb::is_operator())
-        .def("__mul__",[](const units::precise_unit &unit,const std::vector<double> &mult)
-        {
-            std::vector<units::precise_measurement> results;
-            results.resize(mult.size());
-            for (std::size_t ii=0;ii<mult.size();++ii)
-            {
-                results[ii]=mult[ii]*unit;
-            }
-            return results;
-        },
+        .def(
+            "__mul__",
+            [](const units::precise_unit& unit,
+               const std::vector<double>& mult) {
+                std::vector<units::precise_measurement> results;
+                results.resize(mult.size());
+                for (std::size_t ii = 0; ii < mult.size(); ++ii) {
+                    results[ii] = mult[ii] * unit;
+                }
+                return results;
+            },
             nb::is_operator())
-        .def("__rmul__",[](const units::precise_unit &unit,const std::vector<double> &mult)
-        {
-            std::vector<units::precise_measurement> results;
-            results.resize(mult.size());
-            for (std::size_t ii=0;ii<mult.size();++ii)
-            {
-                results[ii]=mult[ii]*unit;
-            }
-            return results;
-        },
+        .def(
+            "__rmul__",
+            [](const units::precise_unit& unit,
+               const std::vector<double>& mult) {
+                std::vector<units::precise_measurement> results;
+                results.resize(mult.size());
+                for (std::size_t ii = 0; ii < mult.size(); ++ii) {
+                    results[ii] = mult[ii] * unit;
+                }
+                return results;
+            },
             nb::is_operator())
         .def(
             "is_exactly_the_same",
@@ -461,27 +459,29 @@ NB_MODULE(units_llnl_ext, mod)
             },
             nb::is_operator())
 
-            .def("__mul__",[](const units::precise_measurement& measurement,const std::vector<double> &mult)
-        {
-            std::vector<units::precise_measurement> results;
-            results.resize(mult.size());
-            for (std::size_t ii=0;ii<mult.size();++ii)
-            {
-                results[ii]=measurement*mult[ii];
-            }
-            return results;
-        },
+        .def(
+            "__mul__",
+            [](const units::precise_measurement& measurement,
+               const std::vector<double>& mult) {
+                std::vector<units::precise_measurement> results;
+                results.resize(mult.size());
+                for (std::size_t ii = 0; ii < mult.size(); ++ii) {
+                    results[ii] = measurement * mult[ii];
+                }
+                return results;
+            },
             nb::is_operator())
-        .def("__rmul__",[](const units::precise_measurement& measurement,const std::vector<double> &mult)
-        {
-            std::vector<units::precise_measurement> results;
-            results.resize(mult.size());
-            for (std::size_t ii=0;ii<mult.size();++ii)
-            {
-                results[ii]=mult[ii]*measurement;
-            }
-            return results;
-        },
+        .def(
+            "__rmul__",
+            [](const units::precise_measurement& measurement,
+               const std::vector<double>& mult) {
+                std::vector<units::precise_measurement> results;
+                results.resize(mult.size());
+                for (std::size_t ii = 0; ii < mult.size(); ++ii) {
+                    results[ii] = mult[ii] * measurement;
+                }
+                return results;
+            },
             nb::is_operator())
         .def(
             "is_valid",

test/python/test_measurement.py

@@ -213,15 +213,17 @@ def test_mult():
     m5 = m3 * 3
     assert m5 == u.Measurement(18, "meters squared")
 
+
 def test_vector_mult():
     m1 = u.Measurement("2 meters")
     m2 = u.Measurement(3, "meters")
-    v1 = [5,10,15,20,25]
-    mv3=v1*m1
-    mv4=m2*v1
+    v1 = [5, 10, 15, 20, 25]
+    mv3 = v1 * m1
+    mv4 = m2 * v1
+
+    assert mv3[2].value == 30
+    assert mv4[3].value == 60
 
-    assert mv3[2].value==30
-    assert mv4[3].value==60
 
 def test_div():
     m1 = u.Measurement("10 meters")

test/python/test_units.py

@@ -179,22 +179,23 @@ def test_float_mult():
     m4 = u1 * 12
     assert type(m4).__name__ == "Measurement"
     assert m4.value == 12
-
+
+
 def test_mult_vect():
-    u1=u.Unit('m')
-    
-    v1=[10,20,40]
-    mv=v1*u1
+    u1 = u.Unit("m")
+
+    v1 = [10, 20, 40]
+    mv = v1 * u1
     assert type(mv[0]).__name__ == "Measurement"
     print(mv)
     assert mv[1].value == 20
-    
-    mv=u1*v1
+
+    mv = u1 * v1
     assert type(mv[2]).__name__ == "Measurement"
     print(mv)
     assert mv[2].value == 40
-    
-    
+
+
 def test_convert_units():
     u1 = u.Unit("m")
     u2 = u.Unit("cm")