add decompose method to dimensions

Author: phlptp

python/units_python.cpp

@@ -689,6 +689,37 @@ NB_MODULE(units_llnl_ext, mod)
                 new (dim) Dimension{def};
             },
             "dimension"_a)
+        .def(
+            "__init__",
+            [](Dimension* dim, const nb::dict &composition) {
+                units::precise_unit def;
+
+                for (const auto& element : composition)
+                {
+                    nb::handle key_handle = element.first;
+                    nb::handle value_handle = element.second;
+
+                    // Convert the key handle to a std::string
+                    std::string key = nb::cast<std::string>(key_handle);
+
+                    // Convert the value handle to an int
+                    int value = nb::cast<int>(value_handle);
+                    if (key == "custom")
+                    {
+                        def=def*units::precise::generate_custom_unit(static_cast<std::uint16_t>(value));
+                    }
+                    else if (key == "custom_count")
+                    {
+                        def=def*units::precise::generate_custom_count_unit(static_cast<std::uint16_t>(value));
+                    }
+                    else
+                    {
+                        def=def*(units::unit_from_string(key).pow(value));
+                    }
+                }
+                new (dim) Dimension{def};
+            },
+            "composition"_a)
         .def_prop_ro(
             "default_unit",
             [](const Dimension& dim) { return (dim.base); },
@@ -747,6 +778,92 @@ NB_MODULE(units_llnl_ext, mod)
         .def(
             "__invert__",
             [](const Dimension& dim) { return Dimension{dim.base.inv()}; })
+        .def("decompose",
+            [](const Dimension& dim) { 
+                nb::dict dictionary;
+                auto base_units=dim.base;
+                units::detail::unit_data base=base_units.base_units();
+                bool custom{false};
+                if (units::precise::custom::is_custom_unit(base))
+                {
+                    dictionary["custom"]=units::precise::custom::custom_unit_number(base);
+                    if (units::precise::custom::is_custom_unit_inverted(base))
+                    {
+                        dictionary["inverted"]=1;
+                    }
+                    custom=true;
+                }
+                else if(units::precise::custom::is_custom_count_unit(base))
+                {
+                    dictionary["custom_count"]=units::precise::custom::custom_count_unit_number(base);
+                    if (units::precise::custom::is_custom_count_unit_inverted(base))
+                    {
+                        dictionary["inverted"]=1;
+                    }
+                    custom=true;
+                }
+                if (!custom)
+                {
+                    if (base.meter() != 0)
+                    {
+                        dictionary["meters"] = base.meter();
+                    }
+                    if (base.kg() != 0)
+                    {
+                        dictionary["kilogram"] = base.kg();
+                    }
+                    if (base.second() != 0)
+                    {
+                        dictionary["second"] = base.second();
+                    }
+                    if (base.ampere() != 0)
+                    {
+                        dictionary["ampere"] = base.ampere();
+                    }
+                    if (base.kelvin() != 0)
+                    {
+                        dictionary["kelvin"] = base.kelvin();
+                    }
+                    if (base.mole() != 0)
+                    {
+                        dictionary["mole"] = base.mole();
+                    }
+                    if (base.candela() != 0)
+                    {
+                        dictionary["candela"] = base.candela();
+                    }
+                    if (base.currency() != 0)
+                    {
+                        dictionary["currency"] = base.currency();
+                    }
+                    if (base.count() != 0)
+                    {
+                        dictionary["count"] = base.count();
+                    }
+                    if (base.radian() != 0)
+                    {
+                        dictionary["radian"] = base.radian();
+                    }
+                    if (base.is_per_unit())
+                    {
+                        dictionary["per_unit"] = 1;
+                    }
+                    if (base.has_i_flag())
+                    {
+                        dictionary["iflag"] = 1;
+                    }
+                    if (base.has_e_flag())
+                    {
+                        dictionary["eflag"] = 1;
+                    }
+                    
+                }
+                if (base.is_equation())
+                {
+                    dictionary["equation"] = 1;
+                }
+                return dictionary;
+            } )
         .def(
             "__pow__",
             [](const Dimension& dim, int power) {

test/python/test_dimensions.py

@@ -70,3 +70,18 @@ def test_dimensions_units():
     d1 = Dimension("volume")
     u1 = Unit("m^3")
     assert d1.default_unit == u1
+
+def test_dimensions_decompose1():
+    d1 = Dimension("volume")
+    decomposition=d1.decompose()
+    
+    assert decomposition["meters"]==3
+    
+def test_dimensions_decompose2():
+    u1 = Unit("$ per watt radian")
+    dim=u1.dimension
+    decomposition=dim.decompose()
+    
+    dim2=Dimension(decomposition)
+    assert dim2==dim
+    assert dim2.default_unit==u1