/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        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.02$c' :                                                                                         */
/*                                                                                                                                   */
/*                    Jean-Francois Colonna (LACTAMME, 20230303174558).                                                              */
/*                                                                                                                                   */
/*************************************************************************************************************************************/

#include  "INCLUDES.01.I"

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

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

void      ConversionBase(nombre,base,exposant)
int       nombre;
int       base;
int       exposant;
          {
          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
                              {
                              }

                    printf("%d ",quotient);

                    NombreCourant=reste;
                    diviseur=diviseur/BASE;
                    }
          }

int       main()
          {
          int       n1,n2;

          for       (n1=(N-1) ; n1>=0 ; n1--)
                    {
                    for       (n2=(n1-1) ; n2>=0 ; n2--)
                              {
                              double    logarithme=log((double)(n1^n2))/log((double)BASE);

                              if        ((int)logarithme == logarithme)
                                        {
                                        ConversionBase(MIN2(n1,n2),BASE,EXPOSANT);
                                        printf("  --o-->  ");
                                        ConversionBase(MAX2(n1,n2),BASE,EXPOSANT);
                                        printf("\n");
                                        /* 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
                                        {
                                        }
                              }
                    }

          return(0);
          }