Re: [boost] Arbitrary precision arithmetic

Subject: Re: [boost] Arbitrary precision arithmetic
From: Stephen Nuchia (snuchia_at_[hidden])
Date: 2009-08-18 17:25:28

I had drafted an earlier reply but perhaps I botched sending it as I've
not seen it come through.  My opinion then was that this (a bignum
library) is a poor fit for the boost community, considering the amount
and kind of platform-specific microoptimization that goes on in the GMP
library camp.

But today I'm writing unit tests for some tricky floating-point
calculation sequences and it occurs to me that a reliable
arbitrary-precision library with a very good API would be just the thing
for calculating the "should be" values.  Support for crypto and
calculator demo programs round out the justification.

A bignum library focused primarily on portable, provably correct
"reference implementations" of the algorithms rather than on performance
would have a lot of value.

My toolbag for writing tests like these includes testing properties of
the answers rather than checking their values against predictions,
choosing input data for which the output is easy to calculate, or
writing a model of the calculation in Mathematica, executing it manually
for pre-selected values, and pasting the answers into an expected value
table.

The way Mathematica answers the questions "what is the value of this
expression, rounded to 53 bits?" is to evaluate the expression using a
heuristically determined amount of extra precision and interval
arithmetic.  If both ends of the result interval round to the same
number we have an answer, otherwise the calculation is repeated with
increasing precision until the results converge.

Having just recently taken a look at the boost::proto stuff I think it
might be possible to directly implement this concept with expressions
written in C++.  Now that would be a trip!

The boost community is not set up to duplicate what GMP does.  But I
think we could do something else very well if we focus on correctness,
portability, and metaprogramming API tastiness instead of making the
tires smoke.

If I grok the proto stuff correctly it should be possible to write
expressions that can be evaluated in different contexts.  One could be
native hardware FP arithmetic, one could be the reference bignum
library, and one could even use GMP.  Right?

-swn

Lambda expressions in a statically typed, compiled language.  It's
actually making me giddy!

Self-identified old fart story: I implemented lambda expressions in C
using a preprocessor in 1987 or 88, while working in the Sun Windows
API.  It had a very fine-grained callback design and the resulting
namespace pollution and lack of locality when reading code drove me to
it.  It actually worked really well for that application.