Awesome

Units Of Measure

Conceptual repo. Most advanced compile time safe units of measure for C#. Read about what's happening here on medium.

Based on generic type safety, type argument inference, generic math.

Examples

C#

var distance = 5f.Meters();                                    // 5.00 m
var time = 4f.Seconds();                                       // 4.00 s
var speed = distance.Divide(time);                             // 1.25 (m/s)
var additionalSpeed = 1f.Kilometers().Divide(60f.Minutes());   // 0.02 (km/min)
var totalSpeed = speed.Add(additionalSpeed);                   // 1.53 (m/s)
var bla = distance.Add(time);                                  // compilation error, you can't add time and distance

F#

In F# we additionally get generic operators.

var distance = 5f.Meters();                              // 5.00 m
var time = 4f.Seconds();                                 // 4.00 s
var speed = distance / time;                             // 1.25 (m/s)
var additionalSpeed = 1f.Kilometers() / 60f.Minutes();   // 0.02 (km/min)
var totalSpeed = speed + additionalSpeed;                // 1.53 (m/s)
var bla = distance + time;                               // compilation error, you can't add time and distance

How does this work?

General structure

Your value is stored in Unit with three type arguments. A one which corresponds to the unit of your value. A one which is this unit's base value (e. g. for kilometers it would normally be meter). And a one which is your type's number (float/double/int etc.).

Operations are defined as extension methods in UoM as well as regular operators in the F# version. Each operation will

Return a combination of units. For example, division of kilometer and second returns Divide<Kilometer, Second, ...>.
Return the instance's type. This normally happens on persistent operations, like addition, which does not change the type.
Fail to compile. This happens for persistent operations on incompatible types. For example, addition of seconds and kilometers.

Lengths, masses, speeds...?

None of it. The core idea is that each unit of measure has its base type. E. g. for kilometer it is meter, for gram it is kilogram, for meter it is meter too.

Conversion

Thanks to the base type idea, one can easily convert units with the same base type. Each type holds how many times it is bigger than its base type. For kilometer it would be 1000, for mile around 1600, for gram it will be 0.001. Arithmetic types, like division or square, would combine those values into their own bases. For example, square kilometer would hold 1'000'000 square meters.

Based on this, we can easily convert a value of type A to type B assuming they share the same base unit.

Generic math

.NET 6 introduces preview feature: generic math. To make the UoM even more customizable, it supports generic math too, so every single value is some generic TNumber constrained as little as possible to allow the necessary operations.

Efficiency

It is far from floats. Despite that there is no runtime dispatch, everything is inlined, there is still overhead. The thing is, floats are passed and returned by xmm registers, so operations on them do not invole memory.

However, since Unit wraps a float, it is passed by an "integer" register. It then is being written to RAM (stack), after which it is loaded onto an xmm register, an operation is then performed, and written back to memory, and then unloaded back to a regular "integer" register.

Consider a simple function which calculates something looking similar to gravity force.

Performance:

Method	Mean	Error	StdDev
Floats	1.555 ns	0.0734 ns	0.1855 ns
UoM	5.691 ns	0.1553 ns	0.3441 ns

For floats:

public static float ComputeGravityForceFloats(float mass1, float mass2, float distance)
{
    return (mass1 + mass2) / (distance * distance);
}

The codegen:

    00007FFBAB3A64B0 C5F877               vzeroupper
    00007FFBAB3A64B3 C5FA58C1             vaddss    xmm0,xmm0,xmm1
    00007FFBAB3A64B7 C5EA59CA             vmulss    xmm1,xmm2,xmm2
    00007FFBAB3A64BB C5FA5EC1             vdivss    xmm0,xmm0,xmm1
    00007FFBAB3A64BF C3                   ret

For UoMs:

public static Force ComputeGravityForceUoM(Mass mass1, Mass mass2, Length distance)
{
    return mass1.Add(mass2).Divide(distance.Square());
}

(Mass, Length and Force are no more than aliases made with using)