In the Currency Module the precision of a number is the number of digits that number can contain. When using RWDecimal<T> or RWFixedDecimal<T>, you set the precision of the numbers that the classes will represent by replacing the <T> with an integer type. The Currency Module provides class RWMultiPrecisionInt<n> to define an integer type. In addition, the Currency Module provides three RWMultiPrecisionInt<n> typedefs: RWMP1Int, RWMP2Int, and RWMP3Int.

The private class RWMultiPrecisionInt<n> provides a very large number of bits of precision for representing decimals. By replacing the <n> in RWMultiPrecisionInt<n> with an integer from 1 to 16, you can specify up to 16 *32, or 512 bits of precision. For example, the following declaration creates a number that will have 5 *32 or 160 bits of precision:

RWMultiPrecisionInt<n> has been specialized for n =1, since this case would use only one integer to represent a value, and you would be better off simply using an int. When n= 1, a type double stores the integer value.

The speed of computation changes depend upon the number of bits used for precision. This means that a computation that uses class RWDecimal<RWMultiPrecisionInt<1> > is faster than the same computation using RWDecimal<RWMultiPrecisionInt<16> >.

For ease of use, the Currency Module provides the three integer types shown in Table 4. These types provide 52-bit, 64-bit, and 96-bit precision.

Any number that can be written using 18 digits, a decimal point, and a sign can be represented exactly using an RWDecimal<RWMP2Int>. Table 5 describes the size of numbers that can be represented using a given number of digits.

Note that the speed of computation falls as the number of bits increases. The RWDecimal<RWMP1Int> and RWFixedDecimal<RWMP1Int> classes provide the fastest computations and can deal with numbers that are large enough for the vast majority of financial applications. Classes RWDecimal<RWMP2Int> and RWFixedDecimal<RWMP2Int> are slightly slower, but can handle the larger numbers required by some institutions. The RWDecimal<RWMP3Int> and RWFixedDecimal<RWMP3Int> classes are slightly slower still, but can handle the overwhelming majority of numbers required for financial applications.

For a floating decimal point class,RWDecimal<T>, the decimal point is changed as necessary when operations are performed. For a fixed decimal point class,RWFixedDecimal<T>, the number of digits after the decimal point is fixed. Fixed decimal classes are useful for representing, for example, bank account balances where there must always be exactly two decimal places. The following two code fragments illustrate the difference between floating and fixed classes:

Once set, the number of decimal places for a fixed decimal point class remains constant. Any value later assigned to it will be rounded to that number of decimal places. An important exception to this rule occurs when an RWFixedDecimal<T> has the value null. When a fixed decimal class has a value of null, it will take on the number of decimal places of an assigned value. Since the default constructor produces a null value, this feature can be particularly useful. For example:

is equivalent to

Elements of an array are initialized to a null value. This means that the number of decimal places for an element is not determined until a value is assigned to that element.