/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        FONCTION D'EXPLORATION DE L'ESPACE DES COORDONNEES :                                                                       */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*        Author of '$xrD/universel$K' :                                                                                             */
/*                                                                                                                                   */
/*                    Jean-Francois Colonna (LACTAMME, 19????????????).                                                              */
/*                                                                                                                                   */
/*************************************************************************************************************************************/

#define   coord0    0                                                                                                                   \
                                        /* Rang de la premiere coordonnee.                                                           */
#define   coordN    2                                                                                                                   \
                                        /* Rang de la derniere coordonnee.                                                           */
#define   dimension (coordN - coord0 + BEGIN_AT_0)                                                                                      \
                                        /* Dimension de l'espace physique.                                                           */
#define   coordMIN  0                                                                                                                   \
                                        /* Borne inferieure inclusive des coordonnees.                                               */
#define   logMAX    1                                                                                                                   \
                                        /* Logarithme en base 2 de "coordMAX".                                                       */
#define   coordMAX  ((BIT<<logMAX) - BEGIN_AT_0 + coordMIN)                                                                             \
                                        /* Borne superieure inclusive des coordonnees.                                               */
Int
FONCTION  EXPLORE(COORDONNEES)
DEFV(Argument,DEFV(Int,COORDONNEES[dimension]));
                                        /* Vecteur de coordonnees.                                                                   */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
     {
     DEFV(Int,INIT(i,UNDEF));
                                        /* Index d'acces aux composantes du vecteur COORDONNEES.                                     */
     DEFV(Int,INIT(fin,UNDEF));
                                        /* Indicateur de fin de l'exploration de l'espace physique.                                  */
     POINTC(COORDONNEES);
     fin = TRUE;
                                        /* A priori c'est la fin de l'exploration.                                                   */
     for (i = coordN ; i >= coord0 ; i--)
          {
          if (COORDONNEES[i] < coordMAX)
               {
               COORDONNEES[i]++;
               fin = FALSE;
                                        /* Non, ce n'est pas la fin.                                                                 */
               break;
               }
          else
               {
               COORDONNEES[i] = coordMIN;
               }
          if (fin == FALSE)
               {
               break;
               }
          }
     if (fin == FALSE)
          {
          EXPLORE(COORDONNEES);
                                        /* Exploration recursive de l'espace physique.                                               */
          }
     }

/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        FONCTION D'EXPLORATION DE L'ESPACE DES VALEURS :                                                                           */
/*                                                                                                                                   */
/*************************************************************************************************************************************/
#define   nombre    (BIT<<(logMAX * dimension))                                                                                         \
                                        /* Dimension de l'espace des valeurs.                                                        */
#define   val0      0                                                                                                                   \
                                        /* Rang de la premiere valeur.                                                               */
#define   valN      (nombre + val0 - BEGIN_AT_0)                                                                                        \
                                        /* Rang de la derniere valeur.                                                               */
#define   valMIN    0                                                                                                                   \
                                        /* Valeur la plus basse possible.                                                            */
#define   valMAX    2                                                                                                                   \
                                        /* Valeur la plus grande possible.                                                           */
Int
FONCTION  GENERE(VALEURS)
DEFV(Argument,DEFV(Int,VALEURS[nombre]));
                                        /* Vecteur des valeurs.                                                                      */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
     {
     DEFV(Int,INIT(i,UNDEF));
                                        /* Index d'acces aux composantes du vecteur VALEURS.                                         */
     DEFV(Int,INIT(fin,UNDEF));
                                        /* Indicateur de fin de l'exploration de l'espace des valeurs.                               */
     POINTV(VALEURS);
     fin = TRUE;
                                        /* A priori c'est la fin de l'exploration.                                                   */
     for (i = valN ; i >= val0 ; i--)
          {
          if (VALEURS[i] < valMAX)
               {
               VALEURS[i]++;
               fin = FALSE;
                                        /* Non, ce n'est pas la fin.                                                                 */
               break;
               }
          else
               {
               VALEURS[i] = valMIN;
               }
          if (fin == FALSE)
               {
               break;
               }
          }
     if (fin == FALSE)
          {
          GENERE(VALEURS);
                                        /* Exploration recursive de l'espace des valeurs.                                            */
          }
     }

/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        FONCTION D'EDITION DES COORDONNEES :                                                                                       */
/*                                                                                                                                   */
/*************************************************************************************************************************************/
Int
FONCTION  POINTC(COORDONNEES)
DEFV(Argument,DEFV(Int,COORDONNEES[dimension]));
                                        /* Vecteur de composantes.                                                                   */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
     {
     DEFV(Int,INIT(i,UNDEF));
                                        /* Index des composantes du vecteur.                                                         */
     CAL2(Prin0("COORDONNEES :\n"));
     for (i = coord0 ; i <= coordN ; i++)
          {
          CAL2(Prin1(" %d",COORDONNEES[i]));
          }
     }

/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        FONCTION D'EDITION DES VALEURS :                                                                                           */
/*                                                                                                                                   */
/*************************************************************************************************************************************/
Int
FONCTION  POINTV(VALEURS)
DEFV(Argument,DEFV(Int,VALEURS[nombre]));
                                        /* Vecteur de composantes.                                                                   */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
     {
     DEFV(Int,INIT(i,UNDEF));
                                        /* Index des composantes du vecteur.                                                         */
     CAL2(Prin0("VALEURS :\n"));
     for (i = val0 ; i <= valN ; i++)
          {
          CAL2(Prin1(" %d",VALEURS[i]));
          }
     }

/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        PROGRAMME PRINCIPAL :                                                                                                      */
/*                                                                                                                                   */
/*************************************************************************************************************************************/
main()
/*-----------------------------------------------------------------------------------------------------------------------------------*/
     {
     DEFV(Int,COORDONNEES[dimension]);
                                        /* Vecteur de composantes.                                                                   */
     DEFV(Int,VALEURS[nombre]);
                                        /* Vecteur de composantes.                                                                   */
     DEFV(Int,INIT(i,UNDEF));
                                        /* Index des composantes du vecteur.                                                         */
     for (i = coord0 ; i <= coordN ; i++)
          {
          COORDONNEES[i] = coordMIN;
          }
     EXPLORE(COORDONNEES);
                                        /* Exploration recursive de l'espace physique.                                               */
     for (i = val0 ; i <= valN ; i++)
          {
          VALEURS[i] = valMIN;
          }
     GENERE(VALEURS);
                                        /* Exploration recursive de l'espace des valeurs.                                            */
     }