/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        P R E M I E R E S   G E N E R A T I O N S   D E   N O M B R E S   S U R R E E L S  :                                       */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*        Author of '$xtc/NombresSurReels.01$c' :                                                                                    */
/*                                                                                                                                   */
/*                    Jean-Francois COLONNA (LACTAMME, 20081106162832).                                                              */
/*                                                                                                                                   */
/*************************************************************************************************************************************/

#include  <stdio.h>

#define   EditerDesFractions                                                                                                            \
                    VRAI

#define   PremierJour                                                                                                                   \
                    0
#define   DernierJour                                                                                                                   \
                    4
                                        /* Definition du temps : evidemment, 'DernierJour' devrait etre infini...                    */

#define   OrigineSpatiale                                                                                                               \
                    0
#define   DenominateurNombreEntier                                                                                                      \
                    1

#define   Successeur                                                                                                                    \
                    1
#define   Pred(x)                                                                                                                       \
                    ((x)-Successeur)
#define   Neut(x)                                                                                                                       \
                    (x)
#define   Succ(x)                                                                                                                       \
                    ((x)+Successeur)
                                        /* Definition des fonctions {Predecesseur,Neutre,Successeur}.                                */

#define   Dyadique                                                                                                                      \
                    2
#define   Dyad(x)                                                                                                                       \
                    (Dyadique*(x))
                                        /* Definition de la fonction {Dyadique}.                                                     */

#define   VRAI                                                                                                                          \
                    1
#define   FAUX                                                                                                                          \
                    0

typedef   struct
          {
          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;                                                                                     \
                    }

void      GenerationDesNombresSurReels(JourCourant,NombreSurReelDuJourCourant)
int       JourCourant;
Fraction  NombreSurReelDuJourCourant;
          {
          if        (JourCourant <= DernierJour)
                    {
                    Fraction  NombreSurReelDuJourCourantSimplifie;
                    Fraction  NombreSurReelDuJourSuivantLeft_,NombreSurReelDuJourSuivantRight;

                    EGAL(NombreSurReelDuJourCourantSimplifie,Numer(NombreSurReelDuJourCourant),Denom(NombreSurReelDuJourCourant));

                    if        (    (Numer(NombreSurReelDuJourCourant) != OrigineSpatiale)
                              &&   (Denom(NombreSurReelDuJourCourant) != DenominateurNombreEntier)
                               )
                              {
                              int       iterer=VRAI;

                              while     (iterer == VRAI)
                                        {
                                        if        (    ((Numer(NombreSurReelDuJourCourantSimplifie)%Dyadique) == 0)
                                                  &&   ((Denom(NombreSurReelDuJourCourantSimplifie)%Dyadique) == 0)
                                                   )
                                                  {
                                                  EGAL(NombreSurReelDuJourCourantSimplifie
                                                      ,Numer(NombreSurReelDuJourCourantSimplifie)/Dyadique
                                                      ,Denom(NombreSurReelDuJourCourantSimplifie)/Dyadique
                                                       );
                                        /* Simplification de la fraction 'NombreSurReelDuJourCourant'.                               */
                                                  }
                                        else
                                                  {
                                                  iterer=FAUX;
                                                  }
                                        }
                              }
                    else
                              {
                              }

                    if        (EditerDesFractions == VRAI)
                              {
                              if        (Denom(NombreSurReelDuJourCourantSimplifie) > DenominateurNombreEntier)
                                        {
                                        printf("jour=%d nombre=%+d/%d\n"
                                              ,JourCourant
                                              ,Numer(NombreSurReelDuJourCourantSimplifie)
                                              ,Denom(NombreSurReelDuJourCourantSimplifie)
                                               );
                                        /* Edition de la fraction irreductible 'NombreSurReelDuJourCourant'.                         */
                                        }
                              else
                                        {
                                        printf("jour=%d nombre=%+d\n"
                                              ,JourCourant
                                              ,Numer(NombreSurReelDuJourCourantSimplifie)/Denom(NombreSurReelDuJourCourantSimplifie)
                                               );
                                        /* Edition du nombre entier 'NombreSurReelDuJourCourant'.                                    */
                                        }
                              }
                    else
                              {
                              printf("jour=%d nombre=%+.16f\n"
                                    ,JourCourant
                                    ,(double)Numer(NombreSurReelDuJourCourantSimplifie)
                                     /(double)Denom(NombreSurReelDuJourCourantSimplifie)
                                     );
                                        /* Edition du 'NombreSurReelDuJourCourant' sous forme decimale afin de permettre en sortie   */
                                        /* un tri croissant et numerique...                                                          */
                              }

                    if        (Denom(NombreSurReelDuJourCourant) == DenominateurNombreEntier)
                              {
                                        /* Cas des nombres SurReels extremaux (negatif, positif et evidemment cas particulier de     */
                                        /* l'origine...) :                                                                           */
                              if        (Numer(NombreSurReelDuJourCourant) < 0)
                                        {
                                        EGAL(NombreSurReelDuJourSuivantLeft_
                                            ,Pred(Numer(NombreSurReelDuJourCourant))
                                            ,Neut(Denom(NombreSurReelDuJourCourant))
                                             );
                                        EGAL(NombreSurReelDuJourSuivantRight
                                            ,Succ(Dyad(Numer(NombreSurReelDuJourCourant)))
                                            ,Neut(Dyad(Denom(NombreSurReelDuJourCourant)))
                                             );
                                        /* Fils de gauche ("Left_") et de droite ("Right") du nombre SurReel le plus negatif...      */
                                        }
                              else
                                        {
                                        if        (Numer(NombreSurReelDuJourCourant) == 0)
                                                  {
                                                  EGAL(NombreSurReelDuJourSuivantLeft_
                                                      ,Pred(Numer(NombreSurReelDuJourCourant))
                                                      ,Neut(Denom(NombreSurReelDuJourCourant))
                                                       );
                                                  EGAL(NombreSurReelDuJourSuivantRight
                                                      ,Succ(Numer(NombreSurReelDuJourCourant))
                                                      ,Neut(Denom(NombreSurReelDuJourCourant))
                                                       );
                                        /* Fils de gauche ("Left_") et de droite ("Right") du nombre SurReel 0={O|O}...              */
                                                  }
                                        else
                                                  {
                                                  if        (Numer(NombreSurReelDuJourCourant) > 0)
                                                            {
                                                            EGAL(NombreSurReelDuJourSuivantLeft_
                                                                ,Pred(Dyad(Numer(NombreSurReelDuJourCourant)))
                                                                ,Neut(Dyad(Denom(NombreSurReelDuJourCourant)))
                                                                 );
                                                            EGAL(NombreSurReelDuJourSuivantRight
                                                                ,Succ(Numer(NombreSurReelDuJourCourant))
                                                                ,Neut(Denom(NombreSurReelDuJourCourant))
                                                                 );
                                                            }
                                        /* Fils de gauche ("Left_") et de droite ("Right") du nombre SurReel le plus positif...      */
                                                  else
                                                            {
                                                            printf("ERREUR...\n");
                                                            }
                                                  }
                                        }
                              }
                    else
                              {
                              EGAL(NombreSurReelDuJourSuivantLeft_
                                  ,Pred(Dyad(Numer(NombreSurReelDuJourCourant)))
                                  ,Neut(Dyad(Denom(NombreSurReelDuJourCourant)))
                                   );
                              EGAL(NombreSurReelDuJourSuivantRight
                                  ,Succ(Dyad(Numer(NombreSurReelDuJourCourant)))
                                  ,Neut(Dyad(Denom(NombreSurReelDuJourCourant)))
                                   );
                                        /* Cas des autres nombres SurReels, c'est-a-dire ceux qui ne sont pas extremaux...           */
                              }

                    GenerationDesNombresSurReels(JourCourant+Successeur,NombreSurReelDuJourSuivantLeft_);
                                        /* Calcul des deux "fils" du nombre SurReel 'NombreSurReelDuJourSuivantLeft_'...             */
                    GenerationDesNombresSurReels(JourCourant+Successeur,NombreSurReelDuJourSuivantRight);
                                        /* Calcul des deux "fils" du nombre SurReel 'NombreSurReelDuJourSuivantRight'...             */
                    }
          else
                    {
                                        /* Cas ou l'on a genere suffisamment de generations de nombres SurReels...                   */
                    }
          }

main()
          {
          Fraction  NombreSurReelOrigine;
          EGAL(NombreSurReelOrigine,OrigineSpatiale,DenominateurNombreEntier);

          GenerationDesNombresSurReels(PremierJour,NombreSurReelOrigine);
                                        /* Calcul des deux "fils" du nombre SurReel "origine"...                                     */
          }