Analysis of the Method

The advantages of the proposed method are as follows:

• Full analysis of dimensional correctness before run-time.
• No run-time space overhead for dimensional data, unlike the method proposed in [CG88]. Space is used for storing conversion factors and print-names, but similar amounts of space would be used by any method which converted between units or printed them out.
• Once compiler technology for processing inline template functions is sufficiently developed, there should not be any substantial time or code-space overhead. This follows from the statement on pg. 342 of the ARM that the C++ template mechanism ``allows close to optimal run-time performance through macro expansion of definitions and inlining of function calls.''
• The method almost fits into an existing language and is accepted by an existing compiler. This is in contrast to methods like those in [Geh77] or [Hou83] which require changes to existing languages.
• Higher programmer productivity, since programmers need not spend their time tracking down dimensional errors at run-time.

Some of the disadvantages of the method, along with possible solutions are:

• All quantities having a particular dimension use the same internal unit. Hence the programmer does not have sufficient control over the precision of dimensional quantities, which may lead to an accumulation of floating point error. This may be the most serious disadvantage of the method. It may be possible to extend the method to allow multiple reference units along each dimension. In the interim, a possible workaround would be for the programmer to assign the same quantity to multiple dimensions having internal units of different precision, and manually program operations involving these dimensions.
• The binary arithmetic operations require that their operands be dimensioned quantities with identical underlying types. This can be inconvenient when dimensioned quantities contain multiple underlying types. For example, addition of a dimensioned int to a dimensioned double is not supported.
• No direct support for derived units. However, it is always possible for the programmer to include definitions like:

  #define Newton	(Kg*Meter/(Sec*Sec))
  #define Newton_	(Kg_*Meter_/(Sec_*Sec_))

  and to provide output functions to handle such derived units.
• The set of dimensions required by the program must be known at compile-time.
• It is not possible to represent relationships between units having different origins (like that between the Celsius and Fahrenheit temperature scales). This should not be a problem as such situations are relatively uncommon.
• An increase in compilation time (by over a factor of 3 for the example in section 4). However, it is still much easier for a compiler rather than a human to find errors.
• In some C++ environments, a few dimensional errors may not be detected until link-time when definitions are generated for template functions. This may be rather inconvenient.
• Errors are not reported in terms of dimensional violations, but in terms of missing function definitions. The error messages often contain instantiated template arguments and even mangled function names. It may be hard for a programmer to relate an error message to a dimensional error. Tools could be developed to convert concrete error messages to more abstract dimensional error messages.
• Some C++ environments expect help from the programmer in determining which template instantiations are required. The package provides the programmer with a macro to declare instances of all the (hidden and visible) template classes used by it, but the programmer still needs to determine which instances need to be declared.
• The code produced by the one compiler (G++) known to accept the package is currently of poor quality with no inline expansion of template functions. Hopefully, this problem should disappear over time, for the reasons mentioned above. In the interim, a program should first be compiled with full dimensional checking. Once it is free of dimensional errors, it can be recompiled with dimensional checking turned off (as discussed in the previous section). However, this recompilation is rather inconvenient and some programmers may sometimes choose to omit the first compilation step.