Decimal Numbers

[Paul D Anderson via Digitalmars-d-announce]

A candidate implementation of decimal numbers (arbitrary-precision
floating-point numbers) is available for review at
https://github.com/andersonpd/eris/tree/master/eris/decimal. This 
is a
substantial rework of an earlier implementation which was located 
at
https://github.com/andersonpd/decimal.

This is a D language implementation of the General Decimal 
Arithmetic
Specification (http://www.speleotrove.com/decimal/decarith.pdf), 
which is
compliant with IEEE-754 and other standards as noted in the 
specification.

The current implementation is not complete; there are a lot of 
TODOs and NOTEs
scattered throughout the code, but all the arithmetic and 
miscellaneous
operations listed in the spec are working, along with decimal 
versions of most
of the functions and constants in std.math. I think it is far 
enough along for
effective review.

Briefly, this software adds the capability of properly rounded
arbitrary-precision floating-point arithmetic to the D language. 
All arithmetic
operations are governed by a "context", which specifies the 
precision (number of
decimal digits) and rounding mode for the operations. This same 
functionality
exists in most modern computer languages (for example, 
java.math.BigDecimal).
Unlike Java, however, which uses function syntax for arithmetic 
ops
(add(BigDecimal, BigDecimal), etc.), in D the same arithmetic 
operators that
work for floats or doubles work for decimal numbers. (Of course!)

In this implementation decimal numbers having different contexts 
are different
types. The types are specified using template parameters for the 
precision,
maximum exponent value and rounding mode. This means that
Decimal!(9,99,Rounding.HALF_EVEN) is a different type than
Decimal!(19,199,Rounding.HALF_DOWN). They are largely 
interoperable, however.
Different decimal types can be cast to and from each
other.

There are three standard decimal structs which fit into 32-, 64- 
and 128-bits of
memory, with 7, 16 and 34 digit precision, respectively. These 
are used for
compact storage; they are converted to their corresponding 
decimal numbers for
calculation. They bear the same relation to decimal numbers as 
Walter's
half-float type does to floats.
(http://www.drdobbs.com/cpp/implementing-half-floats-in-d/240146674).
Implementation of these still needs a little work, and will be 
added to github
very shortly.

Major TODO items:

1) The current underlying integer type uses my own big integer 
struct
(eris.integer.extended) rather than std.bigint. This was mainly 
due to problems
with constness and CTFE of BigInts. These problems have since 
been resolved, but
I didn't want to switch over to BigInts until everything was 
working for fear of
introducing new bugs.

2) Integration of Decimal32, Decimal64 and Decimal128 structs are 
not complete.
(See above.)

3) Conversion to and from floats, doubles and reals is currently 
working but it
is slow. (Conversion is through strings: double to string to 
decimal and vice
versa.)

4) Still incomplete implementations of some functions in 
decimal.math: expm1,
acosh, atanh, possibly others.

5) More unit tests (always!).