Re: Expressing physical units (Was: Reprise: 'in out' parameters for functions)

[Hyman Rosen <hyrosen@mail.com>]

Jacob Sparre Andersen wrote:
> It should be noted that my analysis was tied rather strongly to Ada,
> and a more relaxed programming language might be able to do something
> that would be sufficiently close to full compile-time unit checking.

C++ can do full compile-time unit checking with no runtime overhead
as long as all units needed by the program are known at compile-time.
The technique uses templates, requires automatic instantiation of
templates for usability (and so cannot be done in Ada), and was published
in Barton & Nackman, _Scientific and Engineering C++_. I've often posted
the technique, but here goes again, in a simplified version:

template <int Mass, int Distance, int Time>
struct Unit
{
     double value;
     Unit(double value = 0.0) : value(value) { }

     Unit operator+(Unit other) { return Unit(value + other.value); }
};

template <int M1, int D1, int T1,
           int M2, int D2, int T2>
Unit<M1+M2,D1+D2,T1+T2>
operator*(Unit<M1,D1,T1> l, Unit<M2,D2,T2> r)
{
     return Unit<M1+M2,D1+D2,T1+T2>(l.value * r.value);
}

This supports positive and negative whole number powers. For those rare
applications which require fractional powers, you can move to using pairs
of numerator/denominator template parameters to represent fractions.
The full implementation will include the other operators, and may have the
value type as a template parameter as well, but this is enough of a guide
to see how it works.

Here's how you might write the output operator:
     template <typename OStream, int M, int D, int T>
     Ostream &operator<<(Ostream &o, const Unit<M, D, T> &v)
     {
         o << v.value;
         if (M > 0) o << " g";
         if (M > 1) o << "^" << M;
         if (D > 0) o << " cm";
         if (D > 1) o << "^" << D;
         if (T > 0) o << " s";
         if (T > 1) o << "^" << T;
         if (M < 0 || D < 0 || T < 0) o << " /";
         if (M < 0) o << " g";
         if (M < 1) o << "^" << -M;
         if (D < 0) o << " cm";
         if (D < 1) o << "^" << -D;
         if (T < 0) o << " s";
         if (T < 1) o << "^" << -T;
         return o;
     }
Because M, D, T are template parameters, their values are all known at
compile time, and the output routine instantiated for a particular unit
will contain only the code needed, without any tests at runtime.