Haskell Data.Decimal for rounding issue?

Question

I would like to create a list of all the real numbers between 1.0 and 2.0 in two-decimal-place increments. This

dList = [1.00,1.01..2.00]

however, creates float run-on problems

dList = [1.0,1.01,1.02,1.03,1.04,1.05,1.06,1.07,1.08,1.09,1.1,1.11,1.12,
1.1300000000000001,1.1400000000000001,1.1500000000000001, ...

To remedy this I found what I thought was a function in Data.Decimal namely, roundTo. I was hoping to eventually run this

map (roundTo 2) [1.1,1.2..2.0]

and get rid of the float run-on, but it produces a giant error message. This page is for this beginner undecipherable. And so I'm trying to do this with an hs file loaded at a ghci REPL. This is the code

import Data.Decimal

dList :: [Decimal]
dList = [1.00,1.01..2.0]

main = print dList

and it produces

Could not find module ‘Data.Decimal’

Lost, I am....

leftaroundabout · Accepted Answer

Answer to your specific float problem

By far the simplest option in this case is

[n/100 | n<-[0..200]]

or variations on the same idea:

map (/100) [0..200]
(*1e-2) . fromIntegral <$> [0 .. 200 :: Int] -- (*) is more efficient than (/),
                                             -- but will actually introduce rounding
                                             -- errors (non-accumulating) again

No need for any special decimal library or rational numbers.

The reason this works better than the [x₀, x₁ .. xe] approach is that integers below 2⁵² can be expressed exactly in floating point (whereas decimal fractions cannot). Therefore, the range [0..200] is exactly what you want it to be. Then at the end, dividing each of these numbers by 100 will still not give you exact representations of the hundredths you want to get – because such representations don't exist – but you will for each element get the closest possible approximation. And that closest possible approximation is in fact printed in x.yz form, even with the standard print function. By comparison, in [1.00,1.01..2.0] you keep adding up already-approximate values, thereby compounding the errors.

You could also use your original range calculation in exact rationals, and only then convert them to float^★ – this still doesn't require a decimal library

map fromRational [0, 0.01 .. 2]

Rational arithmetic is often an easy fix for similar problems – but I tend to advise against this, because it usually scales badly. Algorithms that have rounding problems in floating-point will more often than not run into memory problems in rational arithmetic, because you need to carry an ever-growing range of precision through the entire calculation. The better solution is to avoid needing the precision in the first place, like with the n/100 suggestion.

Also, arguably the [x₀, x₁ .. xe] syntax is a broken design anyway; integer ranges have far clearer semantics.

Note also that the float errors in your original attempt aren't necessarily a problem at all. An error of 10^-9 in a real-world measured quantity is for all meaningful purposes neglectable. If you need something to be truely exact, you probably shouldn't be using fractional values at all, but straight integers. So, conside Carl's suggestion of just living with the float-deviations, but simply printing them in a suitably rounded form, by way of showFFloat, printf, or Text.Show.Pragmatic.print.

^★_{Actually, in this specific case both solutions are almost equivalent, because converting Rational to float involves floating-point dividing the numerator by the denominator.}

Answer to your module-loading problem

In cases where you do need the Decimal library (or some other library), you need to depend on it.

The easiest way to do this is to use Stack and add Decimal to your global project. Then, you can load the file with stack ghci and it'll know where to look for Data.Decimal.
Alternatively, and IMO preferrably, you should create a project package yourself and only make that depend on Decimal. This can be done with either Stack or Cabal-install.
```
$ mkdir my-decimal-project
$ cd my-decimal-project
$ cabal init
```
Now you're being asked some questions about the name etc. of your project, you can mostly answer with the defaults. Say your project defines a library (you can add an executable later on if you want.)

cabal init creates amongst other things a my-decimal-project.cabal file. In that file, add Decimal to the dependency, and your own source file to exposed-modules.

Then you need to (still in your project directory) cabal install --dependencies-only to fetch the Decimal library, and then cabal repl to load your module.

Haskell Data.Decimal for rounding issue?

Answers (2)

Answer to your specific float problem

Answer to your module-loading problem

Related Questions