Decimal: Decimal numbers with variable precision

This is a package candidate release! Here you can preview how this package release will appear once published to the main package index (which can be accomplished via the 'maintain' link below). Please note that once a package has been published to the main package index it cannot be undone! Please consult the package uploading documentation for more information.

[maintain] [Publish]

A decimal number has an integer mantissa and a negative exponent. The exponent can be interpreted as the number of decimal places in the value.

[Skip to Readme]

Properties

Versions	0.1.0, 0.2.0, 0.2.1, 0.2.2, 0.2.3, 0.3.1, 0.4.1, 0.4.1, 0.4.2, 0.5.1, 0.5.2
Change log	None available
Dependencies	base (>=4 && <5), deepseq [details]
License	BSD-3-Clause
Copyright	Paul Johnson, 2013
Author	Paul Johnson
Maintainer	paul@cogito.org.uk
Category	Math
Home page	https://github.com/PaulJohnson/Haskell-Decimal
Uploaded	by PaulJohnson at 2014-03-24T07:47:06Z

Modules

[Index]

Data
- Data.Decimal

Downloads

Decimal-0.4.1.tar.gz [browse] (Cabal source package)
Package description (as included in the package)

Maintainer's Corner

Package maintainers

PaulJohnson

For package maintainers and hackage trustees

edit package information

Readme for Decimal-0.4.1

[back to package description]

Variable Precision Decimal Numbers
==================================

The "Decimal" type is mainly intended for doing financial arithmetic
where the number of decimal places may not be known at compile time
(e.g. for a program that handles both Yen and Dollars) and the
application must not drop pennies on the floor.  For instance if you
have to divide $10 between three people then one of them has to get
$3.34.

The number of decimal places in a value is represented as a Word8,
allowing for up to 255 decimal places.  Functions preserve precision.
Binary operators return a result with the precision of the most
precise argument, so 2.3 + 5.678 = 7.978.

If you need fixed precision decimal arithmetic where the precision is
known at compile time then Data.Number.Fixed from Lennart Augustsson's
"numbers" package is more likely to be what you want.

QuickCheck Specification
------------------------

Data.Decimal includes a set of QuickCheck properties which act as both
tests and a formal specification. To run the tests do:

   cabal configure --enable-tests
   cabal build
   cabal test



Version 0.2.1
-------------

Fixed "base" dependency.
Put test suite under "cabal test"

Version 0.2.2
-------------

Minor fixes to allow compilation under other versions of GHC.

Version 0.2.3
-------------

Added instance of NFData from Control.DeepSeq, and hence a dependency
on the deepseq package, thanks to Jeff Shaw (shawjef3 at msu.edu).

Version 0.3.1
-------------

Added Typeable, Fractional and RealFrac instances.
Multiplication now returns an exact result, increasing precision if necessary.

These changes alter the API. Hence the increment to the major version number.

Thanks to Alexey Uimanov (s9gf4ult at gmail.com).

Version 0.4.1
-------------

Improved "Read" instance. Now handles "1.2e3" and "reads" only returns a 
   single parse.
Corrected documentation.
Added "Enum" instance.
"decimalConvert" now returns a Maybe value. The old version has been renamed
   to "unsafeDecimalConvert.