Units Operations

Units Operations

Go back Home

Motivation

It is well known that:

time * speed = distance

But how can we represent this multiplication in our units library?

Assume you have the following code:

KilometersPerHour carSpeed{60};
Minutes driveDuration{42};

You want to multiply carSpeed and driveDuration in order to find the distance the car did. The main question is:

In which unit the result of the multiplication should be?

And the answer is: It doesn't matter!

With units library you can get the result in any unit you desire. For example:

auto driveDistance = units_multiply<Yards>(carSpeed, driveDuration);

gives us the result as a Yards object.

Units Multiplication

As we've seen, units_multiply()calculates the multiplication of two unit objects and returns the result in any wanted unit. The result type given by the user is validated to be from the right type. For example:

auto driveDistance = units_multiply<Degrees>(carSpeed, driveDuration); // This will not compile, since the given result unit is from the wrong type

The order of the multiplied units doesn't matter. For example:

auto driveDistance1 = units_multiply<Yards>(carSpeed, driveDuration);
auto driveDistance2 = units_multiply<Yards>(driveDuration, carSpeed);
if (driveDistance1 == driveDistance2) cout < "same!" << endl; // This will be printed!

You can multiply as many units as you want, For example:

Meters length{4};
Yards width{3};
Feet height{7.1};
auto volume = units_multiply<Liters>(length, width, height);

units_multiply() takes only the tags of the result type. For example:

struct tag1{};
struct tag2{};
struct tag3{};

Tag<Meters, tag1> length{4}; // has only "tag1" tag.
Tag<Yards, tag2> width{3}; // has only "tag2" tag
Feet height{7.1}; // has no tags
auto volume = units_multiply<Tag<Liters, tag3>>(length, width, height); // has only "tag3" tag

units_multiply() is a constexpr function, which means it can be run in compile time.

Units Ratio

You can calculate the ratio of two units using the units_ratio() function. Its API is similar to units_multiply(). For example:

struct tag1{};
struct tag2{};
struct tag3{};

Kilometers driveDistance{100}
Minutes driveDuration{67};
auto carSpeed = units_ratio<KilometersPerHour>(driveDistance, driveDuration);
auto boatSpeed = units_ratio<Knots>(driveDistance, driveDuration);
auto taggedCarSpeed = units_ratio<Tag<MetersPerSecond, tag3>>(
	tag<tag1>(driveDistance),
	tag<tag2>(driveDuration)); // result has only "tag3" tag.
cout << units_ratio<Degrees>(driveDistance, driveDuration) << endl; // This will not compile, since Degrees is not a speed unit.

Pay attention:

The left and right variables of the units_ratio() are the numerator and denominator respectively. Moreover, units_ratio() gets exactly 2 parameters.

units_ratio() is also a constexpr function.

Units Pow, Square and Cube

You can use units_pow() in order to calculate areas or volumes of perfect shapes. for example:

Meters m{2};
auto area = units_pow<2>(m); // Result is from SquareMeters type
auto volume = units_pow<3>(m); // Result is from SquareMeters type

Pay Attention:

Not like other units operation, result type of the units_pow() function is not given by the user but calculated directly from the unit that was passed to the function. On the other hand, units_pow() saves tags. For example:

struct tag1{};

Tag<Meters, tag1> m{2}; // has "tag1" tag
auto area = units_pow<2>(m); // has "tag1" tag
auto volume = units_pow<3>(m); // has "tag1" tag

Most of the times we recommend using the units_sqr() and units_cube() functions, which are like units_pow<2>() and units_pow<3>() respectively. They act exactly like units_multiply() and units_ratio() (result type given by the user, tags are from the result type only, etc.). For example:

Meters m{2};
auto area = units_sqr<Dunams>(m); // Result is from Dunams type
auto volume = units_cube<Liters>(m); // Result is from Liters type

units_pow(), units_sqr() and units_cube() are all constexpr functions.