Re: CA and EDP

[Richard Fateman <fateman@xxxxxxxxx>]

On 8/7/2013 1:28 AM, Ulrich Kulisch wrote:

A very impressive application is considered in [5] in the references, an iteration with the logistic equation (dynamical system)
x_n+1 := 3.75 · x_n · (1 − x_n), n >= 0.
For the initial value x₀ = 0.5 the system shows chaotic behavior. Double precision floating-point or interval arithmetic totally fail (no correct digit) after 30 iterations while long interval arithmetic still computes correct digits of a guaranteed enclosure after 2790 iterations.

I haven't looked at reference [5], but I wrote that same iteration using the Maxima computer algebra system.
Using  1597 bit fractions  (that is, about 480 decimal digits)  I got x[2790]  correct to 40 decimals.
Using complete arithmetic with 4288 bit fractions  (about 1290 decimal digits)  seems to be overkill for
this iteration at x[2790] for a scalar result.
 Using 1290 decimal digits I can get reasonable answers much further out than 2790.

I computed x[10000] using 1290 decimal digits and I got a number that I think
is good to only 3 digits.  0.8257....  at least it differs from a  5000-digit version of x[10000] which
looks like  0.8242...

I think this illustrates that using CA delays the onset of substantial loss of precision in this iteration, but
It does not cure it.

 I am not sure how to compute this using interval CA, and perhaps you cannot go beyond x[2790]
with it in long interval arithmetic as a consequence of the interval independence of the two x[n] in the formula.

 Given that multiple-precision floats of arbitrary size are now fairly commonly available,
it seems to me we could simplify the standard by noting
the possible relevance of (software) multiple-precision packages for encoding the endpoints of
intervals, including references to CA.


Here's the program.. you specific the number of decimal digits of precision, the index, and the initial point

 test(prec,m,init):=block([fpprec:prec],
           kill(x),
           x[n]:=375/100*x[n-1]*(1-x[n-1]),
           x[0]:init,
           for i thru m do x[i],
             x[m]);

test(1290, 2790,  0.5b0);

You use 0.5b0  to specify the initial value as a "bigfloat".

The arithmetic is done internally in binary.
Maxima is available free for windows, Mac, Linux on sourceforge.  Presumably other systems
would show similar results.

RJF