/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        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   " V R A I S "   P O I N T S   A L E A T O I R E S  :                                                                 */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*        Author of '$xrC/ObjetComplexe.M1$vv$c' :                                                                                   */
/*                                                                                                                                   */
/*                    Jean-Francois Colonna (LACTAMME, 20130624143912).                                                              */
/*                                                                                                                                   */
/*************************************************************************************************************************************/

#ifdef    COMMENTS
#         undef     COMMENTS
#else
#endif

#define   COMMENTS  "'Vrai' champ aleatoire type BBS (format octet) -noir ou blanc-"

#include  "images_1octet.01.vv.I"

char      ChaineBitsAleatoires[]={
#include  "ChaineBitsAleatoires_1024x1024.08.vv.I"
                                 };
                                        /* Le programme 'v $xrC/ObjetComplexe.G2$vv$c' est adapte a la mesure de la Complexite       */
                                        /* Algorithmique de Kolmogorov puisque chaque bit de la chaine de bits aleatoires n'occupe   */
                                        /* qu'un seul bit de memoire. Sa longueur mesurees en bits a partir du binaire non           */
                                        /* executable ('v $xrC/Mesures.01$vv$Z .CoMpIlE..-c') est alors egale (en bits) au nombre    */
                                        /* de bits de la chaine aleatoire plus une petite constante (voir a ce propos                */
                                        /* 'v $xrC/ObjetComplexe.F2$vv$c 20130519121302' pour avoir des informations concernant      */
                                        /* la longueur du binaire non executable).                                                   */
                                        /*                                                                                           */
                                        /* Les programmes 'v $xrC/ObjetComplexe.L1$vv$c' et 'v $xrC/ObjetComplexe.L2$vv$c' sont      */
                                        /* eux adaptes a la mesure de la Complexite Structuelle de Bennet puisque l'on mesure        */
                                        /* alors le nombre d'instructions necessaires au transfert de la chaine de bits aleatoires   */
                                        /* dans une matrice de bits (la conversion bit --> octet etant penalisante...).              */
                                        /*                                                                                           */
                                        /* Les programmes 'v $xrC/ObjetComplexe.M1$vv$c' et 'v $xrC/ObjetComplexe.M2$vv$c' sont      */
                                        /* eux aussi adaptes a la mesure de la Complexite Structuelle de Bennet puisque l'on mesure  */
                                        /* alors le nombre d'instructions necessaires au transfert de la chaine de bits aleatoires   */
                                        /* (representees par une chaine d'octets : un bit est contenu dans un octet) dans une        */
                                        /* matrice d'octets (ce qui est donc plus rapide que ci-dessus...).                          */

MAIN(
          {
          int       IndexBit=0;

          INITIALISATION_IMAGE(COND(ChaineBitsAleatoires[IndexBit++]==0
                                   ,NOIR
                                   ,BLANC
                                    )
                               );
                                        /* On notera que 'IndexBit' est incremente APRES usage...                                    */

          SORTIE_DU_FICHIER_IMAGE;
          EDITER_LES_COMPTEURS_DES_FONCTIONS;
          }
     )