/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        G E N E R A T I O N   D ' U N   H Y P E R C U B E  :                                                                       */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*        Author of '$xtc/hyper_cube.12$c' :                                                                                         */
/*                                                                                                                                   */
/*                    Jean-Francois COLONNA (LACTAMME, 20230309093902).                                                              */
/*                                                                                                                                   */
/*************************************************************************************************************************************/

#include  "INCLUDES.01.I"

extern    double    log();
extern    double    pow();

#define   BASE                                                                                                                          \
                    2
#define   EXPOSANT                                                                                                                      \
                    3
#define   N                                                                                                                             \
                    ((int)pow((double)BASE,(double)EXPOSANT))

#define   FIN_DE_CHAINE                                                                                                                 \
                    (char)0


#define   GENERATION_LISTE_DES_ENTIERS                                                                                                  \
                    {                                                                                                                   \
                    int       n;                                                                                                        \
                                                                                                                                        \
                    printf("\nGeneration de la liste des entiers de %d a %d :\n\n",0,N-1);                                              \
                                                                                                                                        \
                    for       (n=0 ; n<=(N-1) ; n++)                                                                                    \
                              {                                                                                                         \
                              printf("%s\n",ConversionBase(n,BASE,EXPOSANT));                                                           \
                              }                                                                                                         \
                                                                                                                                        \
                    printf("\n");                                                                                                       \
                    }

#define   GENERATION_DES_ARETES                                                                                                         \
                    {                                                                                                                   \
                    int       n1,n2;                                                                                                    \
                                                                                                                                        \
                    printf("\nGeneration des aretes :\n\n");                                                                            \
                                                                                                                                        \
                    for       (n1=0 ; n1<=(N-1) ; n1++)                                                                                 \
                              {                                                                                                         \
                              for       (n2=0 ; n2<=(n1-1) ; n2++)                                                                      \
                                        {                                                                                               \
                                        int       minimum_n1_n2=MIN2(n1,n2);                                                            \
                                        int       maximum_n1_n2=MAX2(n1,n2);                                                            \
                                                                                                                                        \
                                        double    logarithme_base2=log((double)(n1^n2))/log((double)BASE);                              \
                                                                                                                                        \
                                        printf("EOR(%s",ConversionBase(minimum_n1_n2,BASE,EXPOSANT));                                   \
                                        printf(",%s)=",ConversionBase(maximum_n1_n2,BASE,EXPOSANT));                                    \
                                        printf("%s",ConversionBase((n1^n2),BASE,EXPOSANT));                                             \
                                                                                                                                        \
                                        if        ((int)logarithme_base2 == logarithme_base2)                                           \
                                                  {                                                                                     \
                                                  printf("     log2=%d",(int)logarithme_base2);                                         \
                                                  printf("          arete={%s,%s}"                                                      \
                                                        ,ConversionBase(minimum_n1_n2,BASE,EXPOSANT)                                    \
                                                        ,ConversionBase(maximum_n1_n2,BASE,EXPOSANT)                                    \
                                                         );                                                                             \
                                        /* Edition des couples {n1,n2} de sommets connectes de l'hypercube et qui correspondent      */ \
                                        /* aux cas ou 'n1' et 'n2' ne different que d'un seul bit, ce qui se voit en faisant le      */ \
                                        /* ou-exclusif entre eux, puis en regardant si ce dernier est une puissance de 2 (son        */ \
                                        /* logarithme en base 2 est alors un nombre entier...).                                      */ \
                                                  }                                                                                     \
                                        else                                                                                            \
                                                  {                                                                                     \
                                                  printf("     log2=%f",logarithme_base2);                                              \
                                                  }                                                                                     \
                                                                                                                                        \
                                        printf("\n");                                                                                   \
                                        }                                                                                               \
                                                                                                                                        \
                              printf("\n");                                                                                             \
                              }                                                                                                         \
                                                                                                                                        \
                    printf("\n");                                                                                                       \
                    }

char      *ConversionBase(nombre,base,exposant)
int       nombre;
int       base;
int       exposant;
          {
          char      *chaine=malloc(exposant+1);

          int       diviseur=(int)pow((double)base,(double)(exposant-1));
          int       NombreCourant=nombre;
          int       quotient,reste;
          int       iteration;

          for       (iteration=1 ; iteration<=exposant ; iteration++)
                    {
                    quotient=NombreCourant/diviseur;
                    reste=NombreCourant%diviseur;

                    if        ((quotient<0) || (quotient >= BASE))
                              {
                              printf("\nquotient errone ; %d\n",quotient);
                              }
                    else
                              {
                              }

                    *(chaine+iteration-1)='0'+quotient;

                    NombreCourant=reste;
                    diviseur=diviseur/BASE;
                    }
          *(chaine+iteration-1)=FIN_DE_CHAINE;

          return(chaine);
          }

int       main()
          {
          int       n1,n2;

          GENERATION_LISTE_DES_ENTIERS;

          GENERATION_DES_ARETES;

          return(0);
          }