/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        P A R C O U R S   E N   " Z I G - Z A G "   D ' U N E   M A T R I C E   C A R R E E  :                                     */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*        Author of '$xtc/zig_zag.01$c' :                                                                                            */
/*                                                                                                                                   */
/*                    Jean-Francois Colonna (LACTAMME, AAAAMMJJhhmmss).                                                              */
/*                                                                                                                                   */
/*************************************************************************************************************************************/

#include  "INCLUDES.01.I"
                                        /* Introduit le 20051116103411...                                                            */

#define   DIMENSION                                                                                                                     \
                    (DEUX*DEUX)

#define   DEUX                                                                                                                          \
                    2

#define   INDEX0                                                                                                                        \
                    0
#define   INDX(k)                                                                                                                       \
                    INTE((k) - INDEX0)
#define   LSTX(nombre)                                                                                                                  \
                    INTE(INDEX0 + ((nombre) - 1))
#define   COMPLEMENT(k)                                                                                                                 \
                    (LSTX(DIMENSION)-INDX(k))

#define   INTE(x)                                                                                                                       \
                    ((int)(x))

#define   SOMME_1_DE_0_a_N(n)                                                                                                           \
                    (((n)*((n)+1))/2)

#define   FONCTION(i,j)                                                                                                                 \
                    (SOMME_1_DE_0_a_N(INDX(i)+INDX(j))                                                                                  \
                    +COND(EST_PAIR(INDX(i)+INDX(j))                                                                                     \
                         ,INDX(i)                                                                                                       \
                         ,INDX(j)                                                                                                       \
                          )                                                                                                             \
                     )

main()
          {
          int       i,j;
                                        /* Indices de la matrice.                                                                    */
          int       index;
                                        /* Index lineaire cherche...                                                                 */
          int       fonction_directe[DIMENSION][DIMENSION];
                                        /* Definition de la fonction avec une matrice.                                               */
          int       fonction_inverse_i[DIMENSION*DIMENSION];
          int       fonction_inverse_j[DIMENSION*DIMENSION];
                                        /* Definition de la fonction inverse avec 2 tableaux {i,j}.                                  */

          for       (j=INDEX0 ; j<=LSTX(DIMENSION) ; j++)
                    {
                    for       (i=INDEX0 ; i<=LSTX(DIMENSION) ; i++)
                              {
                              fonction_directe[i][j] = INDEX0 - DEUX;
                                        /* La valeur initiale correspond a une valeur a priori impossible...                         */
                              }
                    }

          for       (index=INDEX0 ; index<=LSTX(DIMENSION*DIMENSION) ; index++)
                    {
                    fonction_inverse_i[index] = INDEX0 - DEUX;
                    fonction_inverse_j[index] = INDEX0 - DEUX;
                                        /* La valeur initiale correspond a une valeur a priori impossible...                         */
                    }

          for       (j=INDEX0 ; j<=LSTX(DIMENSION) ; j++)
                    {
                    for       (i=INDEX0 ; i<=LSTX(DIMENSION) ; i++)
                              {
                              if        ((i+j) <= LSTX(DIMENSION))
                                        {
                                        index=INDEX0 + FONCTION(i,j);
                                        }
                              else
                                        {
                                        index=LSTX(DIMENSION*DIMENSION) - FONCTION(COMPLEMENT(i),COMPLEMENT(j));
                                        }

                              if        (fonction_directe[i][j] < INDEX0)
                                        {
                                        fonction_directe[i][j] = index;
                                        /* Definition de la fonction directe.                                                        */

                                        if        ((fonction_inverse_i[index] < INDEX0) && (fonction_inverse_j[index] < INDEX0))
                                                  {
                                                  fonction_inverse_i[index] = i;
                                                  fonction_inverse_j[index] = j;
                                        /* Definition de la fonction inverse.                                                        */
                                                  }
                                        else
                                                  {
                                                  printf("\n la fonction inverse %04d --> {%04d,%04d}"
                                                        ,index,fonction_inverse_i[index],fonction_inverse_j[index]
                                                         );
                                                  printf("\n est doublement definie ({%04d,%04d})"
                                                        ,i,j
                                                         );
                                                  }
                                        }
                              else
                                        {
                                        printf("\n la fonction directe {%04d,%04d} --> %04d est doublement definie (%04d)"
                                              ,i,j,fonction_directe[i][j],index
                                               );
                                        }
                              }
                    }

          printf("\n fonction directe :\n");

          for       (j=INDEX0 ; j<=LSTX(DIMENSION) ; j++)
                    {
                    printf("\n");
                    for       (i=INDEX0 ; i<=LSTX(DIMENSION) ; i++)
                              {
                              printf(" %04d",fonction_directe[i][j]);
                              }
                    printf("\n");
                    }

          printf("\n fonction inverse :\n");

          for       (index=INDEX0 ; index<=LSTX(DIMENSION*DIMENSION) ; index++)
                    {
                    printf("\n %04d --> {%04d,%04d}",index,fonction_inverse_i[index],fonction_inverse_j[index]);
                    }

          printf("\n");
          }