Decimals unit

Download

UPDATE: If you downloaded a version from before July 1, 2010, please download the new version 2.0. It was improved and made faster. The files uploaded May 21 were apparently still not good enough, see below

To calculate non-integral numbers, most programming languages provide floating point types. These are usually fast, because they often are FPU-supported, but there are quite a few problems with their accuracy. More about the problems you can expect can be found in my article about Floating Point Numbers.

In Microsoft .NET, there is a type, called Decimal that is not FPU-supported, but very accurate in a defined range. The Decimals unit tries to emulate this type as well as possible, in Delphi (and a lot of assembler). The internal format is exactly the same, but the routines that manipulate the bits were entirely written by me.

Currently, this is a Win32 type only. Most important routines are in 32 bit assembler. I intend to write a 64 bit assembler version of these routines too, and even a “PUREPASCAL” (i.e. no assembler) version.

The Decimal type

Unlike the FPU-supported types, this type uses a decimal “exponent”, although in this case the exponent is more like a scaling factor, and has a range of 0..28. The mantissa is binary, but much larger than that of the FPU types: it contains 96 bits. The sign bit is stored separately. The exact format is like this:

Unlike most other floating point types, this type has a different format for values like 0.1 and 0.1000. The first value is stored as mantissa 1 and a scaling factor of 1 (i.e. as 1 × 10⁻¹). The second is stored as 1000 with a scaling factor of 4 (i.e. as 1000 × 10⁻⁴), etc. In other words, this type “remembers”, as much as possible, the number of decimals entered. Of course, if you multiply or divide, you will get more decimals.

Although values like 0.123 and 0.1230000 are stored differently, the comparison routines and operators recognize them as equal.

The Decimal type is a record type. That enables it to be used like any other numeric type. It has operators for comparison, simple arithmetic like addition, subtraction, multiplication and division, and conversion operators to and from other numeric types.

A simple code example:

var
  A, B, C: Decimal;
begin
  A := '1.2345'; // I said it was a little simple
  B := '3.49';
  C := A + B;
  Writeln('C = ', C.ToString);
end;

The output is, as expected:

C = 4.7245

Initialization is best done using one of the conversion operators. If you want a specific format, with a specific number of decimals, use the conversion operator that converts from a string:

myDecimal := '1.3456';

If you want to control the exact contents of the Decimal, you can use the following constructor:

constructor Create(Lo, Mid, Hi: Longword; IsNegative: Boolean; Scale: Byte);

To get the exact contents, you can use the GetBits function.

Additionally to the functions and operators discussed above, Decimal has a full set of conversion functions and the usual mathematic functions, like Abs, Floor, etc. There is a ToString function that converts the Decimal to a string. The other ToString function that takes a Format string is not functional yet, but is being worked on.

The simple DecimalDevelopment program shows a few ways to use the type.

Speed

As I already mentioned, the type is not FPU-supported. This means it is a lot slower than the normal FPU types like Single, Double or Extended. I did my best to make the routines as fast as I could, using assembler everywhere it made sense, but 96 bit multiplications or divisions are not really fast, even when they are done in assembler. This produces the desired results, but I’m glad about any suggestion to speed up the type. Just e-mail me.

Conclusion

I hope this code is useful to you. If you use some of it, please credit me. If you modify or improve the unit, please send me the modifications.

I may improve or enhance the unit myself, and I will try to post changes here. But this is not a promise. Please don’t request features.

Rudy Velthuis