[CLN-list] CLN 1.2.0

[Richard B. Kreckel]

Hi,

I am releasing CLN-1.2.0.  This took much longer than I hoped it would, 
mainly because the focus of this release has been to support huge 
numbers, i.e. those with billions of decimal digits.  And turnaround 
times when testing, debugging and benchmarking programs operating on 
numbers several GiB in size can be rather stultifying.

Another major change is the introduction of C++ exceptions for error 
handling.  The cl_abort() hook is not supported any more.  This allows 
for much more flexible error handling on the side of your application. 
Please refer to the documentation to learn about existing exception types.

Also, some types have changed which might require that you have a look 
at your application code: [su]intC is used for counter loops, [su]intE 
for exponents of all floating-point numbers, and cl_boolean has been 
replaced with standard C++ bool.

As is to be expected, if one pushes the limits of known digits, memory 
consumption becomes a critical issue.  So, CLN 1.2.0's constants and 
transcendental functions are noticeably more memory efficient than in 
previous releases.  There are two reasons for this: First, more use has 
been made of the streamed binary splitting implementation, only used 
casually in earlier versions: There, the rational series terms are not 
precomputed before starting the binary splitting algorithm but rather 
computed when they are needed.  The second reason is that while 
performing the binary splitting, some intermediate integer results may 
become much larger than the result's precision warrants.  As it turns 
out, that excess precision can simply be truncated by coercing the 
result into a cl_LF of appropriate length.  Basically, this compresses 
the extra digits into the floating-point exponent.  With some rational 
series, the savings are dramatic.  As an extreme example, attached is a 
picture of the memory footprint when computing one million decimal 
digits of Euler's gamma.  The red curve corresponds to CLN-1.1.x while 
the blue one to CLN 1.2.0.  Here, making the operands smaller even saves 
computing time.

The library has undergone tests with operands of billions of decimal 
digits and I have stopped finding errors many months ago.  This makes me 
confident to trust a computation of over 1 billion decimal digits of 
Euler's constant gamma which took one week (and another week for a 
verification on another machine with even higher precision).  Instead of 
pasting the result here, let me just write it in regexpese:

     decimal(gamma) =~ "0.57721566[0-9]{1001262760}39288477"

According to Wikipedia [1] and Xavier Gourdon's list [2], this 
establishes the current world record.  It more than eightfolds the 
previous world record by Alexander J. Yee and by the way confirms that 
earlier record's correctness.  (I've emailed Mr. Gourdon, but he doesn't 
seem to be tracking numerical world records any more, so one cannot be 
so sure.)

Oh, and last but not least, I should say a big THANK YOU to the people 
who made contributions to this release.  You'll find the names in the 
ChangeLog.

Enjoy
   -richy.

[1] <http://en.wikipedia.org/wiki/Mathematical_constant>
[2] <http://numbers.computation.free.fr/Constants/Gamma/gamma.html>
[3] <http://numberworld.org/euler116m.html>
-- 
Richard B. Kreckel
<http://www.ginac.de/~kreckel/>
-------------- next part --------------
A non-text attachment was scrubbed...
Name: euler.png
Type: image/png
Size: 5078 bytes
Desc: not available
Url : http://www.cebix.net/pipermail/cln-list/attachments/20080119/66b886f4/euler.png