[GSoC Proposal] Statically Checked Measurement Units

[spir]

On 03/28/2011 05:43 PM, Cristi Cobzarenco wrote:
> Thus, the requirements for the unit system would be:
> 1. One line definition of new units.
> 2. Simple, yet safe and explicit conversion between units.
> 3. Zero runtime overhead.
> 4. Minimal extra coding effort to use units.

I like your study very much. Measurement units are, for me, kinds of conceptual 
types --as opposed to primitive types. I think they would be welcome, possibly 
for Phobos.

> [...]
> I propose using types for base units and mixins to define derived units.
>  One can use the typenames of the units in arithmetic operations this way:
>
> struct metre  {}
> struct second {}
>
> void f() {
> Quantity!("metre")        dist1 = quantity!(3.0, "metre");
> Quantity!("metre^2")      area  = dist1 * dist1;
> Quantity!("metre/second") speed = dist1 / quantity!(2.0, "second");
> }

I think (not sure) this could be even simpler:
   1. Thank to D's very used auto feature, avoiding double specification of the 
type; you could get rif of quantity, if it's only a convenience factory func.
   2. I guess it's not needed for the user to give a quantity type to 
/constants/ (here 2.0). It is /meant/ to be a a number of seconds. This, as 
opposed to measure /variables/.
Thus, we possibly could have:

     auto dist1 = Quantity!("meter")(3.0);
     auto area  = Quantity!("metre^2")(dist1 * dist1);
     auto speed = Quantity!("metre/second")(dist1 / 2.0);

(Unsure whether your system could automagically infer the unit of area. ?)

I'm not fan of using strings as unit identifiers. Why don't you want to use use 
the corresponding types (structs or classes) themselves?

      auto dist1 = Quantity!Meter(3.0);

Thus requiring each unit to be identified by a (possibly empty) struct or 
class. This also gives the opportunity for the user to actually implement some 
useful stuff in there; or to *reuse* existing types for things-to-be-counted 
(in the latter case, measures would actually be integer /counts/); see your 
Widget vs Gadget example below).

> Conversion between units can be done specifying a single factor with a
> proper unit:
>
> template conversion( alias unit : "kilometer/meter" ) {
> immutable Quantity!(unit) conversion = quantity!(123.0,unit);
> }

Unsure of the right approch here. All we need is a registered conversion factor 
for every needed (U1,U2) pair. It could be a kind of 2D associative array with 
unit keys and float values. Then, would it be possible to have a single convert 
template, like:

     Quantity!U2 convert (string U1, string U2) (Quantity!U1 measure) {
         auto factor = conversionFactors[U1][U2];   // throws if undefined
         return Quantity!U2(measure * factor);
     }

?

> void f() {
> Quantity!("metre")     d1 = quantity!(123.0,"metre");
> // convert calls conversion! with the right argument
> Quantity!("kilometre") d2 = convert!(d1,"kilometre");
> }

    auto d1 = Quantity!("metre")(123.0);
    auto d2 = convert!(d1,"kilometre");
or using my approach:
    auto d2 = convert!("metre","kilometre")(d1);

Here the type for d2 is really unnecessary.

> Also, notice this approach imposes no restriction to the types that define
> units, therefore our Widget/Gadget counters could be defined without any
> extra work:
>
> class Widget { /* complicated class definition */ }
> class Gadget { /* complicated class definition */ }
>
> Quantity!("Widget",int) nWidgets;
> Quantity!("Gadget",int) nGadgets;

See note about identifying units above.

Denis
-- 
_________________
vita es estrany
spir.wikidot.com