/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        G E N E R A T I O N   D ' U N E   I M A G E   C O N T E N A N T   L ' A T T R A C T E U R   D E   H E N O N                */
/*        A V E C   T E S T   D E   L ' A S S O C I A T I V I T E   D E   L A   M U L T I P L I C A T I O N  :                       */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*                  Std                                                                                                              */
/*                  $aPout    | $xci/display$X    p=$xiP/cercle.22                                                                   */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*        Author of '$xtc/henon.02$c' :                                                                                              */
/*                                                                                                                                   */
/*                    Jean-Francois Colonna (LACTAMME, AAAAMMJJhhmmss).                                                              */
/*                                                                                                                                   */
/*************************************************************************************************************************************/

#include  <stdio.h>
#include  <fcntl.h>

#define   PRECIS    double                                                                                                              \
                                        /* Permet de travailler en 'double' ou en 'float'.                                           */

#define   pas       10
#define   N         10
                                        /* Nombre d'iterations...                                                                    */

#define   Tx        1.3
#define   Ty        1.275
#define   echelle   0.40
                                        /* Translation et echelle des valeurs des deux suites. Ces constantes sont calculees suivant */
                                        /* la methode suivante :                                                                     */
                                        /*                                                                                           */
                                        /*                                            1          \                                   */
                                        /*                  echelle            = -----------     |                                   */
                                        /*                                        MXn - mXn      | de facon a placer l'abscisse de   */
                                        /*                                                       | l'origine au centre de l'image.   */
                                        /*                                                       |                                   */
                                        /*                  Tx                 = -mXn            /                                   */
                                        /*                                                                                           */
                                        /* echelle*(0.0 + Ty) = 0.5 (c'est-a-dire l'ordonnee du milieu de l'image dans [0,1])        */
                                        /*           .                                                                               */
                                        /*          /|\                                            |                                 */
                                        /*           |            ordonnee de l'origine            |                                 */
                                        /*           |_____________________________________________|                                 */
                                        /*                                                                                           */
                                        /*                                                                                           */

#define   dimX      512
#define   Xmin      0
#define   Xmax      (Xmin + (dimX-1))
#define   Cx(x)     ((int)(Xmin + ((echelle*((x+Tx)))*(Xmax-Xmin))))
                                        /* Definition des abscisses et de la fonction de passage de [0,1] a [Xmin,Xmax].             */

#define   dimY      512
#define   Ymin      0
#define   Ymax      (Ymin + (dimY-1))
#define   Cy(y)     ((int)(Ymin + ((echelle*((y+Ty)))*(Ymax-Ymin))))
                                        /* Definition des ordonnees et de la fonction de passage de [0,1] a [Ymin,Ymax].             */

#define   IMAGE(x,y)                                                                                                                    \
                    image[y][x]                                                                                                         \
                                        /* Acces a un point de l'image.                                                              */

#define   store(n,x,y)                                                                                                                  \
                    {                                                                                                                   \
                    if   ((((Cx(x)) >= Xmin) && (Cx(x) <= Xmax)) && ((Cy(y) >= Ymin) && (Cy(y) <= Ymax)))                               \
                         {                                                                                                              \
                         IMAGE(Cx(x),Cy(y)) = n;                                                                                        \
                         }                                                                                                              \
                    else                                                                                                                \
                         {                                                                                                              \
                         }                                                                                                              \
                    }                                                                                                                   \
                                        /* Rangement d'un point valide d'une image.                                                  */

#define   A         1.0
#define   B         1.4
#define   C         0.3
                                        /* L'attracteur de Henon est defini par l'iteration :                                        */
                                        /*                                                                                           */
                                        /*                                      2                                                    */
                                        /*                  X    = A + Y  - B.X                                                      */
                                        /*                   n+1        n      n                                                     */
                                        /*                                                                                           */
                                        /*                                                                                           */
                                        /*                  Y    = C.X                                                               */
                                        /*                   n+1      n                                                              */
                                        /*                                                                                           */
#define   X0        0.00
#define   Y0        0.00

#define   niveau1   72
#define   niveau2   145

main()
     {
     PRECIS              Xn1=X0,Yn1=Y0;
     PRECIS              sXn1,sYn1;
     PRECIS              Xn2=X0,Yn2=Y0;
     PRECIS              sXn2,sYn2;
                                        /* Definition des deux formulations du couple (Xn,Yn).                                       */

     int                 n;
                                        /* Definition de l'index d'iteration.                                                        */
     int                 x,y;
                                        /* Definition des coordonnees.                                                               */
     unsigned  char      image[dimY][dimX];
                                        /* Definition de l'image a generer...                                                        */

     for  (y=Ymin ; y<=Ymax ; y++)
          {
          for  (x=Xmin ; x<=Xmax ; x++)
               {
               IMAGE(x,y) = 0;
               }
          }
                                        /* Nettoyage de l'image...                                                                   */

     for  (n=0 ; n<(N*pas) ; n++)
          {
          if   ((n%pas) == 0)
               {
               fprintf(stderr,"\n X1(%3d) = %18.14g",n,Xn1);
               fprintf(stderr,"   Y1(%3d) = %18.14g",n,Yn1);

               fprintf(stderr,"   X2(%3d) = %18.14g",n,Xn2);
               fprintf(stderr,"   Y2(%3d) = %18.14g",n,Yn2);
               }
          else
               {
               }

          store(niveau1,Xn1,Yn1);
          store(niveau2,Xn2,Yn2);
                                        /* Generation de l'image point par point...                                                  */

          sXn1 = A + Yn1 - (B*(Xn1*Xn1));
          sYn1 = C*Xn1;
          Xn1 = sXn1;
          Yn1 = sYn1;

          sXn2 = A + Yn2 - (Xn2*(B*Xn2));
          sYn2 = C*Xn2;
          Xn2 = sXn2;
          Yn2 = sYn2;
                                        /* Iteration...                                                                              */

          }

     write(1,image,dimX*dimY);
                                        /* Sortie de l'image...                                                                      */
     }