/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        E N U M E R A T I O N   D E S   R A T I O N N E L S  :                                                                     */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*        Author of '$xtc/EnumerationDesRationnels.01$vv$c' :                                                                        */
/*                                                                                                                                   */
/*                    Jean-Francois Colonna (LACTAMME, 20220730095624).                                                              */
/*                                                                                                                                   */
/*************************************************************************************************************************************/

#include  "INCLUDES.01.I"

#define   TRIER                                                                                                                         \
                    VRAI

typedef   struct
          {
          unsigned  int       Numerateur;
          unsigned  int       Denominateur;
          }
          Fraction;
                                        /* Definition d'une fraction (nombre rationnel).                                             */

#define   Numer(fraction)                                                                                                               \
                    (fraction.Numerateur)
#define   Denom(fraction)                                                                                                               \
                    (fraction.Denominateur)
#define   EGAL(fraction,numerateur,denominateur)                                                                                        \
                    {                                                                                                                   \
                    Numer(fraction) = numerateur;                                                                                       \
                    Denom(fraction) = denominateur;                                                                                     \
                    }

#define   MOYENNE_DE_BROCOT(Rationnel_R,Rationnel_A1,Rationnel_A2)                                                                      \
                    {                                                                                                                   \
                    EGAL(Rationnel_R,Numer(Rationnel_A1)+Numer(Rationnel_A2),Denom(Rationnel_A1)+Denom(Rationnel_A2));                  \
                                        /* Voir 'v $ximD/definit.1$DEF MOYENNE_MEDIANE_DE_DEUX_FRACTIONS' a ce propos...             */ \
                    }

#define   PROFONDEUR                                                                                                                    \
                    3
int       compteur=0;

#define   LONGUEUR                                                                                                                      \
                    ((1<<PROFONDEUR)-1)
#define   INDEX0                                                                                                                        \
                    0
#define   INDEXn                                                                                                                        \
                    (LONGUEUR-1)
double    tableau[LONGUEUR];
int       numerateurs__[LONGUEUR];
int       denominateurs[LONGUEUR];
int       permutation[LONGUEUR];
int       IndexRationnels=0;

void      EnumerationDesRationnels(Rationnel_A1,Rationnel_A2)
Fraction  Rationnel_A1;
Fraction  Rationnel_A2;
          {
          Fraction  Rationnel_A1A2;

          compteur++;

          MOYENNE_DE_BROCOT(Rationnel_A1A2,Rationnel_A1,Rationnel_A2);

          tableau[IndexRationnels] = ((double)Numer(Rationnel_A1A2))/((double)Denom(Rationnel_A1A2));
          numerateurs__[IndexRationnels] = Numer(Rationnel_A1A2);
          denominateurs[IndexRationnels] = Denom(Rationnel_A1A2);
          IndexRationnels++;

          if        (TRIER == FAUX)
                    {
                    printf("%f"
                          ,((double)Numer(Rationnel_A1A2))/((double)Denom(Rationnel_A1A2))
                           );

                    printf("     %d/%d"
                          ,Numer(Rationnel_A1A2),Denom(Rationnel_A1A2)
                           );

                    printf("     =M(%d/%d,%d/%d)"
                          ,Numer(Rationnel_A1),Denom(Rationnel_A1)
                          ,Numer(Rationnel_A2),Denom(Rationnel_A2)
                           );

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

          if        (compteur < PROFONDEUR)
                    {
                    EnumerationDesRationnels(Rationnel_A1,Rationnel_A1A2);
                    EnumerationDesRationnels(Rationnel_A1A2,Rationnel_A2);
                    }
          else
                    {
                                        /* Cas ou l'on a genere suffisamment de Rationnels...                                        */
                    }

          compteur--;
          }

#include  "tri_N2.02.I"

void      main()
          {
          Fraction  Rationnel_01;
          Fraction  Rationnel_10;
          EGAL(Rationnel_01,0,1);
          EGAL(Rationnel_10,1,0);

          EnumerationDesRationnels(Rationnel_01,Rationnel_10);

          if        (TRIER == VRAI)
                    {
                    int       index;

                    for       (index=INDEX0 ; index<=INDEXn ; index++)
                              {
                              permutation[index] = index;
                              }

                    tri(INDEX0,INDEXn);
                                        /* Tri des Rationnels dans l'ordre croissant...                                              */

                    for       (index=INDEX0 ; index<=INDEXn ; index++)
                              {
                              printf("%d/%d\n",numerateurs__[permutation[index]],denominateurs[permutation[index]]);
                              }
                    }
          else
                    {
                    }
          }