```/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        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...                                                                      */
}
```