/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        R E C H E R C H E   D E S   E X T R E M A                                                                                  */
/*        D E   L ' A T T R A C T E U R   D E   L O R E N Z  :                                                                       */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*        Author of '$xtc/lorenz.01$c' :                                                                                             */
/*                                                                                                                                   */
/*                    Jean-Francois COLONNA (LACTAMME, AAAAMMJJhhmmss).                                                              */
/*                                                                                                                                   */
/*************************************************************************************************************************************/

#define   ITER      10000
#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
                                        /* ATTENTION, les ecritures :                                                                */
                                        /*                                                                                           */
                                        /* 0.01                                                                                      */
                                        /*                                                                                           */
                                        /* et                                                                                        */
                                        /*                                                                                           */
                                        /* (((1.0)/10)/10)                                                                           */
                                        /*                                                                                           */
                                        /* ne sont pas equivalentes sur 'SYSTEME_FX2800_CONCENTRIX' ; c'est cette difference qui     */
                                        /* est responsable de la divergence des resultats avec 'SYSTEME_NWS3000_NEWSOS'. Par contre  */
                                        /* sur 'SYSTEME_VAX9000_ULTRIX' cela ne joue pas, et la divergence est causee par les        */
                                        /* differences au niveau du calcul arithmetique.                                             */
#define   MIN(a,b)  (((a) < (b)) ? (a) : (b))
#define   MAX(a,b)  (((a) > (b)) ? (a) : (b))
main()
     {
     int       n;
     PRECIS    x = X0,dx;
     PRECIS    y = Y0,dy;
     PRECIS    z = Z0,dz;
     PRECIS    dt = DT;
     PRECIS    mx = 1e30,Mx = -1e30;
     PRECIS    my = 1e30,My = -1e30;
     PRECIS    mz = 1e30,Mz = -1e30;
     PRECIS    mdx = 1e30,Mdx = -1e30;
     PRECIS    mdy = 1e30,Mdy = -1e30;
     PRECIS    mdz = 1e30,Mdz = -1e30;

     int       print=1;

     for       (n=1 ; n<=ITER ; n++)
               {
               mx = MIN(x,mx);Mx = MAX(x,Mx);
               my = MIN(y,my);My = MAX(y,My);
               mz = MIN(z,mz);Mz = MAX(z,Mz);

               if        (print == 0)
                         {
                         printf("\n x=%12.8g   y=%12.8g   z=%12.8g",x,y,z);
                         }
               else
                         {
                         }

               dx = ((-10.0 * x) + (10.0 * y)) * dt;
               dy = ((28.0 * x) - (y) - (x * z)) * dt;
                                        /* Les ecritures :                                                                           */
                                        /*                                                                                           */
                                        /* dy = ((28.0 * x) - (y) - (x * z)) * dt;                                                   */
                                        /* dy = ((28.0 * x) - (x * z) - (y)) * dt;                                                   */
                                        /* dy = ((28.0 * x) - ((y) + (x * z))) * dt;                                                 */
                                        /*                                                                                           */
                                        /* ne sont pas equivalentes, sauf s'il y a peu d'iterations (1000 ou moins...), mais pour    */
                                        /* 10000 et plus...                                                                          */
               dz = (((-8.0 / 3.0) * z) + (x * y)) * dt;

               mdx = MIN(dx,mdx);Mdx = MAX(dx,Mdx);
               mdy = MIN(dy,mdy);Mdy = MAX(dy,Mdy);
               mdz = MIN(dz,mdz);Mdz = MAX(dz,Mdz);

               if        (print == 0)
                         {
                         printf("   -->   dx=%12.8g   dy=%12.8g   dz=%12.8g   (dt=%12.8g)",dx,dy,dz,dt);
                         }
               else
                         {
                         }

               x = x + dx;
               y = y + dy;
               z = z + dz;
               }
     printf("\n iterations=%d   x=%12.8g   y=%12.8g   z=%12.8g\n",n-1,x,y,z);

     printf("\n min(x)=%12.8g   max(x)=%12.8g",mx,Mx);
     printf("\n min(y)=%12.8g   max(y)=%12.8g",my,My);
     printf("\n min(z)=%12.8g   max(z)=%12.8g",mz,Mz);

     printf("\n min(dx)=%12.8g   max(dx)=%12.8g",mdx,Mdx);
     printf("\n min(dy)=%12.8g   max(dy)=%12.8g",mdy,Mdy);
     printf("\n min(dz)=%12.8g   max(dz)=%12.8g",mdz,Mdz);
     }