Unit base class

The unit base class is a bitmap comprising segments of a 32 bit number. all the bits are defined

the underlying definition is a set of bit fields that cover a full 32 bit unsigned integer

// needs to be defined for the full 32 bits
     signed int meter_ : 4;
     signed int second_ : 4; // 8
     signed int kilogram_ : 3;
     signed int ampere_ : 3;
     signed int candela_ : 2; // 16
     signed int kelvin_ : 3;
     signed int mole_ : 2;
     signed int radians_ : 3; // 24
     signed int currency_ : 2;
     signed int count_ : 2; // 28
     unsigned int per_unit_ : 1;
     unsigned int i_flag_ : 1; // 30
     unsigned int e_flag_ : 1; //
     unsigned int equation_ : 1; // 32

The default constructor sets all the fields to 0. But this is private and only accessible from friend classes like units.

The main constructor looks like

constexpr unit_data(
        int meter,
        int kilogram,
        int second,
        int ampere,
        int kelvin,
        int mole,
        int candela,
        int currency,
        int count,
        int radians,
        unsigned int per_unit,
        unsigned int flag,
        unsigned int flag2,
        unsigned int equation)

an alternative constructor

explicit constexpr unit_data(std::nullptr_t);

sets all the fields to 1

Math operations

When multiplying two base units the powers are added. For the flags. The e_flag and i_flag are added, effectively an Xor while the pu and equation are ORed.

For division the units are subtracted, while the operations on the flags are the same.

Power and Root and Inv functions

For power operations all the individual powers of the base units are multiplied by the power number. The pu and equation flags are passed through. For even powers the i_flag and e_flag are set to 0, and odd powers they left as is. For root operations, First a check if the root is valid, if not the error unit is returned. If it is a valid root all the powers are divided by the root power. The Pu flag is left as is, the i_flag and e_flag are treated the same is in the pow function and the equations flag is set to 0.

There is one exception to the above rules. There is a special unit for √Hz it is a combination of some i_flag and e_flag and a high power of the seconds unit. This unit is used in amplitude spectral density and comes up on occasion in some engineering contexts. There is some special logic in the power function that does the appropriate things such the square of √Hz= Hz. If a low power of seconds is multiplied or divided by the special unit it still does the appropriate thing. But √Hz*√Hz will not generate the expected result. √Hz is a singular unique unit and the only coordinated result is a power operation to remove it. √Hz unit base itself uses a power of (-5) on the seconds and sets the i_flag and e_flag.

The inverse function is equivalent to pow(-1), and just inverts the unit_data.


The unit data type supports getters for the different fields all these are constexpr methods

  • meter(): return the meter power

  • kg(): return the kilogram power

  • second(): return the seconds power

  • ampere(): return the ampere power

  • kelvin(): return the kelvin power

  • mole(): return the mole power

  • candela(): return the candela power

  • currency(): return the currency power

  • count(): return the count power

  • radian(): return the radian power

  • is_per_unit(): returns true if the unit_base has the per_unit flag set

  • is_equation(): returns true if the unit_base has the equation field set

  • has_i_flag(): returns true if the i_flag is set

  • has_e_flag(): returns true if the e_flag is set

  • empty(): will check if the unit_data has any of the base units set, flags are ignored.

  • unit_type_count: will count the number of base units with a non-zero power


there are a few methods will generate a new unit based on an existing one the methods are constexpr

  • add_per_unit(): will set the per_unit flag

  • add_i_flag(): will set the i_flag

  • add_e_flag(): will set the e_flag

The method clear_flags is the only non-const method that modifies a unit_data in place.


Unit data support the == and != operators. these check all fields.

There are a few additional comparison functions that are also available.

  • equivalent_non_counting(unit_base other) : will return true if all the units but the counting units are equal, the counting units are mole, radian, and count.

  • has_same_base(unit_base other): will return true if all the units bases are equivalent. So the flags can be different.