add vector operations for python

python/units_python.cpp

@@ -8,6 +8,7 @@ SPDX-License-Identifier: BSD-3-Clause
 #include <nanobind/operators.h>
 #include <nanobind/stl/bind_map.h>
 #include <nanobind/stl/string.h>
+#include <nanobind/stl/vector.h>
 
 #include "units/units.hpp"
 #include "units/units_math.hpp"
@@ -116,6 +117,47 @@ NB_MODULE(units_llnl_ext, mod)
                 return unit.pow(pow);
             },
             nb::is_operator())
+        .def(
+            "__pow__",
+            [](const units::precise_unit& unit, float pow) {
+                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 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;
+        },
+            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;
+        },
+            nb::is_operator())
         .def(
             "is_exactly_the_same",
             [](const units::precise_unit& type1,
@@ -418,6 +460,29 @@ NB_MODULE(units_llnl_ext, mod)
                 return floor(measurement / divisor);
             },
             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;
+        },
+            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;
+        },
+            nb::is_operator())
         .def(
             "is_valid",
             [](const units::precise_measurement& measurement) {

test/python/test_measurement.py

@@ -213,6 +213,15 @@ 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
+
+    assert mv3[2].value==30
+    assert mv4[3].value==60
 
 def test_div():
     m1 = u.Measurement("10 meters")

test/python/test_units.py

@@ -179,8 +179,22 @@ 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
+    assert type(mv[0]).__name__ == "Measurement"
+    print(mv)
+    assert mv[1].value == 20
+
+    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")