/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        T E N T A T I V E   D E                                                                                                    */
/*        S U R J E C T I O N   F R A C T A L E   D E   [ 0 , 1 ]   D A N S   [ 0 , 1 ] x [ 0 , 1 ] x [ 0 , 1 ]   D E   P E A N O  : */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*        Author of '$xtc/Peano_SurjectionFractale.13$vv$c' :                                                                        */
/*                                                                                                                                   */
/*                    Jean-Francois Colonna (LACTAMME, 20220401113541).                                                              */
/*                                                                                                                                   */
/*************************************************************************************************************************************/

#include  "INCLUDES.01.I"
extern    double    pow();

#define   BASE                                                                                                                          \
                    4
#define   BASEm1                                                                                                                        \
                    (BASE-1)

int       Parametre_t[]={0,0,0,0,0,0,0,0,0};

#define   INDEX_0                                                                                                                       \
                    1
#define   INDEXATION(vecteur,index)                                                                                                     \
                    (vecteur[MAX2(index,INDEX_0)-INDEX_0])

#define   N                                                                                                                             \
                    (sizeof(Parametre_t)/sizeof(int))
#define   Nr                                                                                                                            \
                    (N/BASEm1)
#define   ALL                                                                                                                           \
                    ((int)pow((double)BASE,(double)N))

int       editer_04=VRAI;
#define   EDITER_04(print)                                                                                                              \
                    {                                                                                                                   \
                    if        (editer_04 == VRAI)                                                                                       \
                              {                                                                                                         \
                              print;                                                                                                    \
                              }                                                                                                         \
                    else                                                                                                                \
                              {                                                                                                         \
                              }                                                                                                         \
                    }                                                                                                                   \
                                        /* Edition conditionnelle en base 04.                                                        */

#define   dSELECTION                                                                                                                    \
                    BASEm1
#define   SELECTION(DCoordonnee,somme)                                                                                                  \
                    {                                                                                                                   \
                    int       reste=somme % dSELECTION;                                                                                 \
                                        /* Le 20220405153522 je note un grave probleme : par defaut le reste est calcule avec un     */ \
                                        /* diviseur egal a 4-1=3. Les restes possibles sont donc {0,1,2} et sont donc en nombre      */ \
                                        /* impair. Et donc les deux instructions :                                                   */ \
                                        /*                                                                                           */ \
                                        /*                  DCoordonnee = Dparametre;                                                */ \
                                        /*                                                                                           */ \
                                        /* et :                                                                                      */ \
                                        /*                                                                                           */ \
                                        /*                  DCoordonnee = BASEm1-Dparametre;                                         */ \
                                        /*                                                                                           */ \
                                        /* ne seront pas en nombre egal (a priori deux fois plus de la premiere que de la seconde) ! */ \
                    switch    (reste)                                                                                                   \
                              {                                                                                                         \
                              case      0:                                                                                              \
                              case      2:                                                                                              \
                                        {                                                                                               \
                                        DCoordonnee = Dparametre;                                                                       \
                                        break;                                                                                          \
                                        }                                                                                               \
                              default:                                                                                                  \
                                        {                                                                                               \
                                        DCoordonnee = BASEm1-Dparametre;                                                                \
                                        }                                                                                               \
                              }                                                                                                         \
                    }

#define   CONVERSION(titre,variable,liste,borne)                                                                                        \
                    {                                                                                                                   \
                    int       n;                                                                                                        \
                    double    puissance=1.0;                                                                                            \
                                                                                                                                        \
                    variable=0.0;                                                                                                       \
                                                                                                                                        \
                    for       (n=INDEX_0 ; n <= borne ; n++)                                                                            \
                              {                                                                                                         \
                              puissance = puissance / ((double)BASE);                                                                   \
                              variable = variable + (((double)INDEXATION(liste,n))*puissance);                                          \
                              }                                                                                                         \
                                                                                                                                        \
                    printf("%s%f\n",titre,variable);                                                                                    \
                    }                                                                                                                   \
                                        /* Conversion de la base 4 vers la base 10.                                                  */

void      Surjection(parametre)
int       parametre[];
          {
          double    t;

          int       Coordonnee_x[Nr];
          double    x;

          int       Coordonnee_y[Nr];
          double    y;

          int       Coordonnee_z[Nr];
          double    z;

          int       n;

          EDITER_04(printf("\n"););
          EDITER_04(printf("t=0.{"););

          for       (n=INDEX_0 ; n <= N ; n++)
                    {
                    if        ((INDEXATION(parametre,n) >= 0) && (INDEXATION(parametre,n) < BASE))
                              {
                              EDITER_04(printf("%d",INDEXATION(parametre,n)););
                              }
                    else
                              {
                              printf("Le chiffre %d de rang %d n'est pas dans [0,%d].\n",INDEXATION(parametre,n),n-INDEX_0,BASEm1);
                              }
                    }

          EDITER_04(printf("}\n"););

          for       (n=INDEX_0 ; n <= (Nr) ; n++)
                    {
                    int       DCoordonnee_x;
                    int       DCoordonnee_y;
                    int       DCoordonnee_z;

                    if        (n >= (INDEX_0+0))
                                        /* Question : "+0" ou autre chose ?                                                          */
                              {
                              int       somme_x=0;
                              int       Dparametre=INDEXATION(parametre,(BASEm1*n)-2);

                              int       p;

                              for       (p=INDEX_0 ; p < n ; p++)
                                        {
                                        somme_x = somme_x + INDEXATION(parametre,(BASEm1*p)-0);
                                        }

                              SELECTION(DCoordonnee_x,somme_x);
                              }
                    else
                              {
                              DCoordonnee_x = INDEXATION(parametre,INDEX_0);
                              }

                    INDEXATION(Coordonnee_x,n) = DCoordonnee_x;

                    if        (n >= (INDEX_0+0))
                                        /* Question : "+0" ou autre chose ?                                                          */
                              {
                              int       somme_y=0;
                              int       Dparametre=INDEXATION(parametre,(BASEm1*n)-1);

                              int       p;

                              for       (p=INDEX_0 ; p < n ; p++)
                                        {
                                        somme_y = somme_y + INDEXATION(parametre,(BASEm1*p)-1);
                                        }

                              SELECTION(DCoordonnee_y,somme_y);
                              }
                    else
                              {
                              DCoordonnee_y = INDEXATION(parametre,INDEX_0);
                              }

                    INDEXATION(Coordonnee_y,n) = DCoordonnee_y;

                    if        (n >= (INDEX_0+0))
                                        /* Question : "+0" ou autre chose ?                                                          */
                              {
                              int       somme_z=0;
                              int       Dparametre=INDEXATION(parametre,(BASEm1*n)-0);

                              int       p;

                              for       (p=INDEX_0 ; p < n ; p++)
                                        {
                                        somme_z = somme_z + INDEXATION(parametre,(BASEm1*p)-2);
                                        }

                              SELECTION(DCoordonnee_z,somme_z);
                              }
                    else
                              {
                              DCoordonnee_z = INDEXATION(parametre,INDEX_0);
                              }

                    INDEXATION(Coordonnee_z,n) = DCoordonnee_z;
                    }

          if        (editer_04 == VRAI)
                    {
                    EDITER_04(printf("x=0.{"););
                    for       (n=INDEX_0 ; n <= (Nr) ; n++)
                              {
                              EDITER_04(printf("%d  ",INDEXATION(Coordonnee_x,n)););
                              }
                    EDITER_04(printf("}\n"););

                    EDITER_04(printf("y=0.{"););
                    for       (n=INDEX_0 ; n <= (Nr) ; n++)
                              {
                              EDITER_04(printf(" %d ",INDEXATION(Coordonnee_y,n)););
                              }
                    EDITER_04(printf("}\n"););

                    EDITER_04(printf("z=0.{"););
                    for       (n=INDEX_0 ; n <= (Nr) ; n++)
                              {
                              EDITER_04(printf("  %d",INDEXATION(Coordonnee_z,n)););
                              }
                    EDITER_04(printf("}\n"););

                    }
          else
                    {
                    CONVERSION("t=",t,parametre,N);

                    CONVERSION("x(t)=",x,Coordonnee_x,Nr);
                    CONVERSION("y(t)=",y,Coordonnee_y,Nr);
                    CONVERSION("z(t)=",z,Coordonnee_z,Nr);
                    }

          return;
          }

void      main()
          {
          int       i1;

          if        ((N%BASEm1) != 0)
                    {
                    printf("ERREUR : la liste 't' a un nombre incorrect d'elements.\n\n");
                    }
          else
                    {
                    }

          for       (i1=1 ; i1 <= ALL ; i1++)
                    {
                    int       i2;
                    int       retenue=1;

                    Surjection(Parametre_t);

                    for       (i2=(N-1) ; i2 >= 0 ; i2--)
                              {
                              Parametre_t[i2] = Parametre_t[i2] + retenue;
                                        /* Incrementation du parametre 't'...                                                        */

                              if        (Parametre_t[i2] == BASE)
                                        {
                                        Parametre_t[i2] = 0;
                                        retenue = 1;
                                        }
                              else
                                        {
                                        retenue = 0;
                                        }
                              }
                    }
          }