Well, I should say in our case it didn't. You end up with several large functions with long lists of case statements and then separately, somewhere, a list of conversion factors. In this case we are talking about a static unit converter somewhere, and correct me if I'm wrong but I think they are in several different tables...not just tables for each dimension you will be doing conversions in but in different "systems".
At the risk of repeating myself, I would just like to point out that this library is primarily intended as a dimensional analysis library to ensure correctness, not a general purpose runtime unit conversion library. That being said, I have attempted to make the conversion architecture as flexible as possible; by appropriately specializing template<class System1,class Dim1, class System2,class Dim2, class Y> class conversion_helper< quantity<unit<System1,Dim1>,Y>, quantity<unit<System2,Dim2>,Y> > you should be able to get just about any unit conversion behavior you want. Default behavior is to only allow explicit unit conversions, but implicit conversion can be optionally enabled. I happen to implement conversions for SI and CGS units using forward and backward tables, which entails defining a conversion factor from SI->CGS and a conversion factor from CGS->SI for each fundamental unit, but nothing in the library mandates this design choice. You can roll your own to do just about anything...
there are of course only a few dimensions we do this in. I have a hard time seeing a situation in which this isn't the way you would want to go about it.
Imagine I want to compute the electrostatic force between two charged particles; the equation for this depends on the unit system you are using. In SI, the expression is F = (1/4 pi epsilon_0) q1 q2 / r12^2 in electrostatic units, this is F = q1 q2 / r12^2 Imagine I want to write a function that computes this for a computationally intensive multi-body simulation where the function is called millions or billions of times. With mcs::units, you can just do this: quantity<si::force> electrostatic_force(const quantity<si::charge>& q1, const quantity<si::charge>& q2, const quantity<si::length>& r12) { static const double k_C = 1.0/(4.0*pi*si::constants::epsilon_0); return k_C*q1*q2/(r12*r12); } quantity<esu::force> electrostatic_force(const quantity<esu::charge>& q1, const quantity<esu::charge>& q2, const quantity<esu::length>& r12) { return q1*q2/(r12*r12); } Note that there is no runtime overhead, and, more importantly, we can select the appropriate equation at compile-time. In this case, this is not just a semantic advantage; doing the calculation in SI units incurs an additional multiply for each function invocation. With runtime units, you would have to check the unit system each time the function was called - bad for simulation work. Cheers, Matthias