Let me offer another suggestion which I think can be
fitted into Haskell quite well. For the applications
of rounding choice that I'm aware of, you want to
choose when you write the code, not when you run it.
This was actually reflected in the design of a real
machine: the DEC Alpha. Floating point instructions
had variants for "whatever the PSW says" and for
"this particular mode". It would have been nice (had
DEC survived, if the Alpha were still alive) to be
able to generate the first-direction instructions, as
that's rather more efficient than switching rounding
modes twice.
Now the Haskell Way is to do things with types.
So,
newtype RoundedUp t = RoundedUp t
newtype RoundedDown t = RoundedDown t
newtype Truncated t = Truncated t
instance Floating t => Num (RoundedUp t)
where ...
instance Floating t => Num (RoundedDown t)
where ...
instance Floating t => Num (Truncated t)
where ...
...
Then one could write
let i = round (Truncated x + Truncated y)
This is just a quick sketch. I'm sure it has problems.
It does, however, deal with a fairly major problem in
attempting to use hardware rounding modes in Haskell,
and that is laziness. Putting the rounding mode in the
type means that the information is right there at each
operator without having to use monadic floating point.
_______________________________________________
Haskell-Cafe mailing list
Haskell-Cafe@haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe
