-----Original Message----- From: boost-bounces@lists.boost.org [mailto:boost-bounces@lists.boost.org] On Behalf Of Andy Little
This (my small sample code) is in no way supposed to be a full-blown library, BTW. It is just for amusement.
How about rational dimension elements rather than integers. Would that be possible using the preprocessor?
The preprocessor isn't doing the work. It is just generating the code that does the work. Use of the preprocessor (here) is just making all that code write itself based on an initial sequence of fundamental units.
This occurs rarely but needs to be possible. One example is in measuring electrical noise where units for noise-voltage density are Volts * (Hertz to_power -1/2). ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Out of curiosity, how does this occur starting from SI's fundamental units?
The time element of the dimension works out as being to power -(2 1/2) FWIW!
You can certainly implement a static rational with a little template metaprogramming. Reducing rational values with template metaprogramming would be expensive in general, but here were mostly talking about very "small" rationals. You'd just end up with two "fields" per dimension (numerator and denominator) instead of one, and you'd have to use them as rational values. E.g. the way that I wrote it, you basically have: dim<mass, time, ...> ...where 'mass' and 'time' are integers. Instead, you have to have 'mass' and 'time' be types that represent rational values (such as 'rational<-5, 2>').
The things that I find amusing in it are that dimensions are specified using variables, not types (somewhat unusual), and the way that the reconstruction of type from variables occurs.
Is that the same as how Boost.typeof works ...?
acceleration a; mass m;
BOOST_TYPEOF( m * a) f; //or BOOST_AUTO(f, m * a);
regards Andy little
It is probably similar (as far as reconstruction goes). I think that specifying dimensions using variables instead of types is different. Instead of the above, you have something like: // fundamentals: <unspecified-type> length; <unspecified-type> time; <unspecified-type> mass; // etc. // composites: DIM(length / time) velocity; DIM(velocity / time) acceleration; // or DIM(length / (time * time)) DIM(mass * acceleration) force; // or DIM(mass * length / (time * time)) All of the above are variable declarations, not typedefs. They are variables that have no function except to be used in expressions for the purpose of extracting type. In a scheme like this, the user never even sees the actual types of these variables. Instead, the type is 'named' via an expression. Using this scheme, however, you can't say something like: 2 * time So you'd have to say something like: r<2> * time (or r<1, 2> to get such a fractional exponent at all). All of this is slightly more complex that what I wrote (which is no where near being a full-fledged physical quantities library), but it is all possible. Regards, Paul Mensonides