/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        E T U D E   D E   L A   C O M P L E X I T E   S T R U C T U R E L L E                                                      */
/*        D E   P O I N T S   P S E U D O - A L E A T O I R E S   D A N S   U N   C A D R E   L I M I T E  :                         */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*        Author of '$xrC/ObjetComplexe.J1$vv$c' :                                                                                   */
/*                                                                                                                                   */
/*                    Jean-Francois Colonna (LACTAMME, 20130620140731).                                                              */
/*                                                                                                                                   */
/*************************************************************************************************************************************/

#ifdef    COMMENTS
#         undef     COMMENTS
#else
#endif

#define   COMMENTS  "Points pseudo-aleatoires type 'drand48(...)' dans un cadre limite (format octet) -noir ou blanc-"

#define   DEFINE_01 "-DXCOTE=gDIVI(dimX,2)  -DYCOTE=gDIVI(dimY,2)"
#define   DEFINE_02 "-DXCOTE=gDIVI(dimX,3)  -DYCOTE=gDIVI(dimY,3)"
#define   DEFINE_03 "-DXCOTE=gDIVI(dimX,4)  -DYCOTE=gDIVI(dimY,4)"
#define   DEFINE_04 "-DXCOTE=gDIVI(dimX,5)  -DYCOTE=gDIVI(dimY,5)"
#define   DEFINE_05 "-DXCOTE=gDIVI(dimX,6)  -DYCOTE=gDIVI(dimY,6)"
#define   DEFINE_06 "-DXCOTE=gDIVI(dimX,7)  -DYCOTE=gDIVI(dimY,7)"
#define   DEFINE_07 "-DXCOTE=gDIVI(dimX,8)  -DYCOTE=gDIVI(dimY,8)"
#define   DEFINE_08 "-DXCOTE=gDIVI(dimX,9)  -DYCOTE=gDIVI(dimY,9)"
#define   DEFINE_09 "-DXCOTE=gDIVI(dimX,10) -DYCOTE=gDIVI(dimY,10)"
#define   DEFINE_10 "-DXCOTE=gDIVI(dimX,11) -DYCOTE=gDIVI(dimY,11)"
#define   DEFINE_11 "-DXCOTE=gDIVI(dimX,12) -DYCOTE=gDIVI(dimY,12)"
#define   DEFINE_12 "-DXCOTE=gDIVI(dimX,13) -DYCOTE=gDIVI(dimY,13)"
#define   DEFINE_13 "-DXCOTE=gDIVI(dimX,14) -DYCOTE=gDIVI(dimY,14)"
#define   DEFINE_14 "-DXCOTE=gDIVI(dimX,15) -DYCOTE=gDIVI(dimY,15)"
#define   DEFINE_15 "-DXCOTE=gDIVI(dimX,16) -DYCOTE=gDIVI(dimY,16)"
#define   DEFINE_16 "-DXCOTE=gDIVI(dimX,17) -DYCOTE=gDIVI(dimY,17)"
                                        /* Les seuils ont ete obtenus par (le 20130615083031) :                                      */
                                        /*                                                                                           */
                                        /*                  $xci/valeurs_inte$X                                                   \  */
                                        /*                                      p=1 d=16                                          \  */
                                        /*                                      lineaire=VRAI                                     \  */
                                        /*                                      vD=1 vA=2000                                 |    \  */
                                        /*                  $xrv/LOGX.01$X                                                        \  */
                                        /*                                      ne=0                                              \  */
                                        /*                                      fichier==                                    |    \  */
                                        /*                  $xrv/normalise.01$X                                                   \  */
                                        /*                                      ne=0                                              \  */
                                        /*                                      fichier==                                         \  */
                                        /*                                      origine=0.1 extremite=0.99                        \  */
                                        /*                                      decimales=4                                          */
                                        /*                                                                                           */

#include  "images_1octet.01.vv.I"

#ifndef   XCOTE
#         define    XCOTE                                                                                                               \
                              gDIVI(dimX,4)
#else
#endif

#ifndef   YCOTE
#         define    YCOTE                                                                                                               \
                              gDIVI(dimY,4)
#else
#endif

#ifndef   SEUIL
#         define    SEUIL                                                                                                               \
                              (0.5)
#else
#endif

double    seuil=SEUIL;

int       Xcote=XCOTE;
int       Ycote=YCOTE;

MAIN(
          {
          long      int       m=0x0000ffffffffffff;
          long      int       a=0x5DEECE66D;
          long      int       c=0xB;
          long      int       Xi=1;
                                        /* Les valeurs des parametres {m,a,c} sont ceux de la fonction 'drand48(...)'.               */

          for       (y=Ymin ; y <= Ymax ; y=ADD2(y,1))
                    {
                    for       (x=Xmin ; x <= Xmax ; x=ADD2(x,1))
                              {
                              if        (    ((x >= SOUS(Xcentre,Xcote)) && (x <= ADD2(Xcentre,Xcote)))
                                        &&   ((y >= SOUS(Ycentre,Ycote)) && (y <= ADD2(Ycentre,Ycote)))
                                         )
                                        {
                                        Xi = ETLO(ADD2(MUL2(a,Xi),c),m);

                                        STORE_IMAGE_PLAN(x,y,COND(IFLT(DIVIf(((double)Xi),((double)m)),seuil),NOIR,BLANC));
                                        }
                              else
                                        {
                                        STORE_IMAGE_PLAN(x,y,BLANC);
                                        }
                              }
                    }

          SORTIE_DU_FICHIER_IMAGE;
          EDITER_LES_COMPTEURS_DES_FONCTIONS;
          }
     )