/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        G E N E R A T I O N   D E   P A Q U E T S   D E   N O M B R E S   A L E A T O I R E S   E N T I E R S  :                   */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*        Utilisation :                                                                                                              */
/*                                                                                                                                   */
/*                  $aPout    [<NIterations> [<Graine> [<PasGraine> [<Tabule>]]]]                                                    */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*        Principe :                                                                                                                 */
/*                                                                                                                                   */
/*                    Ce programme genere iterativement des                                                                          */
/*                  paquets de N bits aleatoires de la facon                                                                         */
/*                  suivante :                                                                                                       */
/*                                                                                                                                   */
/*                                      ITERATION 1         1 paquet                                {N1(0),N1(1)}                    */
/*                                      ITERATION 2         1xN1(1) paquets identiques              {N2(0),N2(1)}                    */
/*                                      ITERATION 3         1xN1(1)xN2(1) paquets identiques        {N3(0),N3(1)}                    */
/*                                      ITERATION 4         1xN1(1)xN2(1)xN3(1) paquets identiques  {N4(0),N4(1)}                    */
/*                                      (...)                                                                                        */
/*                                                                                                                                   */
/*                  avec :                                                                                                           */
/*                                                                                                                                   */
/*                                      Ni(0)+Ni(1) = N \-/ i                                                                        */
/*                                                                                                                                   */
/*                  'Ni(0)' et 'Ni(1)' designant respectivement les                                                                  */
/*                  nombres de '0's et de '1's a l'iteration 'i'...                                                                  */
/*                                                                                                                                   */
/*                    On notera que la graine du generateur aleatoire                                                                */
/*                  peut changer a chaque iteration et ce en faisant                                                                 */
/*                  que 'PasGraine' soit different de 0. Par contre                                                                  */
/*                  si ce pas est nul, alors TOUS les paquets sont                                                                   */
/*                  identiques (quelle que soit l'iteration...).                                                                     */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*        Author of '$xtc/random_paquets.01$vv$c' :                                                                                  */
/*                                                                                                                                   */
/*                    Jean-Francois COLONNA (LACTAMME, 20240914094257).                                                              */
/*                                                                                                                                   */
/*************************************************************************************************************************************/

#include  "INCLUDES.01.I"

extern    int       atoi();

extern    double    drand48();
extern    double    floor();

#define   ITERATION 6
#define   N         (3*3*3)
                                        /* En prevision d'une utilisation pour l'eponge de Menger...                                 */
#define   MinN      (1+10)
#define   MaxN      (N-10)
#define   GRAINE    1789
#define   PASGRAINE 1

#define   TABULE    FAUX

void      main(int argc,char *argv[])
          {
          int       iteration,NIterations=ITERATION;
          long int  Graine=GRAINE,PasGraine=PASGRAINE;
          int       Tabule=TABULE;

          int       npaquets=1;

          if        (argc >= 2)
                    {
                    NIterations=atoi(argv[1]);

                    if        (argc >= 3)
                              {
                              Graine=atoi(argv[2]);

                              if        (argc >= 4)
                                        {
                                        PasGraine=atoi(argv[3]);

                                        if        (argc >= 5)
                                                  {
                                                  Tabule=atoi(argv[4]);

                                                  if        (argc >= 6)
                                                            {
                                                            printf("Les arguments en sur-nombre sont ignores.\n");
                                                            }
                                                  else
                                                            {
                                                            }
                                                  }
                                        else
                                                  {
                                                  }
                                        }
                              else
                                        {
                                        }
                              }
                    else
                              {
                              }
                    }
          else
                    {
                    }

          for       (iteration=1 ; iteration<=NIterations ; iteration++)
                    {
                    double    rdn=drand48();
                    int       n0,n1;
                    int       generer=VRAI;

                    srand48(Graine);

                    rdn = (MaxN-MinN+1)*rdn;
                    rdn = rdn+MinN;
                    rdn = floor(rdn);
                    rdn = MIN2(rdn,MaxN);

                    n0 = (int)rdn;
                    n1 = N-n0;
                                        /* Nombre 'n0' de bits '0' et nombre 'n1' de bits '1' a generer.                             */

                              {
                              int       nc0=0,nc1=0;
                              int       index=0;
                              int       Lbits[N];
                              int       index1,index2;

                              while     (generer == VRAI)
                                        {
                                        double    rdn_bit=drand48();
                                        int       bit;

                                        if        (rdn_bit < 0.5)
                                                  {
                                                  bit = 0;
                                                  nc0++;
                                                  }
                                        else
                                                  {
                                                  bit = 1;
                                                  nc1++;
                                                  }

                                        Lbits[index] = bit;
                                        index++;
                                        /* Memorisation de 'n0' bits '0' et de 'n1' bits '1' repartis aleatoirement...               */

                                        if        ((nc0+nc1) == N)
                                                  {
                                                  generer = FAUX;
                                                  }
                                        else
                                                  {
                                                  }
                                        }

                              for       (index1=1 ; index1 <= npaquets ; index1++)
                                        /* Edition de 'npaquets' identiques :                                                        */
                                        {
                                        /* Pour faire des tests, on peut forcer ici :                                                */
                                        /*                                                                                           */
                                        /*        int       Lbits[]={1,1,1,1,0,1,1,1,1,1,0,1,0,0,0,1,0,1,1,1,1,1,0,1,1,1,1};         */
                                        /*                                                                                           */
                                        /* soit :                                                                                    */
                                        /*                                                                                           */
                                        /*                                      1 1 1                                                */
                                        /*                                      1 0 1                                                */
                                        /*                                      1 1 1                                                */
                                        /*                                                                                           */
                                        /*                                      1 0 1                                                */
                                        /*                                      0 0 0                                                */
                                        /*                                      1 0 1                                                */
                                        /*                                                                                           */
                                        /*                                      1 1 1                                                */
                                        /*                                      1 0 1                                                */
                                        /*                                      1 1 1                                                */
                                        /*                                                                                           */
                                        /* qui decrit l'eponge de Menger "standard"...                                               */

                                        for       (index2=0 ; index2 < N ; index2++)
                                        /* Edition d'un paquet de 'N=nc0+nc1' bits '0' et '1' repartis aleatoirement :               */
                                                  {
                                                  printf("%d",Lbits[index2]);

                                                  if        (Tabule == FAUX)
                                                            {
                                                            printf("\n");
                                                            }
                                                  else
                                                            {
                                                            }
                                                  }

                                        if        (Tabule == VRAI)
                                                  {
                                                  printf(" ");
                                                  }
                                        else
                                                  {
                                                  }
                                        }

                              if        (Tabule == VRAI)
                                        {
                                        printf("\n");
                                        }
                              else
                                        {
                                        }

                              npaquets = nc1*npaquets;
                                        /* Le nombre de paquets a generer au prochain tour est 'nc1' fois plus grand que celui       */
                                        /* que l'on vient de generer...                                                              */
                              }
                    Graine = Graine+PasGraine;
                    }
          }