Subject: Number crunching in 16-byte precision.

From: [email-masked] (Robert Gdanitz)
Date: Mon, 4 Mar 1996 20:44:27 +0100 (MEZ)

+-----+  Robert J. Gdanitz                      email: [email-masked]
| GhK |  Gesamthochschule Kassel                Tel.: +(49) 561-804-4556
|     |  Fachbereich 18 (Physik)                Fax:  +(49) 561-804-4006
+-----+  34109 Kassel 
X-Mailer: ELM [version 2.4 PL24 PGP3 *ALPHA*]
MIME-Version: 1.0
Content-Type: text/plain; charset=ISO-8859-1
Content-Transfer-Encoding: 8bit
Content-Length: 3014      

Dear Netters,

I think it is justified to say that most of us are quite satisfied with, as well the pre-
cision (approx. 2.22E-16 in IEEE) as the performance of the usual "working precision" 
arithmetic (8-byte, real*8, "double-precision" is, if at all, not much slower than 4-byte,
real(*4), "single precision") in our routinely calculations which, in some cases, may take
considerable time. I have heard that once there was a time, when the working precision
was real*4 or something in between real*4 and real*8 which e.g. frequently gave rise to 
problems with numerical stability in quantum chemical calculations and double precision
was prohibitively slow, but this now is history.

Anyway, there are still people who want to push things to the limit (like me) who do their
calculations in a way, that even real*8 precision is not sufficient. And the problems do
not arise because I need to have, say 16 or more figures accuracy in the final result, or
because from the algorithms available to solve a certain problem, due to some reason, I
choose the one most prone to numerical instabilities.

What I actually want to do, is to solve the Schroedinger equation of some small chemical 
system (e.g. N2) to "chemical accuracy" (1 kcal/mol) which still has not yet been achieved
all (even "small") cases (e.g. the De of N2). One could give e.g. MR-CI-(SD) or CC(SD)[T]
a try, but the convergence of De with respect to the increase of the size of the basis set
(n) is VERY slow (~ n^-3). Recently, I managed to combine Kutzelnigg's and Klopper's 
"r12"-method with MR-CI(SD), resp. MR-ACPF to get a convergence ~ n^7, but there are still
problems to be solved...

The r12-method uses explicitly correlated terms which, when rather diffuse orbitals are 
joined by r12, are highly redundant. On the other hand, I cannot easily remove these terms
because then problems with e.g. proper dissociation or size-extensivity may arise. So I
have to do some fiddling with the CI- as well as with the r12-ansatz, i.e. I have to re-
move e.g. orbitals with high energy and r12-terms which are not necessary and I always 
have to check that I am indeed allowed to do so, which makes things somewhat tedious.

OK, now that I have these problems with numerical stability, why do I not simply switch to
real*16 arithmetic and be happy? Well, I found out that on our only computer where I can
dump some GByte temporary data (it's a SGI Power Challenge) real*16 arithmetic, when used
for e.g. a dot-product of two vectors, is 300 times slower than real*8. Since I cannot 
afford to wait one year to compute what takes one day in real*8, I'm in serious trouble. 
On the other hand, our IBMs, which degrade only by about 30 in the present case, do not
have enough temporary disc space available.

Anyway, if there is anybody out there who has experience doing large scale computations
in real*16, please tell me your experience with computers & algorithms.

As usual, I will summarize to the net.

Thanks in advance,
Robert Gdanitz