Decimal Numbers

[Iain Buclaw via Digitalmars-d-announce]

On 3 Jul 2014 23:00, "Paul D Anderson via Digitalmars-d-announce" <
digitalmars-d-announce at puremagic.com> wrote:
>
> 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!).

Nice job.

I would also add:

6) Rename the file decimal.d to package.d, and module eris.decimal.decimal
to eris.decimal
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.puremagic.com/pipermail/digitalmars-d-announce/attachments/20140704/cd49fbda/attachment-0001.html>