/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        E T U D E   D E S   O P T I O N S   D ' O P T I M I S A T I O N                                                            */
/*        P O U R   U N   P S U D O - A T T R A C T E U R   D E   L O R E N Z                                                        */
/*        ( C O N T E N A N T   D E S   T E R M E S   E N   ' x*y*z ' )  :                                                           */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*        Author of '$xtc/lorenz.21$c' :                                                                                             */
/*                                                                                                                                   */
/*                    Jean-Francois Colonna (LACTAMME, AAAAMMJJhhmmss).                                                              */
/*                                                                                                                                   */
/*************************************************************************************************************************************/

#include  <stdio.h>

#define   ITER      12701
#define   PRECIS    double                                                                                                              \
                                        /* Permet de travailler en 'double' ou en 'float'.                                           */
#define   DT        0.01
#define   X0        0.01
#define   Y0        0.01
#define   Z0        0.01

main()
     {
     int       n;

     PRECIS    x1 = X0,dx1;
     PRECIS    y1 = Y0,dy1;
     PRECIS    z1 = Z0,dz1;

     PRECIS    x2 = X0,dx2;
     PRECIS    y2 = Y0,dy2;
     PRECIS    z2 = Z0,dz2;

     PRECIS    dt = DT;

     int       print=1;

     for       (n=1 ; n<=ITER ; n++)
               {
               if        (print == 0)
                         {
                         printf("\n x1=%+10.6f y1=%+10.6f z1=%+10.6f",x1,y1,z1);
                         printf("\n x2=%+10.6f y2=%+10.6f z2=%+10.6f",x2,y2,z2);
                         }
               else
                         {
                         }

               dx1 = (-10.0*x1 + 10.0*y1 - 0.02*x1*y1*z1)*dt;
               dy1 = (28.0*x1 - y1 - x1*z1 + 0.01*x1*y1*z1)*dt;
               dz1 = ((-8.0 / 3.0)*z1 + x1*y1 + 0.01*x1*y1*z1)*dt;

               dx2 = -10.0*x2*dt + 10.0*y2*dt - 0.02*x2*y2*z2*dt;
               dy2 = 28.0*x2*dt - y2*dt - x2*z2*dt + 0.01*x2*y2*z2*dt;
               dz2 = (-8.0 / 3.0)*z2*dt + x2*y2*dt + 0.01*x2*y2*z2*dt;
                                        /* ATTENTION, il ne faut pas de parentheses et il est imperatif de ne pas mettre 'dt' en     */
                                        /* facteur commun et ce afin d'avoir des produits a 3 termes...                              */

               x1 = x1 + dx1;
               y1 = y1 + dy1;
               z1 = z1 + dz1;

               x2 = x2 + dx2;
               y2 = y2 + dy2;
               z2 = z2 + dz2;
               }
     printf("\n 'dt' non distribue : iterations=%d   x1=%+10.6f y1=%+10.6f z1=%+10.6f",n-1,x1,y1,z1);
     printf("\n 'dt' distribue     : iterations=%d   x2=%+10.6f y2=%+10.6f z2=%+10.6f",n-1,x2,y2,z2);
                                        /* Avec 'cc -O0', donne :                                                                    */
                                        /*                                                                                           */
                                        /*        'dt' non distribue : iterations=12701   x1=-24.096380 y1= -8.203284 z1=+41.243466  */
                                        /*        'dt' distribue     : iterations=12701   x2= +4.641505 y2= +7.711528 z2=+19.545368  */
                                        /*                                                                                           */
                                        /* et avec 'cc -O3', donne :                                                                 */
                                        /*                                                                                           */
                                        /*        'dt' non distribue : iterations=12701   x1= -6.589218 y1=-11.343677 z1=+10.877308  */
                                        /*        'dt' distribue     : iterations=12701   x2= -0.186530 y2= -0.543707 z2=+20.303556  */
                                        /*                                                                                           */
                                        /* ainsi grace aux termes en 'x*y*z', {x1,y1,z1} ('dt' non distribue), tout comme {x2,y2,z2} */
                                        /* ('dt' distribue), depend de l'optimisation...                                             */
     printf("\n");
     }