/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        E T U D E   E X H A U S T I V E   D U   P A R A D O X E   D E   S I M P S O N  :                                           */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*        Author of '$xtc/ParadoxeSimpson.21$vv$c' :                                                                                 */
/*                                                                                                                                   */
/*                    Jean-Francois Colonna (LACTAMME, 20130405145848).                                                              */
/*                                                                                                                                   */
/*************************************************************************************************************************************/

#include  "INCLUDES.01.I"

#define   dimX                                                                                                                          \
                    EXP4(BorneSuperieure-BorneInferieure+1)
#define   dimY                                                                                                                          \
                    dimX
#define   IMAGE(x,y)                                                                                                                    \
                    (*(image + (((y)*dimX) + (x))))
int       GenererUneImage=FAUX;
                                        /* Cet indicateur lorsqu'il est VRAI permet de generer une image (introduit le               */
                                        /* 20130415093456).                                                                          */

int       EditerLesTableauxParadoxaux=FAUX;
                                        /* Cet indicateur lorsqu'il est VRAI permet d'editer les tableaux interessants               */
                                        /* (introduit le 20130416183750).                                                            */

#define   BORNE_INFERIEURE                                                                                                              \
                    1
long      int       BorneInferieure=BORNE_INFERIEURE;
#define   BORNE_SUPERIEURE                                                                                                              \
                    5
long      int       BorneSuperieure=BORNE_SUPERIEURE;
#define   BORNE_PAS                                                                                                                     \
                    1
long      int       BornePas=BORNE_PAS;


                                        /* Notations :                                                                               */
                                        /*                                                                                           */
                                        /*                  H         Homme                                                          */
                                        /*                  F         Femme                                                          */
                                        /*                  m         Medicament                                                     */
                                        /*                  p         Placebo                                                        */
                                        /*                  NG        Non Gueri                                                      */
                                        /*                  G         Gueri                                                          */
                                        /*                                                                                           */

#define   v____Gm             ((vH___Gm)+(vF___Gm))
#define   v____Gp             ((vH___Gp)+(vF___Gp))
#define   v___NGm             ((vH__NGm)+(vF__NGm))
#define   v___NGp             ((vH__NGp)+(vF__NGp))
                                        /* Definition du tableau {1}.                                                                */
#define   vH___Gm             H___Gm
#define   vH___Gp             H___Gp
#define   vH__NGm             H__NGm
#define   vH__NGp             H__NGp
                                        /* Definition du tableau {2}.                                                                */
#define   vF___Gm             F___Gm
#define   vF___Gp             F___Gp
#define   vF__NGm             F__NGm
#define   vF__NGp             F__NGp
                                        /* Definition du tableau {3}.                                                                */

#define   v____GNGm          ((v____Gm)+(v___NGm))
#define   v____GNGp          ((v____Gp)+(v___NGp))

#define   vH___GNGm          ((vH___Gm)+(vH__NGm))
#define   vH___GNGp          ((vH___Gp)+(vH__NGp))

#define   vF___GNGm          ((vF___Gm)+(vF__NGm))
#define   vF___GNGp          ((vF___Gp)+(vF__NGp))


#define   wH___Gm            ((vH___Gm)/(vH___GNGm))
#define   wH___Gp            ((vH___Gp)/(vH___GNGp))
#define   wF___Gm            ((vF___Gm)/(vF___GNGm))
#define   wF___Gp            ((vF___Gp)/(vF___GNGp))
#define   w____Gm            ((v____Gm)/(v____GNGm))
#define   w____Gp            ((v____Gp)/(v____GNGp))

void      main()
          {
          unsigned  char      *image;
                                        /* Definition de l'image a generer...                                                        */

          double    H___Gm=36;
          double    H__NGm=24;
          double    H___Gp=14;
          double    H__NGp=6;
          double    F___Gm=4;
          double    F__NGm=16;
          double    F___Gp=18;
          double    F__NGp=42;

          long      int       ComptageDeTousLesCas=0;
          long      int       ComptageDesCasParadoxauxMPP=0;
          long      int       ComptageDesCas_PP=0;
          long      int       ComptageDesCasParadoxauxPMM=0;
          long      int       ComptageDesCas_MM=0;

          gGetl(BorneInferieure,"BorneInferieure",BORNE_INFERIEURE);
          gGetl(BorneSuperieure,"BorneSuperieure",BORNE_SUPERIEURE);
          gGetl(BornePas,"BornePas",BORNE_PAS);
                                        /* Parametrage eventuel du nombre d'iterations afin de faciliter le lancement parallele...   */

#define   SI(pM,pP) COND((pM)>(pP),'>',COND((pM)<(pP),'<','='))
                                        /* Procedure d'edition "Superieur-Inferieur"...                                              */

          if        (GenererUneImage == FAUX)
                    {
                    printf("Cas par defaut :\n");
                    printf("               m...=%f %c p...=%f\n",w____Gm,SI(w____Gm,w____Gp),w____Gp);
                    printf("Homme :        m...=%f %c p...=%f\n",wH___Gm,SI(wH___Gm,wH___Gp),wH___Gp);
                    printf("Femme :        m...=%f %c p...=%f\n",wF___Gm,SI(wF___Gm,wF___Gp),wF___Gp);
                    printf("\n");
                                        /* Doit donner a priori les valeurs suivantes :                                              */
                                        /*                                                                                           */
                                        /*                                 m...=0.500000 > p...=0.400000                             */
                                        /*                  Homme :        m...=0.600000 < p...=0.700000                             */
                                        /*                  Femme :        m...=0.200000 < p...=0.300000                             */
                                        /*                                                                                           */
                    }
          else
                    {
                    image=malloc(dimY*dimX);
                                        /* Definition de l'image a generer...                                                        */
                    }

          for       (H___Gm=BorneInferieure ; H___Gm <= BorneSuperieure ; H___Gm=H___Gm+BornePas)
                    {
                    for       (H___Gp=BorneInferieure ; H___Gp <= BorneSuperieure ; H___Gp=H___Gp+BornePas)
                              {
                              for       (H__NGm=BorneInferieure ; H__NGm <= BorneSuperieure ; H__NGm=H__NGm+BornePas)
                                        {
                                        for       (H__NGp=BorneInferieure ; H__NGp <= BorneSuperieure ; H__NGp=H__NGp+BornePas)
                                                  {
                                                  for       (F___Gm=BorneInferieure ; F___Gm <= BorneSuperieure ; F___Gm=F___Gm+BornePas)
                                                            {
                                                            for       (F___Gp=BorneInferieure ; F___Gp <= BorneSuperieure ; F___Gp=F___Gp+BornePas)
                                                                      {
                                                                      for       (F__NGm=BorneInferieure ; F__NGm <= BorneSuperieure ; F__NGm=F__NGm+BornePas)
                                                                                {
                                                                                for       (F__NGp=BorneInferieure ; F__NGp <= BorneSuperieure ; F__NGp=F__NGp+BornePas)
                                                                                          {
                                                                                          int       EditerLeTableauCourant=FAUX;
                                        /* A priori, les tableaux ne seront pas edites...                                            */
                                                                                          int       x;
                                                                                          int       y;

#define   NI(pM,pP) COND((pM)>(pP),2,COND((pM)<(pP),0,1))

                                                                                          unsigned  char      niveau;

                                                                                          if        (         (EditerLesTableauxParadoxaux == VRAI)
                                                                                                    ||        (GenererUneImage == VRAI)
                                                                                                     )
                                                                                                    {

#define   BASE      BorneSuperieure-BorneInferieure+1
#define   xyHORNER(a,b,c,d)                                                                                                             \
                    HORNER_1_03(BASE                                                                                                    \
                               ,a-BorneInferieure                                                                                       \
                               ,b-BorneInferieure                                                                                       \
                               ,c-BorneInferieure                                                                                       \
                               ,d-BorneInferieure                                                                                       \
                                )                                                                                                       \
                                        /* Procedure de multiplexage de 4 nombres...                                                 */
                                                                                                    x=xyHORNER(H___Gm,H___Gp,H__NGm,H__NGp);
                                                                                                    y=xyHORNER(F___Gm,F___Gp,F__NGm,F__NGp);

#define   NI(pM,pP) COND((pM)>(pP),2,COND((pM)<(pP),0,1))

                                                                                                    niveau=HORNER_1_02(10,NI(w____Gm,w____Gp),NI(wH___Gm,wH___Gp),NI(wF___Gm,wF___Gp));
                                        /* Quelques valeurs interessantes :                                                          */
                                        /*                                                                                           */
                                        /*        022       ((w____Gm < w____Gp) && ((wH___Gm > wH___Gp) && (wF___Gm > wF___Gp)))    */
                                        /*                                                                                           */
                                        /*        122       ((w____Gm = w____Gp) && ((wH___Gm > wH___Gp) && (wF___Gm > wF___Gp)))    */
                                        /*        222       ((w____Gm > w____Gp) && ((wH___Gm > wH___Gp) && (wF___Gm > wF___Gp)))    */
                                        /*                                                                                           */
                                        /* en notant que :                                                                           */
                                        /*                                                                                           */
                                        /*                  pM < pP   NI(pM,pP)=0                                                    */
                                        /*                  pM = pP   NI(pM,pP)=1                                                    */
                                        /*                  pM > pP   NI(pM,pP)=2                                                    */
                                        /*                                                                                           */
                                        /* Enfin, la base 10 est utilisee dans le schema de Horner ci-dessus, afin de "concatener"   */
                                        /* les trois valeurs de 'NI(...)'...                                                         */
                                        /*                                                                                           */
                                        /*                                                                                           */
                                        /* Voici les 3x3x3=27 cas possibles :                                                        */
                                        /*                                                                                           */
                                        /*        000       w____Gm < w____Gp   wH___Gm < wH___Gp   wF___Gm < wF___Gp   OK           */
                                        /*        001       w____Gm < w____Gp   wH___Gm < wH___Gp   wF___Gm = wF___Gp   ?            */
                                        /*        002       w____Gm < w____Gp   wH___Gm < wH___Gp   wF___Gm > wF___Gp   ?            */
                                        /*        010       w____Gm < w____Gp   wH___Gm = wH___Gp   wF___Gm < wF___Gp   ?            */
                                        /*        011       w____Gm < w____Gp   wH___Gm = wH___Gp   wF___Gm = wF___Gp   ?            */
                                        /*        012       w____Gm < w____Gp   wH___Gm = wH___Gp   wF___Gm > wF___Gp   ?            */
                                        /*        020       w____Gm < w____Gp   wH___Gm > wH___Gp   wF___Gm < wF___Gp   ?            */
                                        /*        021       w____Gm < w____Gp   wH___Gm > wH___Gp   wF___Gm = wF___Gp   ?            */
                                        /*        022       w____Gm < w____Gp   wH___Gm > wH___Gp   wF___Gm > wF___Gp   PARADOXE     */
                                        /*        100       w____Gm = w____Gp   wH___Gm < wH___Gp   wF___Gm < wF___Gp   ?            */
                                        /*        101       w____Gm = w____Gp   wH___Gm < wH___Gp   wF___Gm = wF___Gp   ?            */
                                        /*        102       w____Gm = w____Gp   wH___Gm < wH___Gp   wF___Gm > wF___Gp   ?            */
                                        /*        110       w____Gm = w____Gp   wH___Gm = wH___Gp   wF___Gm < wF___Gp   ?            */
                                        /*        111       w____Gm = w____Gp   wH___Gm = wH___Gp   wF___Gm = wF___Gp   OK           */
                                        /*        112       w____Gm = w____Gp   wH___Gm = wH___Gp   wF___Gm > wF___Gp   ?            */
                                        /*        120       w____Gm = w____Gp   wH___Gm > wH___Gp   wF___Gm < wF___Gp   ?            */
                                        /*        121       w____Gm = w____Gp   wH___Gm > wH___Gp   wF___Gm = wF___Gp   ?            */
                                        /*        122       w____Gm = w____Gp   wH___Gm > wH___Gp   wF___Gm > wF___Gp   ?            */
                                        /*        200       w____Gm > w____Gp   wH___Gm < wH___Gp   wF___Gm < wF___Gp   PARADOXE     */
                                        /*        201       w____Gm > w____Gp   wH___Gm < wH___Gp   wF___Gm = wF___Gp   ?            */
                                        /*        202       w____Gm > w____Gp   wH___Gm < wH___Gp   wF___Gm > wF___Gp   ?            */
                                        /*        210       w____Gm > w____Gp   wH___Gm = wH___Gp   wF___Gm < wF___Gp   ?            */
                                        /*        211       w____Gm > w____Gp   wH___Gm = wH___Gp   wF___Gm = wF___Gp   ?            */
                                        /*        212       w____Gm > w____Gp   wH___Gm = wH___Gp   wF___Gm > wF___Gp   ?            */
                                        /*        220       w____Gm > w____Gp   wH___Gm > wH___Gp   wF___Gm < wF___Gp   ?            */
                                        /*        221       w____Gm > w____Gp   wH___Gm > wH___Gp   wF___Gm = wF___Gp   ?            */
                                        /*        222       w____Gm > w____Gp   wH___Gm > wH___Gp   wF___Gm > wF___Gp   OK           */
                                        /*                                                                                           */
                                                                                                    }
                                                                                          else
                                                                                                    {
                                                                                                    }

                                                                                          ComptageDeTousLesCas++;

                                                                                          if        (         (wH___Gm < wH___Gp)
                                                                                                    &&        (wF___Gm < wF___Gp)
                                                                                                     )
                                                                                                    {
                                                                                                    ComptageDesCas_PP++;

                                                                                                    if        (w____Gm > w____Gp)
                                                                                                              {
                                                                                                              ComptageDesCasParadoxauxMPP++;
                                                                                                              EditerLeTableauCourant=VRAI;
                                                                                                              }
                                                                                                    else
                                                                                                              {
                                                                                                              }
                                                                                                    }
                                                                                          else
                                                                                                    {
                                                                                                    }

                                                                                          if        (         (wH___Gm > wH___Gp)
                                                                                                    &&        (wF___Gm > wF___Gp)
                                                                                                     )
                                                                                                    {
                                                                                                    ComptageDesCas_MM++;

                                                                                                    if        (w____Gm < w____Gp)
                                                                                                              {
                                                                                                              ComptageDesCasParadoxauxPMM++;
                                                                                                              EditerLeTableauCourant=VRAI;
                                                                                                              }
                                                                                                    else
                                                                                                              {
                                                                                                              }
                                                                                                    }
                                                                                          else
                                                                                                    {
                                                                                                    }

                                                                                          if        (GenererUneImage == VRAI)
                                                                                                    {
                                                                                                    IMAGE(x,y) = niveau;
                                                                                                    }
                                                                                          else
                                                                                                    {
                                                                                                    if        (EditerLesTableauxParadoxaux == VRAI)
                                                                                                              {
                                                                                                              if        (EditerLeTableauCourant == VRAI)
                                                                                                                        {

#define   CHIFFRES  2

                                                                                                                        printf("CAS %03d au point (%d,%d)",niveau,x,y);
                                                                                                                        printf(" [%d=(%d-%ld)x%ld^%d+(%d-%ld)x%ld^%d+(%d-%ld)x%ld^%d+(%d-%ld),%d=(%d-%ld)x%ld^%d+(%d-%ld)x%ld^%d+(%d-%ld)x%ld^%d+(%d-%ld)]\n"
                                                                                                                              ,x
                                                                                                                              ,(int)H___Gm,BorneInferieure,BASE,3
                                                                                                                              ,(int)H___Gp,BorneInferieure,BASE,2
                                                                                                                              ,(int)H__NGm,BorneInferieure,BASE,1
                                                                                                                              ,(int)H__NGp,BorneInferieure
                                                                                                                              ,y
                                                                                                                              ,(int)F___Gm,BorneInferieure,BASE,3
                                                                                                                              ,(int)F___Gp,BorneInferieure,BASE,2
                                                                                                                              ,(int)F__NGm,BorneInferieure,BASE,1
                                                                                                                              ,(int)F__NGp,BorneInferieure
                                                                                                                               );
                                                                                                                        printf("\n");

                                                                                                                        printf("TABLEAU 1 :\n");
                                                                                                                        printf("          m... : G=%0*d NG=%0*d\n",CHIFFRES,(int)v____Gm,CHIFFRES,(int)v___NGm);
                                                                                                                        printf("          p... : G=%0*d NG=%0*d\n",CHIFFRES,(int)v____Gp,CHIFFRES,(int)v___NGp);
                                                                                                                        printf("               m...=%f %c p...=%f\n",w____Gm,SI(w____Gm,w____Gp),w____Gp);

                                                                                                                        printf("\n");

                                                                                                                        printf("TABLEAU 2 :\n");
                                                                                                                        printf("          Hm.. : G=%0*d NG=%0*d\n",CHIFFRES,(int)vH___Gm,CHIFFRES,(int)vH__NGm);
                                                                                                                        printf("          Hp.. : G=%0*d NG=%0*d\n",CHIFFRES,(int)vH___Gp,CHIFFRES,(int)vH__NGp);
                                                                                                                        printf("               Hm..=%f %c Hp..=%f\n",wH___Gm,SI(wH___Gm,wH___Gp),wH___Gp);

                                                                                                                        printf("TABLEAU 3 :\n");
                                                                                                                        printf("          Fm.. : G=%0*d NG=%0*d\n",CHIFFRES,(int)vF___Gm,CHIFFRES,(int)vF__NGm);
                                                                                                                        printf("          Fp.. : G=%0*d NG=%0*d\n",CHIFFRES,(int)vF___Gp,CHIFFRES,(int)vF__NGp);
                                                                                                                        printf("               Fm..=%f %c Fp..=%f\n",wF___Gm,SI(wF___Gm,wF___Gp),wF___Gp);

                                                                                                                        printf("\n");

                                                                                                                        }
                                                                                                              else
                                                                                                                        {
                                                                                                                        }
                                                                                                              }
                                                                                                    else
                                                                                                              {
                                                                                                              }
                                                                                                    }
                                                                                          }
                                                                                }
                                                                      }
                                                            }
                                                  }
                                        }
                              }
                    }

          if        (GenererUneImage == FAUX)
                    {
                    printf("Recherche exhaustive dans [%ld,%ld] par pas de %ld.\n",BorneInferieure,BorneSuperieure,BornePas);
                    printf("\n");
                    printf("Pour %ld cas :\n",ComptageDeTousLesCas);
                    printf("\n");
                    printf("Il y a eu %ld cas paradoxaux de type '?pp', soit %f%% (?pp/TOTAL),\n",ComptageDesCas_PP,100*((double)ComptageDesCas_PP/(double)ComptageDeTousLesCas));
                    printf("Il y a eu %ld cas paradoxaux de type 'Mpp', soit %f%% (Mpp/TOTAL),\n",ComptageDesCasParadoxauxMPP,100*((double)ComptageDesCasParadoxauxMPP/(double)ComptageDeTousLesCas));
                    printf("Il y a eu %ld cas de type '?pp', soit %f%% (Mpp/?pp).\n",ComptageDesCas_PP,100*((double)ComptageDesCasParadoxauxMPP/(double)ComptageDesCas_PP));
                    printf("\n");
                    printf("Il y a eu %ld cas paradoxaux de type '?MM', soit %f%% (?MM/TOTAL),\n",ComptageDesCas_MM,100*((double)ComptageDesCas_MM/(double)ComptageDeTousLesCas));
                    printf("Il y a eu %ld cas paradoxaux de type 'pMM', soit %f%% (pMM/TOTAL),\n",ComptageDesCasParadoxauxPMM,100*((double)ComptageDesCasParadoxauxPMM/(double)ComptageDeTousLesCas));
                    printf("Il y a eu %ld cas de type '?MM', soit %f%% (pMM/?MM).\n",ComptageDesCas_PP,100*((double)ComptageDesCasParadoxauxPMM/(double)ComptageDesCas_MM));
                                        /* Doit donner a priori des valeurs du type :                                                */
                                        /*                                                                                           */
                                        /*   Recherche exhaustive dans [1,5] par pas de 1.                                           */
                                        /*        Pour 390625 cas :                                                                  */
                                        /*        Il y a eu 82944 cas paradoxaux de type '?pp', soit 21.233664% (?pp/TOTAL),         */
                                        /*        Il y a eu 232 cas paradoxaux de type 'Mpp', soit 0.059392% (Mpp/TOTAL)             */
                                        /*        Il y a eu 82944 cas de type '?pp', soit 0.279707% (Mpp/?pp).                       */
                                        /*                                                                                           */
                                        /*   Recherche exhaustive dans [1,10] par pas de 1.                                          */
                                        /*        Pour 100000000 cas :                                                               */
                                        /*        Il y a eu 23629321 cas paradoxaux de type '?pp', soit 23.629321% (?pp/TOTAL),      */
                                        /*        Il y a eu 222252 cas paradoxaux de type 'Mpp', soit 0.222252% (Mpp/TOTAL),         */
                                        /*        Il y a eu 23629321 cas de type '?pp', soit 0.940577% (Mpp/?pp).                    */
                                        /*                                                                                           */
                                        /*   Recherche exhaustive dans [1,25] par pas de 1.                                          */
                                        /*        Pour 152587890625 cas :                                                            */
                                        /*        Il y a eu 37707425856 cas paradoxaux de type '?pp', soit 24.711939% (?pp/TOTAL),   */
                                        /*        Il y a eu 581874524 cas paradoxaux de type 'Mpp', soit 0.381337% (Mpp/TOTAL),      */
                                        /*        Il y a eu 37707425856 cas de type '?pp', soit 1.543130% (Mpp/?pp).                 */
                                        /*                                                                                           */
                                        /*   Recherche exhaustive dans [1,30] par pas de 1.                                          */
                                        /*        Pour 656100000000 cas :                                                            */
                                        /*        Il y a eu 162606530025 cas paradoxaux de type '?pp', soit 24.783803% (?pp/TOTAL),  */
                                        /*        Il y a eu 2614488870 cas paradoxaux de type 'Mpp', soit 0.398489% (Mpp/TOTAL),     */
                                        /*        Il y a eu 162606530025 cas de type '?pp', soit 1.607862% (Mpp/?pp).                */
                                        /*                                                                                           */
                                        /*   Recherche exhaustive dans [1,100] par pas de 4.                                         */
                                        /*        Pour 152587890625 cas :                                                            */
                                        /*        Il y a eu 37886286736 cas paradoxaux de type '?pp', soit 24.829157% (?pp/TOTAL),   */
                                        /*        Il y a eu 743629992 cas paradoxaux de type 'Mpp', soit 0.487345% (Mpp/TOTAL),      */
                                        /*        Il y a eu 37886286736 cas de type '?pp', soit 1.962795% (Mpp/?pp).                 */
                                        /*                                                                                           */
                                        /*                                                                                           */
                                        /* puis a compter du 20130416183750 :                                                        */
                                        /*                                                                                           */
                                        /*   Recherche exhaustive dans [1,4] par pas de 1.                                           */
                                        /*        Pour 65536 cas :                                                                   */
                                        /*        Il y a eu 12544 cas paradoxaux de type '?pp', soit 19.140625% (?pp/TOTAL),         */
                                        /*        Il y a eu 4 cas paradoxaux de type 'Mpp', soit 0.006104% (Mpp/TOTAL),              */
                                        /*        Il y a eu 12544 cas de type '?pp', soit 0.031888% (Mpp/?pp).                       */
                                        /*        Il y a eu 12544 cas paradoxaux de type '?MM', soit 19.140625% (?MM/TOTAL),         */
                                        /*        Il y a eu 4 cas paradoxaux de type 'pMM', soit 0.006104% (pMM/TOTAL),              */
                                        /*        Il y a eu 12544 cas de type '?MM', soit 0.031888% (pMM/?MM).                       */
                                        /*                                                                                           */
                    }
          else
                    {
                    write(1,image,dimX*dimY);
                                        /* Sortie de l'image...                                                                      */
                    }
          }



Copyright © Jean-François Colonna, 2021-2023.
Copyright © CMAP (Centre de Mathématiques APpliquées) UMR CNRS 7641 / École polytechnique, Institut Polytechnique de Paris, 2021-2023.