/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        E T U D E   D U   M E G A - P A R A D O X E   D E   P A R R O N D O  :                                                     */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*        Author of '$xtc/ParadoxeParrondo.12$c' :                                                                                   */
/*                                                                                                                                   */
/*                    Jean-Francois Colonna (LACTAMME, 20120704102026).                                                              */
/*                                                                                                                                   */
/*************************************************************************************************************************************/

#include  "INCLUDES.01.I"

extern    void      *malloc();

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))))
#define   TAILLE_IMAGE                                                                                                                  \
                    (dimY*dimX*sizeof(double))
                                        /* Acces a un point de l'image.                                                              */

extern    double    drand48();

#define   NPARTIES  10000                                                                                                               \
                                        /* Nombre de pas...                                                                          */

#define   NJEU_A    ((x-Xmin)+1)
#define   NJEU_B    ((y-Ymin)+1)
                                        /* Nombre de chacun des jeux.                                                                */

#define   SEUIL_A   (1.0/2.0)
#define   SEUIL_B   (1.0/2.0)
                                        /* Seuils utiles...                                                                          */
#define   CONSERVE  Jeton
#define   RETOURNE  COND(IFEQ(Jeton,NOIR),BLANC,NOIR)
                                        /* Etats possibles du jeton...                                                               */

int       CapitalCourant;
                                        /* Gain courant.                                                                             */
int       Jeton=NOIR;
                                        /* Gain courant.                                                                             */

double    CheckGenerateur=0;
double    NombreDeTirages=0;
double    random()
          {
          double    ValeurAleatoire=drand48();
          CheckGenerateur=CheckGenerateur+ValeurAleatoire;
          NombreDeTirages=NombreDeTirages+1;

          return(ValeurAleatoire);
          }

void      jeu(couleur,seuil)
int       couleur;
double    seuil;
          {
          double    ValeurAleatoire=random();

          if        (Jeton == couleur)
                    {
                    if        (ValeurAleatoire < seuil)
                              {
                              CapitalCourant = CapitalCourant+3;
                              Jeton = CONSERVE;
                              }
                    else
                              {
                              CapitalCourant = CapitalCourant-1;
                              Jeton = RETOURNE;
                              }
                    }
          else
                    {
                    if        (ValeurAleatoire < seuil)
                              {
                              CapitalCourant = CapitalCourant+1;
                              Jeton = CONSERVE;
                              }
                    else
                              {
                              CapitalCourant = CapitalCourant-2;
                              Jeton = CONSERVE;
                              }
                    }
          }

void      jeuA()
          {
          jeu(BLANC,SEUIL_A);
          }

void      jeuB()
          {
          jeu(NOIR,SEUIL_B);
          }

double    jeuAB(Arg_nJeu_A,Arg_nJeu_B)
int       Arg_nJeu_A;
int       Arg_nJeu_B;
          {
          int       nParties;

          CapitalCourant=0;
                                        /* Gain courant.                                                                             */

          for       (nParties=1 ; nParties<=NPARTIES ; nParties++)
                    {
                    int       nJeu_A,nJeu_B;

                    for       (nJeu_A=1 ; nJeu_A<=Arg_nJeu_A ; nJeu_A++)
                              {
                              jeuA();
                              }

                    for       (nJeu_B=1 ; nJeu_B<=Arg_nJeu_B ; nJeu_B++)
                              {
                              jeuB();
                              }
                    }

          return(((double)CapitalCourant/((double)(NPARTIES*((Arg_nJeu_A+Arg_nJeu_B))))));
          }

main()
          {
          int       x,y;
                                        /* Definition des coordonnees.                                                               */
          double    *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(TAILLE_IMAGE);
                                        /* Definition de l'image a generer...                                                        */

          for       (y=Ymin ; y<=Ymax ; y++)
                    {
                    for       (x=Xmin ; x<=Xmax ; x++)
                              {
                              IMAGE(x,y)=jeuAB(NJEU_A,NJEU_B);
                              }
                    }

          write(1,image,TAILLE_IMAGE);
                                        /* Sortie de l'image...                                                                      */
                                        /*                                                                                           */
                                        /* Le 20120704161417 je note que l'exploitation peut se faire de la facon suivante :         */
                                        /* utiles) :                                                                                 */
                                        /*                                                                                           */
                                        /*                                                                                           */
                                        /*   :Debut_listG_MegaParadoxe_Parrondo_12:                                                  */
                                        /*                                                                                           */
                                        /*   $Z             setenv    xTV                 $xTG                                       */
                                        /*                                                                                           */
                                        /*   $Z             xtc                                                                      */
                                        /*   $Z             $Cc       $Bsysteme  ParadoxeParrondo.12$c                               */
                                        /*                                                                                           */
                                        /*   $Z             gFITn     FIT1 15 15                                                     */
                                        /*   $Z             FIT1                                                                     */
                                        /*                                                                                           */
                                        /*   $Z             $DELETE   $xTV/MEGA_PARADOXE                                             */
                                        /*                                                                                           */
                                        /*   $Z             $aPout                                                                \  */
                                        /*   $Z                                                     > $xTV/MEGA_PARADOXE             */
                                        /*                                                                                           */
                                        /*   $Z             ext       Std                                                            */
                                        /*   $Z             setenv    P__mrseIlF 0                                                   */
                                        /*                                                                                           */
                                        /*   $Z             $xci/acces$X                                                          \  */
                                        /*   $Z                                 A=$xTV/MEGA_PARADOXE                              \  */
                                        /*   $Z                                 standard=FAUX zero=VRAI                           \  */
                                        /*   $Z                                                               $formatI       |    \  */
                                        /*   $Z             $xci/vraies_C$X                                                       \  */
                                        /*   $Z                                 p=$xiP/rouge_vert.12                              \  */
                                        /*   $Z                                 R=$xTV/MEGA_PARADOXE                              \  */
                                        /*   $Z                                                               $formatI               */
                                        /*                                                                                           */
                                        /*   :Fin_listG_MegaParadoxe_Parrondo_12:                                                    */
                                        /*                                                                                           */
                                        /*                                                                                           */
                                        /* puis :                                                                                    */
                                        /*                                                                                           */
                                        /*                  listG     $xtc/ParadoxeParrondo.12$c                                  \  */
                                        /*                            Debut_listG_""MegaParadoxe_Parrondo_12                      \  */
                                        /*                            Fin_listG_""MegaParadoxe_Parrondo_12                           */
                                        /*                                                                                           */
          }



Copyright © Jean-François Colonna, 2021-2021.
Copyright © CMAP (Centre de Mathématiques APpliquées) UMR CNRS 7641 / Ecole Polytechnique, 2021-2021.