Boost logo

Boost :

From: Matthias Schabel (boost_at_[hidden])
Date: 2007-02-16 14:49:33

> ( 1.0 * SI::meters + 1.0 * imperial::feet ) * ( 2.0 *
> CGS::centimeters + 1.0
> * imperial::feet )

I'm not proposing to allow heterogeneous addition where, as you point
the result type is ambiguous. Multiplication/division don't have this
though. Your example would give

2.0 m cm + 1.0 m ft + 2.0 ft cm + 1.0 ft^2

which wouldn't be allowed due to the addition of different units. Any
quantity h
as a dimensional signature that consists (limiting the
discussion to physical units for simplicity) of the powers of the
dimensions. That is (calling length L, time T, and mass M)

L^2 M^-3 T

is a dimensional signature that could be represented all in SI:

m^2 kg^-3 s

or mixed SI and CGS

m cm kg^-1 g^-2 s
m cm kg^-2 g s

etc... As long as you can come up with an invertible one-to-one map
different heterogeneous units with identical dimensional signatures,
this is

> and other complex expressions. Pushing down a result type may be
> hard. If
> your result type is nautical::miles * imperial::miles, how do you
> decide
> which of the two branches needs to get the nautical::miles? And
> this is a
> relatively simple example.

Another issue, as Steven pointed out, is that it is harder to get a
nice syntax
in the case where you want a function that takes a dimension
signature but
doesn't care about the system (or systems) of units. That is, the
implementation, which requires that all fundamental units belong to one
system, lets you do this:

template<class System>
quantity<unit<System,energy_type> >
work(const quantity<unit<System,force_type> >& F,
           const quantity<unit<System,length_type> >& dx)
        return F*dx;

or even

template<class System1,class System2,class System3>
quantity<unit<System3,energy_type> >
work(const quantity<unit<System1,force_type> >& F,
           const quantity<unit<System2,length_type> >& dx)
        const quantity<unit<System3,force_type> > Fc(F);
         const quantity<unit<System3,length_type> > dxc(dx);

        return Fc*dxc;

when you allow units to be heterogeneous across systems, it becomes
difficult to implement this...suggestions are welcome... Maybe this
is too
much of a hairball to try to deal with.


Boost list run by bdawes at, gregod at, cpdaniel at, john at