```/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        G E N E R A T I O N   D U   P R O F I L   D E   L ' I N F L A T I O N   C O S M I Q U E  :                                 */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*        Author of '\$xtc/inflation.11\$c' :                                                                                          */
/*                                                                                                                                   */
/*                    Jean-Francois Colonna (LACTAMME, 20130219091214).                                                              */
/*                                                                                                                                   */
/*************************************************************************************************************************************/

#include  "INCLUDES.01.I"
/* Introduit le 20051116101528...                                                            */

extern    void      *malloc();
extern    double    pow();
extern    double    sin();
extern    double    tanh();

static    int       dimX=0;
#define   Xmin      0
#define   Xmax      (Xmin + (dimX-1))
/* Definition des abscisses.                                                                 */
static    int       dimY=0;
#define   Ymin      0
#define   Ymax      (Ymin + (dimY-1))
/* Definition des ordonnees.                                                                 */

#define   IMAGE(x,y)                                                                                                                    \
(*(image + ((((y)-Ymin)*dimX) + ((x)-Xmin))))                                                                       \
/* Acces a un point de l'image.                                                              */

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

#define   nCX       (((double)(x-Xmin) / (double)(Xmax-Xmin))*(XD-XG) + XG)
#define   nCY       (((double)(y-Ymin) / (double)(Ymax-Ymin))*(YH-YB) + YB)
/* Definition des coordonnees normalisees.                                                   */
#define   dCX       (int)(((double)(cx-XG) / (double)(XD-XG))*(Xmax-Xmin) + Xmin)
#define   dCY       (int)(((double)(cy-YB) / (double)(YH-YB))*(Ymax-Ymin) + Ymin)
/* Definition des coordonnees denormalisees.                                                 */

#define   XG        (0)
#define   XD        (1)
/* Extremites Gauche et Droite sur l'axe des 'X'.                                            */
#define   YB        (0)
#define   YH        (1)
/* Extremites Bas et Haut sur l'axe des 'Y'.                                                 */

#define   pA        1
#define   pB        20
#define   pC        0.4
#define   pD        0.4
#define   pE        4
#define   pF        4
#define   pG        2
#define   pH        2
#define   pI        0.2
#define   pJ        0.2
#define   pK        0.2
#define   pL        1
#define   F1(x)     ((pA+tanh(pB*(x-pD)+pE))/pF)
#define   F2(x)     pI*(pow(pG*(x-pC),pH))
#define   F3(x)     ((pJ*x*x)+(pK*x)+pL)
#define   F(x)      F3(x)*COND((x < pC),F1(x),F1(pC)+F2(x))
/* Fonctions a coller bout a bout...                                                         */

main()
{
int                 x,y;
/* Definition des coordonnees.                                                               */
unsigned  char      *image;
/* Definition de l'image a generer...                                                        */

Get(dimX,"dimX");
Get(dimY,"dimY");
/* Recuperation des dimensions en 'X' et en 'Y' de l'image a generer.                        */

image=malloc(dimY*dimX);
/* Definition de l'image a generer...                                                        */

for       (y=Ymin ; y<=Ymax ; y++)
{
for       (x=Xmin ; x<=Xmax ; x++)
{
store(NOIR,x,y);
/* Nettoyage...                                                                              */
}
}

for       (x=Xmin ; x<=Xmax ; x++)
{
double    cx=nCX;
double    cy;

cy=F(cx);

store(BLANC,x,dCY);
}

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