/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        L A N C E R   D E   D E U X   D E S  :                                                                                     */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*        Author of '$xtc/DeuxDes.01$c' :                                                                                            */
/*                                                                                                                                   */
/*                    Jean-Francois COLONNA (LACTAMME, 20231024122249).                                                              */
/*                                                                                                                                   */
/*************************************************************************************************************************************/

#include  "INCLUDES.01.I"

extern    double    drand48();
extern    double    sqrt();

#define   MINIMUM                                                                                                                       \
                    (1)
#define   MAXIMUM                                                                                                                       \
                    (6)
                                        /* Definition d'un de a six faces.                                                           */

#define   F(n)                                                                                                                          \
                    ((2*((n)-1))+1)
#define   G(n)                                                                                                                          \
                    ((n)/2)
#define   N                                                                                                                             \
                    ((MAXIMUM)+1)

#define   RANDOM(minimum,maximum)                                                                                                       \
                    MIN2(MAX2((int)(minimum + (maximum*drand48())),MINIMUM),MAXIMUM)                                                    \
                                        /* Generation d'une valeur aleatoire dans [minimum,maximum].                                 */

#define   N_TIRAGES                                                                                                                     \
                    200000

#define   FACTEUR                                                                                                                       \
                    (0.0002*(2000000/(N_TIRAGES)))

main()
          {
          int       n;

          int       aleatoires[N_TIRAGES];

          int       occurence_1[N];
          int       occurence_2[F(N)];

          int       check=0;

          double    ValeurMoyenne_1=0;
          double    Variance______1=0;

          double    ValeurMoyenne_2=0;
          double    Variance______2=0;

          for       (n=0 ; n < N ; n++)
                    {
                    occurence_1[n] = 0;
                                        /* Initialisation des compteurs d'occurences...                                              */
                    }

          for       (n=0 ; n < F(N) ; n++)
                    {
                    occurence_2[n] = 0;
                                        /* Initialisation des compteurs d'occurences...                                              */
                    }

          for       (n=0 ; n < N_TIRAGES ; n++)
                    {
                    aleatoires[n]=RANDOM(MINIMUM,MAXIMUM);
                                        /* Generation des valeurs aleatoires...                                                      */

                    if        ((aleatoires[n] < MINIMUM) || (aleatoires[n] > MAXIMUM))
                              {
                              printf("Un nombre aleatoire n'est pas dans [%d,%d].\n",MINIMUM,MAXIMUM);
                              }
                    else
                              {
                              }
                    }

          for       (n=0 ; n < N_TIRAGES ; n++)
                    {
                    ValeurMoyenne_1 = ValeurMoyenne_1+(double)aleatoires[n];
                                        /* Calcul de la valeur moyenne des valeurs aleatoires...                                     */
                    }

          ValeurMoyenne_1 = ValeurMoyenne_1/(double)N_TIRAGES;

          for       (n=0 ; n < N_TIRAGES ; n++)
                    {
                    Variance______1 = Variance______1+pow(((double)aleatoires[n])-ValeurMoyenne_1,2);
                                        /* Calcul de la variance des valeurs aleatoires...                                           */
                    }

          Variance______1 = Variance______1/(double)N_TIRAGES;

          n=0;

          while     (n < N_TIRAGES)
                    {
                    int       random_1=aleatoires[n++];
                    int       random_2=aleatoires[n++];
                    int       random_12=random_1+random_2;

                    ValeurMoyenne_2 = ValeurMoyenne_2+(double)(random_12);
                                        /* Calcul de la valeur moyenne des couples de valeurs aleatoires...                          */
                    }

          ValeurMoyenne_2 = ValeurMoyenne_2/(double)G(N_TIRAGES);

          n=0;

          while     (n < N_TIRAGES)
                    {
                    int       random_1=aleatoires[n++];
                    int       random_2=aleatoires[n++];
                    int       random_12=random_1+random_2;

                    Variance______2 = Variance______2+pow((double)(random_12)-ValeurMoyenne_2,2);
                                        /* Calcul de la variance des couples de valeurs aleatoires...                                */
                    }

          Variance______2 = Variance______2/(double)G(N_TIRAGES);

          n=0;

          while     (n < N_TIRAGES)
                                        /* Validations diverses :                                                                    */
                    {
                    int       random_1=aleatoires[n++];
                    int       random_2=aleatoires[n++];
                    int       random_12=random_1+random_2;

                    occurence_1[random_1]++;
                    occurence_1[random_2]++;

                    occurence_2[random_12]++;

                    check = check++;
                    check = check++;

                    if        ((random_12 < (MINIMUM+MINIMUM)) || (random_12 > (MAXIMUM+MAXIMUM)))
                              {
                              printf("Un couple aleatoire n'est pas dans [%d,%d].\n",MINIMUM+MINIMUM,MAXIMUM+MAXIMUM);
                              }
                    else
                              {
                              }
                    }

          if        (check != N_TIRAGES)
                    {
                    printf("Erreur de comptage des occurences (%d # %d).\n",check,N_TIRAGES);
                    }
          else
                    {
                    }

          for       (n=0 ; n < N ; n++)
                    {
                    int       ValeurCourante=occurence_1[n];

                    if        (ValeurCourante > 0)
                              {
                              printf("Tirage 1 : %d --> %d=%f\n",n,ValeurCourante,(double)ValeurCourante/(double)N_TIRAGES);
                                        /* Edition des occurences des valeurs aleatoires...                                          */
                              }
                    else
                              {
                              }
                    }

          printf("\n");

          for       (n=0 ; n < F(N) ; n++)
                    {
                    int       ValeurCourante=occurence_2[n];

                    if        (ValeurCourante > 0)
                              {
                              printf("Tirage 2 : %d --> %d=%f\n",n,ValeurCourante,(double)ValeurCourante/(double)G(N_TIRAGES));
                                        /* Edition des occurences des couples de valeurs aleatoires...                               */
                              }
                    else
                              {
                              }
                    }

          printf("\n");

          for       (n=0 ; n < F(N) ; n++)
                    {
                    double    ValeurCourante=(double)occurence_2[n];

                    if        (ValeurCourante > 0)
                              {
                              int       k;

                              printf("Tirage 2 : ");

                              for       (k=1 ; k <= (int)(FACTEUR*ValeurCourante) ; k++)
                                        {
                                        printf("*");
                                        /* Edition de la distribution des couples de valeurs aleatoires...                           */
                                        }

                              printf("\n");
                              }
                    else
                              {
                              }
                    }

          printf("\n");

          printf("ValeurMoyenne 1=%f\n",ValeurMoyenne_1);
          printf("Variance 1.....=%f\n",Variance______1);
          printf("Sigma 1........=%f\n",sqrt(Variance______1));

          printf("\n");

          printf("ValeurMoyenne 2=%f\n",ValeurMoyenne_2);
          printf("Variance 2.....=%f\n",Variance______2);
          printf("Sigma 2........=%f\n",sqrt(Variance______2));

          printf("\n");
          }