```/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        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;
}
}
}
}
```