/*************************************************************************************************************************************/
/* */
/* T R A N S F O R M A T I O N A U T O - S I M I L A I R E D E H I L B E R T */
/* D A N S [ 0 , 1 ] x [ 0 , 1 ] x [ 0 , 1 ] : */
/* */
/* */
/* Probleme de terminologie (le 20230106115757) : */
/* */
/* On notera un probleme dans les */
/* noms donnes aux programmes : */
/* */
/* $xci/valeurs_TransformationPeano2D$I */
/* $xci/valeurs_TransformationPeano2D$K */
/* $xci/valeurs_TransformationPeano3D$K */
/* */
/* qui devraient s'appeler 'Hilbert' */
/* et non pas 'Peano', ainsi qu'a 55 */
/* images 'PEAN's qui devraient s'appeler */
/* en fait 'HILB's. Tout cela est precise */
/* dans 'v $xiirv/$Fnota 20230106103125'... */
/* */
/* */
/* Definition : */
/* */
/* Cette commande est une version tridimensionnelle */
/* de 'v $xci/valeurs_TransformationPeano2D$K'... */
/* */
/* Avec les notations suivantes : */
/* */
/* X(n) --> X1 */
/* Y(n) --> Y1 */
/* Z(n) --> Z1 */
/* */
/* X(n+1) --> X2 */
/* Y(n+1) --> Y2 */
/* Z(n+1) --> Z2 */
/* */
/* la definition de la transformation de Hilbert */
/* tridimensionnelle "historique" est la suivante */
/* en notation matricielle : */
/* */
/* */
/* |X2| | X1| |+1 0 0| |X1| |0| */
/* | | | | | | | | | | */
/* |Y2| = | Z1| = | 0 0 +1| * |Y1| + |0| Transformation 1 */
/* | | | | | | | | | | */
/* |Z2| | Y1| | 0 +1 0| |Z1| |0| */
/* */
/* */
/* |X2| | Z1| | 0 0 +1| |X1| |0| */
/* | | | | | | | | | | */
/* |Y2| = |1+Y1| = | 0 +1 0| * |Y1| + |1| Transformation 2 */
/* | | | | | | | | | | */
/* |Z2| | X1| |+1 0 0| |Z1| |0| */
/* */
/* */
/* |X2| |1+X1| |+1 0 0| |X1| |1| */
/* | | | | | | | | | | */
/* |Y2| = |1+Y1| = | 0 +1 0| * |Y1| + |1| Transformation 3 */
/* | | | | | | | | | | */
/* |Z2| | Z1| | 0 0 +1| |Z1| |0| */
/* */
/* */
/* |X2| |1+Z1| | 0 0 +1| |X1| |1| */
/* | | | | | | | | | | */
/* |Y2| = |1-X1| = |-1 0 0| * |Y1| + |1| Transformation 4 */
/* | | | | | | | | | | */
/* |Z2| |1-Y1| | 0 -1 0| |Z1| |1| */
/* */
/* */
/* |X2| |2-Z1| | 0 0 -1| |X1| |2| */
/* | | | | | | | | | | */
/* |Y2| = |1-X1| = |-1 0 0| * |Y1| + |1| Transformation 5 */
/* | | | | | | | | | | */
/* |Z2| |1+Y1| | 0 +1 0| |Z1| |1| */
/* */
/* */
/* |X2| |1+X1| |+1 0 0| |X1| |1| */
/* | | | | | | | | | | */
/* |Y2| = |1+Y1| = | 0 +1 0| * |Y1| + |1| Transformation 6 */
/* | | | | | | | | | | */
/* |Z2| |1+Z1| | 0 0 +1| |Z1| |1| */
/* */
/* */
/* |X2| |1-Z1| | 0 0 -1| |X1| |1| */
/* | | | | | | | | | | */
/* |Y2| = |1+Y1| = | 0 +1 0| * |Y1| + |1| Transformation 7 */
/* | | | | | | | | | | */
/* |Z2| |2-X1| |-1 0 0| |Z1| |2| */
/* */
/* */
/* |X2| | X1| |+1 0 0| |X1| |0| */
/* | | | | | | | | | | */
/* |Y2| = |1-Z1| = | 0 0 -1| * |Y1| + |1| Transformation 8 */
/* | | | | | | | | | | */
/* |Z2| |2-Y1| | 0 -1 0| |Z1| |2| */
/* */
/* */
/* Author of '$xci/valeurs_TransformationPeano3D$K' : */
/* */
/* Jean-Francois COLONNA (LACTAMME, 20220425092803). */
/* */
/*************************************************************************************************************************************/
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* I N T E R F A C E ' listG ' : */
/* */
/* */
/* :Debut_listG: */
/* :Fin_listG: */
/* */
/*************************************************************************************************************************************/
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D I R E C T I V E S S P E C I F I Q U E S D E C O M P I L A T I O N : */
/* */
/*************************************************************************************************************************************/
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* F I C H I E R S D ' I N C L U D E S : */
/* */
/*************************************************************************************************************************************/
#include INCLUDES_BASE
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* P A R A M E T R E S : */
/* */
/*************************************************************************************************************************************/
#define DIMENSION_DE_LA_COURBE \
TRI_DIMENSIONNEL \
/* Dimension de la courbe... */
#define REMPLACER_LES_LISTES_DE_SUBSTITUTION_PAR_DES_LISTES_QUELCONQUES \
FAUX \
/* Faut-il remplacer les listes de substitution par des listes queconques ('VRAI') ou pas */ \
/* ('FAUX') ? La valeur par defaut assure la compatibilite anterieure (introduit le */ \
/* 20220513105553)... */
#define INTERPOLER_LES_LISTES_QUELCONQUES \
FAUX \
/* Faut-il interpoler les listes queconques ('VRAI') ou pas ('FAUX') ? Voir a ce propos le */ \
/* commentaires 'v $xci/valeurs_TransformationPeano2D$I 20220513134353'. Ceci fut introduit */ \
/* le 20220513142523... */
#define EDITER_LA_DEFINITION_DU_CUBE \
FAUX
#define EDITER_LA_DEFINITION_DES_SOUS_CUBES \
FAUX
/* Faut-il editer la definition du cube ('VRAI') ou pas ('FAUX') ? L'edition de la */
/* definition des 8 sous-cubes a ete introduite le 20220519182554.. */
#define f1x_____NOM_DE_LA_SUBSTITUTION_DE_DEFINITION \
"L_SUBSTITUTION_ROUGE"
#define f1x_____SUBSTITUTION_COURANTE_DE_DEFINITION \
L_SUBSTITUTION_ROUGE
#define f1x_____LISSAGE_DE_LA_SUBSTITUTION_DE_DEFINITION \
FAUX
#define f1x_____NOMBRE_DE_PASSES_DE_LISSAGE_DE_LA_SUBSTITUTION_DE_DEFINITION \
UN
#define f1x_____PAS_DE_LISSAGE_DE_LA_SUBSTITUTION_DE_DEFINITION \
PAS_COULEURS
#define f1x_____MINIMUM_DE_LA_SUBSTITUTION_DE_DEFINITION \
COORDONNEE_BARYCENTRIQUE_MINIMALE
#define f1x_____MAXIMUM_DE_LA_SUBSTITUTION_DE_DEFINITION \
COORDONNEE_BARYCENTRIQUE_MAXIMALE
#define f1x_____INTERPOLER_LA_SUBSTITUTION_DE_DEFINITION \
VRAI
#define f1x_____INTERPOLER_LA_SUBSTITUTION_DE_DEFINITION__LINEAIREMENT \
VRAI
#define f1x_____INTERPOLER_LA_SUBSTITUTION_DE_DEFINITION__CUBIQUEMENT__DERIVEE_ORIGINE__ \
FZERO
#define f1x_____INTERPOLER_LA_SUBSTITUTION_DE_DEFINITION__CUBIQUEMENT__DERIVEE_EXTREMITE \
FZERO
/* Definition de 'f1x(...)' via '$xiP' a valeur dans [0,1]... */
/* */
/* Le 20220427092531, l'interpolation des listes de substitution est passee de 'FAUX' */
/* a 'VRAI' par defaut et ce contrairement a 'v $xci/valeurs_TransformationPeano2D$K' */
/* qui reste a 'FAUX' pour des raisons de compatibilite anterieure... */
#define f1y_____NOM_DE_LA_SUBSTITUTION_DE_DEFINITION \
"L_SUBSTITUTION_VERTE"
#define f1y_____SUBSTITUTION_COURANTE_DE_DEFINITION \
L_SUBSTITUTION_VERTE
#define f1y_____LISSAGE_DE_LA_SUBSTITUTION_DE_DEFINITION \
FAUX
#define f1y_____NOMBRE_DE_PASSES_DE_LISSAGE_DE_LA_SUBSTITUTION_DE_DEFINITION \
UN
#define f1y_____PAS_DE_LISSAGE_DE_LA_SUBSTITUTION_DE_DEFINITION \
PAS_COULEURS
#define f1y_____MINIMUM_DE_LA_SUBSTITUTION_DE_DEFINITION \
COORDONNEE_BARYCENTRIQUE_MINIMALE
#define f1y_____MAXIMUM_DE_LA_SUBSTITUTION_DE_DEFINITION \
COORDONNEE_BARYCENTRIQUE_MAXIMALE
#define f1y_____INTERPOLER_LA_SUBSTITUTION_DE_DEFINITION \
VRAI
#define f1y_____INTERPOLER_LA_SUBSTITUTION_DE_DEFINITION__LINEAIREMENT \
VRAI
#define f1y_____INTERPOLER_LA_SUBSTITUTION_DE_DEFINITION__CUBIQUEMENT__DERIVEE_ORIGINE__ \
FZERO
#define f1y_____INTERPOLER_LA_SUBSTITUTION_DE_DEFINITION__CUBIQUEMENT__DERIVEE_EXTREMITE \
FZERO
/* Definition de 'f1y(...)' via '$xiP' a valeur dans [0,1]... */
/* */
/* Le 20220427092531, l'interpolation des listes de substitution est passee de 'FAUX' */
/* a 'VRAI' par defaut et ce contrairement a 'v $xci/valeurs_TransformationPeano2D$K' */
/* qui reste a 'FAUX' pour des raisons de compatibilite anterieure... */
#define f1z_____NOM_DE_LA_SUBSTITUTION_DE_DEFINITION \
"L_SUBSTITUTION_VERTE"
#define f1z_____SUBSTITUTION_COURANTE_DE_DEFINITION \
L_SUBSTITUTION_VERTE
#define f1z_____LISSAGE_DE_LA_SUBSTITUTION_DE_DEFINITION \
FAUX
#define f1z_____NOMBRE_DE_PASSES_DE_LISSAGE_DE_LA_SUBSTITUTION_DE_DEFINITION \
UN
#define f1z_____PAS_DE_LISSAGE_DE_LA_SUBSTITUTION_DE_DEFINITION \
PAS_COULEURS
#define f1z_____MINIMUM_DE_LA_SUBSTITUTION_DE_DEFINITION \
COORDONNEE_BARYCENTRIQUE_MINIMALE
#define f1z_____MAXIMUM_DE_LA_SUBSTITUTION_DE_DEFINITION \
COORDONNEE_BARYCENTRIQUE_MAXIMALE
#define f1z_____INTERPOLER_LA_SUBSTITUTION_DE_DEFINITION \
VRAI
#define f1z_____INTERPOLER_LA_SUBSTITUTION_DE_DEFINITION__LINEAIREMENT \
VRAI
#define f1z_____INTERPOLER_LA_SUBSTITUTION_DE_DEFINITION__CUBIQUEMENT__DERIVEE_ORIGINE__ \
FZERO
#define f1z_____INTERPOLER_LA_SUBSTITUTION_DE_DEFINITION__CUBIQUEMENT__DERIVEE_EXTREMITE \
FZERO
/* Definition de 'f1z(...)' via '$xiP' a valeur dans [0,1]... */
/* */
/* Le 20220427092531, l'interpolation des listes de substitution est passee de 'FAUX' */
/* a 'VRAI' par defaut et ce contrairement a 'v $xci/valeurs_TransformationPeano2D$K' */
/* qui reste a 'FAUX' pour des raisons de compatibilite anterieure... */
#define CHAINER_LES_POINTS \
VRAI \
/* Faut-il chainer les points ('VRAI') ou pas ('FAUX') ? */
#define CALCULER_UNE_SEULE_ITERATION \
VRAI
#define NUMERO_DE_L_ITERATION_UNIQUE \
ITERATION_05
/* Choix du mode "une" ou "plusieurs iterations"... */
#define EDITER_ITERATION_01 \
FAUX
#define EDITER_ITERATION_02 \
FAUX
#define EDITER_ITERATION_03 \
FAUX
#define EDITER_ITERATION_04 \
FAUX
#define EDITER_ITERATION_05 \
VRAI
#define EDITER_ITERATION_06 \
VRAI
#define EDITER_ITERATION_07 \
VRAI
/* Choix des iterations a editer si 'IL_NE_FAUT_PAS(calculer_une_seule_iteration)'... */
#define PAS_DE_L_ITERATION_01 \
PARE(0.001000)
#define PAS_DE_L_ITERATION_02 \
FRA2(PAS_DE_L_ITERATION_01)
#define PAS_DE_L_ITERATION_03 \
FRA2(PAS_DE_L_ITERATION_02)
#define PAS_DE_L_ITERATION_04 \
FRA2(PAS_DE_L_ITERATION_03)
#define PAS_DE_L_ITERATION_05 \
FRA4(PAS_DE_L_ITERATION_04)
#define PAS_DE_L_ITERATION_06 \
FRA4(PAS_DE_L_ITERATION_05)
#define PAS_DE_L_ITERATION_07 \
FRA4(PAS_DE_L_ITERATION_06)
/* Pas d'edition des iterations... */
#define PERMUTATION_XX \
FZERO
#define PERMUTATION_XY \
FZERO
#define PERMUTATION_XZ \
NEUT(FU)
#define TRANSLATION_X \
FZERO
#define PERMUTATION_YX \
FZERO
#define PERMUTATION_YY \
NEUT(FU)
#define PERMUTATION_YZ \
FZERO
#define TRANSLATION_Y \
FZERO
#define PERMUTATION_ZX \
NEGA(FU)
#define PERMUTATION_ZY \
FZERO
#define PERMUTATION_ZZ \
FZERO
#define TRANSLATION_Z \
FU
/* Le 20220428110814, les coordonnees 'X' et 'Z' ont ete permutees afin d'assurer la */
/* compatibilite des orientations des courbes ainsi generees avec des courbes anterieures */
/* (voir par exemple 'v $xiirv/PEAN.61' et 'v $xiirv/HILB.I2' respectivement...) generees */
/* par 'v $xci/valeurs_Hilbert3D$K' en particulier... */
#define PONDERATION_DE_T \
FU
#define PONDERATION_DE_X \
FZERO
#define PONDERATION_DE_Y \
FZERO
#define PONDERATION_DE_Z \
FZERO
/* Ponderations respectives de 'X', 'Y' et 'Z'. */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* M A C R O S U T I L E S : */
/* */
/*************************************************************************************************************************************/
#include xrv/ARITHMET.1d.I"
#include xrv/ARITHMET.21.I"
#include xrv/champs_5.41.I"
/* Introduits le 20220513101131... */
#include xci/valeurs_TransformationPeano2D.I"
/* Introduit le 20220426131337... */
#define PARAMETRAGE_DE_L_ITERATION_UNIQUE(iteration,editer_iteration,pas_de_l_iteration) \
Ca1e(iteration) \
Bblock \
EGAL(editer_iteration,VRAI); \
Eblock \
ECa1 \
/* Choix d'une iteration... */
#define EDITION_DE_LA_DEFINITION_DU_CUBE(editer,sommetX,sommetY,sommetZ) \
/* On notera que l'argument 'editer' n'est pas utilisee, mais ce n'est pas une erreur et */ \
/* cela vient de l'usage 'v $xci/valeurs_Hilbert3D$I EDITION_DE_LA_DEFINITION_DU_CUBE'... */ \
Bblock \
EDITION_DES_COORDONNEES("xB=%+.^^^ yB=%+.^^^ zB=%+.^^^ DefinitionCube=",sommetX,sommetY,sommetZ); \
Eblock \
/* Edition de la definition du cube... */
#define EDITION_DES_COORDONNEES(format_coordonnees_X_Y_et_Z,Coordonnee_X,Coordonnee_Y,Coordonnee_Z) \
Bblock \
CAL2(Prin3(format_coordonnees_X_Y_et_Z \
,LIN3(permutation_XX,Coordonnee_X \
,permutation_XY,Coordonnee_Y \
,permutation_XZ,Coordonnee_Z \
,translation_X \
) \
,LIN3(permutation_YX,Coordonnee_X \
,permutation_YY,Coordonnee_Y \
,permutation_YZ,Coordonnee_Z \
,translation_Y \
) \
,LIN3(permutation_ZX,Coordonnee_X \
,permutation_ZY,Coordonnee_Y \
,permutation_ZZ,Coordonnee_Z \
,translation_Z \
) \
) \
); \
/* Le 20220428110814, les coordonnees 'X' et 'Z' ont ete permutees afin d'assurer la */ \
/* compatibilite des orientations des courbes ainsi generees avec des courbes anterieures */ \
/* (voir par exemple 'v $xiirv/PEAN.61' et 'v $xiirv/HILB.I2' respectivement...) generees */ \
/* par 'v $xci/valeurs_Hilbert3D$K' en particulier... */ \
CAL2(Prin0("\n")); \
Eblock \
/* Edition des coordonnees. */
#define EDITION_EVENTUELLE_D_UNE_ITERATION(editer,F2x,F2y,F2z,F1x,F1y,,F1z,pas_t) \
Bblock \
Test(IL_FAUT(editer)) \
Bblock \
DEFV(Float,INIT(t,FLOT__UNDEF)); \
\
DEFV(Local,DEFV(Float,INIT(Coordonnee_courante___X,FLOT__UNDEF))); \
DEFV(Local,DEFV(Float,INIT(Coordonnee_courante___Y,FLOT__UNDEF))); \
DEFV(Local,DEFV(Float,INIT(Coordonnee_courante___Z,FLOT__UNDEF))); \
/* Coordonnees 'X', 'Y' et 'Z' a l'instant 'T' courant. */ \
\
DEFV(Local,DEFV(Float,INIT(Coordonnee_anterieure_X,FLOT__UNDEF))); \
DEFV(Local,DEFV(Float,INIT(Coordonnee_anterieure_Y,FLOT__UNDEF))); \
DEFV(Local,DEFV(Float,INIT(Coordonnee_anterieure_Z,FLOT__UNDEF))); \
/* Coordonnees 'X', 'Y' et 'Z' a l'instant 'T' precedent. */ \
\
DoIn(t,minimum_t,maximum_t,pas_t) \
Bblock \
EGAL(Coordonnee_courante___X,F2x(t,&F1x,&F1y,&F1z)); \
EGAL(Coordonnee_courante___Y,F2y(t,&F1x,&F1y,&F1z)); \
EGAL(Coordonnee_courante___Z,F2z(t,&F1x,&F1y,&F1z)); \
\
Test(IL_FAUT(chainer_les_points)) \
Bblock \
Test(IFGT(t,minimum_t)) \
Bblock \
EGAL(Coordonnee_anterieure_X,Coordonnee_courante___X); \
EGAL(Coordonnee_anterieure_Y,Coordonnee_courante___Y); \
EGAL(Coordonnee_anterieure_Z,Coordonnee_courante___Z); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
\
Test(IL_FAUT(chainer_les_points)) \
Bblock \
Test(IFGT(t,minimum_t)) \
Bblock \
EDITION_DES_COORDONNEES("xA=%+.^^^ yA=%+.^^^ zA=%+.^^^" \
,Coordonnee_anterieure_X,Coordonnee_anterieure_Y,Coordonnee_anterieure_Z \
); \
EDITION_DES_COORDONNEES("xB=%+.^^^ yB=%+.^^^ zB=%+.^^^" \
,Coordonnee_courante___X,Coordonnee_courante___Y,Coordonnee_courante___Z \
); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
ATes \
Bblock \
CAL2(Prin2(Cara(chain_Aconcaten5(INTRODUCTION_FORMAT,valeurs_signees,".*",format_d_edition,"\n")) \
,NOMBRE_DE_DECIMALES_EFFECTIF(nombre_de_decimales) \
,LIZ4(ponderation_de_T,FLOT(t) \
,ponderation_de_X,FLOT(Coordonnee_courante___X) \
,ponderation_de_Y,FLOT(Coordonnee_courante___Y) \
,ponderation_de_Z,FLOT(Coordonnee_courante___Z) \
) \
) \
); \
Eblock \
ETes \
Eblock \
EDoI \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
/* Edition des coordonnees. */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* S U I T E D E F O N C T I O N S R E C U R S I V E S A V A L E U R D A N S [ 0 , 1 ] */
/* T R A N S F O R M A T I O N A U T O - S I M I L A I R E D E H I L B E R T */
/* D A N S [ 0 , 1 ] x [ 0 , 1 ] x [ 0 , 1 ] : */
/* */
/*************************************************************************************************************************************/
Denumer07(INIS(_01,UN)
,_02
,_03
,_04
,_05
,_06
,_07
,ListeDesIterationsDisponibles
);
#define ITERATION_01 \
ENUM(_01)
#define ITERATION_02 \
ENUM(_02)
#define ITERATION_03 \
ENUM(_03)
#define ITERATION_04 \
ENUM(_04)
#define ITERATION_05 \
ENUM(_05)
#define ITERATION_06 \
ENUM(_06)
#define ITERATION_07 \
ENUM(_07)
BFonctionF
/* Definition d'une fonction neutre 'f0x(...)' a valeur dans [0,1]... */
DEFV(FonctionF,f0x(t))
DEFV(Argument,DEFV(Float,t));
Bblock
RETU(t);
Eblock
EFonctionF
BFonctionF
/* Definition d'une fonction neutre 'f0y(...)' a valeur dans [0,1]... */
DEFV(FonctionF,f0y(t))
DEFV(Argument,DEFV(Float,t));
Bblock
RETU(t);
Eblock
EFonctionF
BFonctionF
/* Definition d'une fonction neutre 'f0z(...)' a valeur dans [0,1]... */
DEFV(FonctionF,f0z(t))
DEFV(Argument,DEFV(Float,t));
Bblock
RETU(t);
Eblock
EFonctionF
BFonctionF
/* Definition de la premiere fonction ('f1x(...)') de la suite de fonctions recursives */
/* a valeur dans [0,1]... */
DEFV(Logical,INIT(remplacer_les_listes_de_substitution_par_des_listes_quelconques
,REMPLACER_LES_LISTES_DE_SUBSTITUTION_PAR_DES_LISTES_QUELCONQUES
)
);
/* Faut-il remplacer les listes de substitution par des listes queconques ('VRAI') ou pas */
/* ('FAUX') ? La valeur par defaut assure la compatibilite anterieure (introduit le */
/* 20220513105553)... */
DEFV(Logical,INIT(interpoler_les_listes_quelconques,INTERPOLER_LES_LISTES_QUELCONQUES));
/* Faut-il interpoler les listes queconques ('VRAI') ou pas ('FAUX') ? Voir a ce propos le */
/* commentaires 'v $xci/valeurs_TransformationPeano2D$I 20220513134353'. Ceci fut introduit */
/* le 20220513142523... */
#define MINIMUM_T \
COORDONNEE_BARYCENTRIQUE_MINIMALE
#define MAXIMUM_T \
COORDONNEE_BARYCENTRIQUE_MAXIMALE
DEFV(Local,DEFV(Float,INIT(minimum_t,MINIMUM_T)));
DEFV(Local,DEFV(Float,INIT(maximum_t,MAXIMUM_T)));
DEFV(Int,INIT(nombre_d_elements,NOMBRE_D_ELEMENTS));
#define X_IMPLICITE \
FZERO
#define Y_IMPLICITE \
FZERO
#define Z_IMPLICITE \
FZERO
gGENERATION_D_UN_FICHIER(fichier_LISTE_X,liste_initiale_des_X);
gGENERATION_D_UN_FICHIER(fichier_LISTE_Y,liste_initiale_des_Y);
gGENERATION_D_UN_FICHIER(fichier_LISTE_Z,liste_initiale_des_Z);
#define ELEMENT_DU_FICHIER_LISTE_X(index) \
gELEMENT_DU_FICHIER(liste_initiale_des_X,index)
#define ELEMENT_DU_FICHIER_LISTE_Y(index) \
gELEMENT_DU_FICHIER(liste_initiale_des_Y,index)
#define ELEMENT_DU_FICHIER_LISTE_Z(index) \
gELEMENT_DU_FICHIER(liste_initiale_des_Z,index)
/* Listes introduites le 20220513101131... */
DEFV(Local,DEFV(Logical,INIT(f1x_____generer_avec_une_liste_de_substitution,FAUX)));
DEFV(Local,DEFV(genere_Float,DTb1(f1x_____liste_flottante_substitution_de_definition,COULEURS)));
/* A priori, 'f1x(...)' n'utilise pas de liste de substitution mais peut le faire... */
DEFV(Local,DEFV(Logical,INIT(f1x_____interpoler_la_substitution_de_definition,f1x_____INTERPOLER_LA_SUBSTITUTION_DE_DEFINITION)));
DEFV(Local,DEFV(Logical,INIT(f1x_____interpoler_la_substitution_de_definition__lineairement
,f1x_____INTERPOLER_LA_SUBSTITUTION_DE_DEFINITION__LINEAIREMENT
)
)
);
DEFV(Local,DEFV(Float,INIT(f1x_____interpoler_la_substitution_de_definition__cubiquement__derivee_origine__
,f1x_____INTERPOLER_LA_SUBSTITUTION_DE_DEFINITION__CUBIQUEMENT__DERIVEE_ORIGINE__
)
)
);
DEFV(Local,DEFV(Float,INIT(f1x_____interpoler_la_substitution_de_definition__cubiquement__derivee_extremite
,f1x_____INTERPOLER_LA_SUBSTITUTION_DE_DEFINITION__CUBIQUEMENT__DERIVEE_EXTREMITE
)
)
);
/* Possible interpolation des listes de substitution... */
DEFV(FonctionF,f1x(t,ARGUMENT_FONCTION(f0x),ARGUMENT_FONCTION(f0y),ARGUMENT_FONCTION(f0z)))
DEFV(Argument,DEFV(Float,t));
DEFV(Argument,DEFV(Float,afPOINTEUR(f0x)));
DEFV(Argument,DEFV(Float,afPOINTEUR(f0y)));
DEFV(Argument,DEFV(Float,afPOINTEUR(f0z)));
Bblock
DEFV(Float,INIT(ValeurDeLaFonction,FLOT__UNDEF));
Test(EST_VRAI(f1x_____generer_avec_une_liste_de_substitution))
Bblock
INTERPOLATION_DE_LA_SUBSTITUTION(f1x_____liste_flottante_substitution_de_definition
,f1x_____interpoler_la_substitution_de_definition
,f1x_____interpoler_la_substitution_de_definition__lineairement
,f1x_____interpoler_la_substitution_de_definition__cubiquement__derivee_origine__
,f1x_____interpoler_la_substitution_de_definition__cubiquement__derivee_extremite
,ELEMENT_DU_FICHIER_LISTE_X
);
Eblock
ATes
Bblock
EGAL(ValeurDeLaFonction,MUL3(FQUATRE,t,COMP(t)));
Eblock
ETes
RETU(ValeurDeLaFonction);
Eblock
EFonctionF
BFonctionF
/* Definition de la premiere fonction ('f1y(...)') de la suite de fonctions recursives */
/* a valeur dans [0,1]... */
DEFV(Local,DEFV(Logical,INIT(f1y_____generer_avec_une_liste_de_substitution,FAUX)));
DEFV(Local,DEFV(genere_Float,DTb1(f1y_____liste_flottante_substitution_de_definition,COULEURS)));
/* A priori, 'f1y(...)' n'utilise pas de liste de substitution mais peut le faire... */
DEFV(Local,DEFV(Logical,INIT(f1y_____interpoler_la_substitution_de_definition,f1y_____INTERPOLER_LA_SUBSTITUTION_DE_DEFINITION)));
DEFV(Local,DEFV(Logical,INIT(f1y_____interpoler_la_substitution_de_definition__lineairement
,f1y_____INTERPOLER_LA_SUBSTITUTION_DE_DEFINITION__LINEAIREMENT
)
)
);
DEFV(Local,DEFV(Float,INIT(f1y_____interpoler_la_substitution_de_definition__cubiquement__derivee_origine__
,f1y_____INTERPOLER_LA_SUBSTITUTION_DE_DEFINITION__CUBIQUEMENT__DERIVEE_ORIGINE__
)
)
);
DEFV(Local,DEFV(Float,INIT(f1y_____interpoler_la_substitution_de_definition__cubiquement__derivee_extremite
,f1y_____INTERPOLER_LA_SUBSTITUTION_DE_DEFINITION__CUBIQUEMENT__DERIVEE_EXTREMITE
)
)
);
/* Possible interpolation des listes de substitution... */
DEFV(FonctionF,f1y(t,ARGUMENT_FONCTION(f0x),ARGUMENT_FONCTION(f0y),ARGUMENT_FONCTION(f0z)))
DEFV(Argument,DEFV(Float,t));
DEFV(Argument,DEFV(Float,afPOINTEUR(f0x)));
DEFV(Argument,DEFV(Float,afPOINTEUR(f0y)));
DEFV(Argument,DEFV(Float,afPOINTEUR(f0z)));
Bblock
DEFV(Float,INIT(ValeurDeLaFonction,FLOT__UNDEF));
Test(EST_VRAI(f1y_____generer_avec_une_liste_de_substitution))
Bblock
INTERPOLATION_DE_LA_SUBSTITUTION(f1y_____liste_flottante_substitution_de_definition
,f1y_____interpoler_la_substitution_de_definition
,f1y_____interpoler_la_substitution_de_definition__lineairement
,f1y_____interpoler_la_substitution_de_definition__cubiquement__derivee_origine__
,f1y_____interpoler_la_substitution_de_definition__cubiquement__derivee_extremite
,ELEMENT_DU_FICHIER_LISTE_Y
);
Eblock
ATes
Bblock
EGAL(ValeurDeLaFonction,MUL3(FQUATRE,t,COMP(t)));
Eblock
ETes
RETU(ValeurDeLaFonction);
Eblock
EFonctionF
BFonctionF
/* Definition de la premiere fonction ('f1z(...)') de la suite de fonctions recursives */
/* a valeur dans [0,1]... */
DEFV(Local,DEFV(Logical,INIT(f1z_____generer_avec_une_liste_de_substitution,FAUX)));
DEFV(Local,DEFV(genere_Float,DTb1(f1z_____liste_flottante_substitution_de_definition,COULEURS)));
/* A priori, 'f1z(...)' n'utilise pas de liste de substitution mais peut le faire... */
DEFV(Local,DEFV(Logical,INIT(f1z_____interpoler_la_substitution_de_definition,f1z_____INTERPOLER_LA_SUBSTITUTION_DE_DEFINITION)));
DEFV(Local,DEFV(Logical,INIT(f1z_____interpoler_la_substitution_de_definition__lineairement
,f1z_____INTERPOLER_LA_SUBSTITUTION_DE_DEFINITION__LINEAIREMENT
)
)
);
DEFV(Local,DEFV(Float,INIT(f1z_____interpoler_la_substitution_de_definition__cubiquement__derivee_origine__
,f1z_____INTERPOLER_LA_SUBSTITUTION_DE_DEFINITION__CUBIQUEMENT__DERIVEE_ORIGINE__
)
)
);
DEFV(Local,DEFV(Float,INIT(f1z_____interpoler_la_substitution_de_definition__cubiquement__derivee_extremite
,f1z_____INTERPOLER_LA_SUBSTITUTION_DE_DEFINITION__CUBIQUEMENT__DERIVEE_EXTREMITE
)
)
);
/* Possible interpolation des listes de substitution... */
DEFV(FonctionF,f1z(t,ARGUMENT_FONCTION(f0x),ARGUMENT_FONCTION(f0y),ARGUMENT_FONCTION(f0z)))
DEFV(Argument,DEFV(Float,t));
DEFV(Argument,DEFV(Float,afPOINTEUR(f0x)));
DEFV(Argument,DEFV(Float,afPOINTEUR(f0y)));
DEFV(Argument,DEFV(Float,afPOINTEUR(f0z)));
Bblock
DEFV(Float,INIT(ValeurDeLaFonction,FLOT__UNDEF));
Test(EST_VRAI(f1z_____generer_avec_une_liste_de_substitution))
Bblock
INTERPOLATION_DE_LA_SUBSTITUTION(f1z_____liste_flottante_substitution_de_definition
,f1z_____interpoler_la_substitution_de_definition
,f1z_____interpoler_la_substitution_de_definition__lineairement
,f1z_____interpoler_la_substitution_de_definition__cubiquement__derivee_origine__
,f1z_____interpoler_la_substitution_de_definition__cubiquement__derivee_extremite
,ELEMENT_DU_FICHIER_LISTE_Z
);
Eblock
ATes
Bblock
EGAL(ValeurDeLaFonction,NEUT(t));
Eblock
ETes
RETU(ValeurDeLaFonction);
Eblock
EFonctionF
#define _____Generer \
FU
#define NePasGenerer \
FZERO
#define NombreDIntervalles \
INTE(PUIX(DEUX,DIMENSION_DE_LA_COURBE))
#define t0 \
ADD2(minimum_t,GRO0(SOUS(maximum_t,minimum_t)/FLOT(NombreDIntervalles)))
#define t1 \
ADD2(minimum_t,GRO1(SOUS(maximum_t,minimum_t)/FLOT(NombreDIntervalles)))
#define t2 \
ADD2(minimum_t,GRO2(SOUS(maximum_t,minimum_t)/FLOT(NombreDIntervalles)))
#define t3 \
ADD2(minimum_t,GRO3(SOUS(maximum_t,minimum_t)/FLOT(NombreDIntervalles)))
#define t4 \
ADD2(minimum_t,GRO4(SOUS(maximum_t,minimum_t)/FLOT(NombreDIntervalles)))
#define t5 \
ADD2(minimum_t,GRO5(SOUS(maximum_t,minimum_t)/FLOT(NombreDIntervalles)))
#define t6 \
ADD2(minimum_t,GRO6(SOUS(maximum_t,minimum_t)/FLOT(NombreDIntervalles)))
#define t7 \
ADD2(minimum_t,GRO7(SOUS(maximum_t,minimum_t)/FLOT(NombreDIntervalles)))
#define t8 \
ADD2(minimum_t,GRO8(SOUS(maximum_t,minimum_t)/FLOT(NombreDIntervalles)))
#define ______0 \
FZERO
#define _____m1 \
NEGA(FU)
#define _____p1 \
NEUT(FU)
#define _____m2 \
NEGA(FDEUX)
#define _____p2 \
NEUT(FDEUX)
#define _____m3 \
NEGA(FTROIS)
#define _____p3 \
NEUT(FTROIS)
#define _____m4 \
NEGA(FQUATRE)
#define _____p4 \
NEUT(FQUATRE)
#define _____m5 \
NEGA(FCINQ)
#define _____p5 \
NEUT(FCINQ)
#define _____m6 \
NEGA(FSIX)
#define _____p6 \
NEUT(FSIX)
#define _____m7 \
NEGA(FSEPT)
#define _____p7 \
NEUT(FSEPT)
/* Afin d'ameliorer les tabulations ci-apres... */
DEFV(Local,DEFV(Float,INIT(ax00,_____p1)));
DEFV(Local,DEFV(Float,INIT(bx00,______0)));
DEFV(Local,DEFV(Float,INIT(tx00,______0)));
DEFV(Local,DEFV(Float,INIT(ay00,_____p1)));
DEFV(Local,DEFV(Float,INIT(by00,______0)));
DEFV(Local,DEFV(Float,INIT(ty00,______0)));
DEFV(Local,DEFV(Float,INIT(az00,_____p1)));
DEFV(Local,DEFV(Float,INIT(bz00,______0)));
DEFV(Local,DEFV(Float,INIT(tz00,______0)));
DEFV(Local,DEFV(Float,INIT(ax01,_____p1)));
DEFV(Local,DEFV(Float,INIT(bx01,______0)));
DEFV(Local,DEFV(Float,INIT(tx01,_____m1)));
DEFV(Local,DEFV(Float,INIT(ay01,_____p1)));
DEFV(Local,DEFV(Float,INIT(by01,_____p1)));
DEFV(Local,DEFV(Float,INIT(ty01,_____m1)));
DEFV(Local,DEFV(Float,INIT(az01,_____p1)));
DEFV(Local,DEFV(Float,INIT(bz01,______0)));
DEFV(Local,DEFV(Float,INIT(tz01,_____m1)));
DEFV(Local,DEFV(Float,INIT(ax02,_____p1)));
DEFV(Local,DEFV(Float,INIT(bx02,_____p1)));
DEFV(Local,DEFV(Float,INIT(tx02,_____m2)));
DEFV(Local,DEFV(Float,INIT(ay02,_____p1)));
DEFV(Local,DEFV(Float,INIT(by02,_____p1)));
DEFV(Local,DEFV(Float,INIT(ty02,_____m2)));
DEFV(Local,DEFV(Float,INIT(az02,_____p1)));
DEFV(Local,DEFV(Float,INIT(bz02,______0)));
DEFV(Local,DEFV(Float,INIT(tz02,_____m2)));
DEFV(Local,DEFV(Float,INIT(ax03,_____p1)));
DEFV(Local,DEFV(Float,INIT(bx03,_____p1)));
DEFV(Local,DEFV(Float,INIT(tx03,_____m3)));
DEFV(Local,DEFV(Float,INIT(ay03,_____m1)));
DEFV(Local,DEFV(Float,INIT(by03,_____p1)));
DEFV(Local,DEFV(Float,INIT(ty03,_____m3)));
DEFV(Local,DEFV(Float,INIT(az03,_____m1)));
DEFV(Local,DEFV(Float,INIT(bz03,_____p1)));
DEFV(Local,DEFV(Float,INIT(tz03,_____m3)));
DEFV(Local,DEFV(Float,INIT(ax04,_____m1)));
DEFV(Local,DEFV(Float,INIT(bx04,_____p2)));
DEFV(Local,DEFV(Float,INIT(tx04,_____m4)));
DEFV(Local,DEFV(Float,INIT(ay04,_____m1)));
DEFV(Local,DEFV(Float,INIT(by04,_____p1)));
DEFV(Local,DEFV(Float,INIT(ty04,_____m4)));
DEFV(Local,DEFV(Float,INIT(az04,_____p1)));
DEFV(Local,DEFV(Float,INIT(bz04,_____p1)));
DEFV(Local,DEFV(Float,INIT(tz04,_____m4)));
DEFV(Local,DEFV(Float,INIT(ax05,_____p1)));
DEFV(Local,DEFV(Float,INIT(bx05,_____p1)));
DEFV(Local,DEFV(Float,INIT(tx05,_____m5)));
DEFV(Local,DEFV(Float,INIT(ay05,_____p1)));
DEFV(Local,DEFV(Float,INIT(by05,_____p1)));
DEFV(Local,DEFV(Float,INIT(ty05,_____m5)));
DEFV(Local,DEFV(Float,INIT(az05,_____p1)));
DEFV(Local,DEFV(Float,INIT(bz05,_____p1)));
DEFV(Local,DEFV(Float,INIT(tz05,_____m5)));
DEFV(Local,DEFV(Float,INIT(ax06,_____m1)));
DEFV(Local,DEFV(Float,INIT(bx06,_____p1)));
DEFV(Local,DEFV(Float,INIT(tx06,_____m6)));
DEFV(Local,DEFV(Float,INIT(ay06,_____p1)));
DEFV(Local,DEFV(Float,INIT(by06,_____p1)));
DEFV(Local,DEFV(Float,INIT(ty06,_____m6)));
DEFV(Local,DEFV(Float,INIT(az06,_____m1)));
DEFV(Local,DEFV(Float,INIT(bz06,_____p2)));
DEFV(Local,DEFV(Float,INIT(tz06,_____m6)));
DEFV(Local,DEFV(Float,INIT(ax07,_____p1)));
DEFV(Local,DEFV(Float,INIT(bx07,______0)));
DEFV(Local,DEFV(Float,INIT(tx07,_____m7)));
DEFV(Local,DEFV(Float,INIT(ay07,_____m1)));
DEFV(Local,DEFV(Float,INIT(by07,_____p1)));
DEFV(Local,DEFV(Float,INIT(ty07,_____m7)));
DEFV(Local,DEFV(Float,INIT(az07,_____m1)));
DEFV(Local,DEFV(Float,INIT(bz07,_____p2)));
DEFV(Local,DEFV(Float,INIT(tz07,_____m7)));
DEFV(Local,DEFV(Float,INIT(diviseur,FDEUX)));
Denumer09(INIS(__01,UN)
,__02
,__03
,__04
,__05
,__06
,__07
,__08
,__09
,ListeDesSegmentsPossibles
);
#define SEGMENT_01 \
ENUM(__01)
#define SEGMENT_02 \
ENUM(__02)
#define SEGMENT_03 \
ENUM(__03)
#define SEGMENT_04 \
ENUM(__04)
#define SEGMENT_05 \
ENUM(__05)
#define SEGMENT_06 \
ENUM(__06)
#define SEGMENT_07 \
ENUM(__07)
#define SEGMENT_08 \
ENUM(__08)
#define SEGMENT_INEXISTANT \
ENUM(__09)
/* Afin de simplifier la gestion des 8 segments (introduit le 20220426114741)... */
#define CHOIX_D_UN_SEGMENT(segment,valeur) \
Ca1e(segment) \
Bblock \
EGAL(ValeurDeLaFonction,valeur); \
Eblock \
ECa1
#define APPEL_RECURSIF(a,F2,translation,F1x,F1y,F1z,b) \
AXPB(a,F2(AXPB(NombreDIntervalles,t,translation),&F1x,&F1y,&F1z),b) \
/* Introduit le 20220426104524 pour simplifier... */
#define GENERE_fnx_fny_fnz(nom \
,F2x,F2y,F2z \
,F1x,F1y,F1z \
,GenX,GenY,GenZ \
,ax00,bx00,tx00,ay00,by00,ty00,az00,bz00,tz00 \
,ax01,bx01,tx01,ay01,by01,ty01,az01,bz01,tz01 \
,ax02,bx02,tx02,ay02,by02,ty02,az02,bz02,tz02 \
,ax03,bx03,tx03,ay03,by03,ty03,az03,bz03,tz03 \
,ax04,bx04,tx04,ay04,by04,ty04,az04,bz04,tz04 \
,ax05,bx05,tx05,ay05,by05,ty05,az05,bz05,tz05 \
,ax06,bx06,tx06,ay06,by06,ty06,az06,bz06,tz06 \
,ax07,bx07,tx07,ay07,by07,ty07,az07,bz07,tz07 \
) \
/* A priori les arguments {ax00,tx00,...,tz03,bz03} ne servent a rien car ils possedent */ \
/* la meme valeur lors de tous les appels a 'GENERE_fnx_fny_fnz(...)', mais on ne sait */ \
/* jamais : plus tard... */ \
BFonctionF \
DEFV(FonctionF,nom(t,ARGUMENT_FONCTION(F2x),ARGUMENT_FONCTION(F2y),ARGUMENT_FONCTION(F2z))) \
DEFV(Argument,DEFV(Float,t)); \
DEFV(Argument,DEFV(Float,afPOINTEUR(F2x))); \
DEFV(Argument,DEFV(Float,afPOINTEUR(F2y))); \
DEFV(Argument,DEFV(Float,afPOINTEUR(F2z))); \
Bblock \
DEFV(Float,INIT(ValeurDeLaFonction,FLOT__UNDEF)); \
DEFV(Int,INIT(NumeroDu_segment \
,CON08(IFINff(t,t0,t1),SEGMENT_01 \
,IFINff(t,t1,t2),SEGMENT_02 \
,IFINff(t,t2,t3),SEGMENT_03 \
,IFINff(t,t3,t4),SEGMENT_04 \
,IFINff(t,t4,t5),SEGMENT_05 \
,IFINff(t,t5,t6),SEGMENT_06 \
,IFINff(t,t6,t7),SEGMENT_07 \
,IFINff(t,t7,t8),SEGMENT_08 \
,SEGMENT_INEXISTANT \
) \
) \
); \
/* Introduit le 20220426115352 afin de simplifier ce qui suit... */ \
\
Choi(NumeroDu_segment) \
Bblock \
CHOIX_D_UN_SEGMENT(SEGMENT_01 \
,LIZ3(GenX,APPEL_RECURSIF(ax00,F2x,tx00,F1x,F1y,F1z,bx00) \
,GenY,APPEL_RECURSIF(ay00,F2z,ty00,F1x,F1y,F1z,by00) \
,GenZ,APPEL_RECURSIF(az00,F2y,tz00,F1x,F1y,F1z,bz00) \
) \
); \
/* Cas du segment [t0,t1] : transformation 1. */ \
CHOIX_D_UN_SEGMENT(SEGMENT_02 \
,LIZ3(GenX,APPEL_RECURSIF(ax01,F2z,tx01,F1x,F1y,F1z,bx01) \
,GenY,APPEL_RECURSIF(ay01,F2y,ty01,F1x,F1y,F1z,by01) \
,GenZ,APPEL_RECURSIF(az01,F2x,tz01,F1x,F1y,F1z,bz01) \
) \
); \
/* Cas du segment [t1,t2] : transformation 2. */ \
CHOIX_D_UN_SEGMENT(SEGMENT_03 \
,LIZ3(GenX,APPEL_RECURSIF(ax02,F2x,tx02,F1x,F1y,F1z,bx02) \
,GenY,APPEL_RECURSIF(ay02,F2y,ty02,F1x,F1y,F1z,by02) \
,GenZ,APPEL_RECURSIF(az02,F2z,tz02,F1x,F1y,F1z,bz02) \
) \
); \
/* Cas du segment [t2,t3] : transformation 3. */ \
CHOIX_D_UN_SEGMENT(SEGMENT_04 \
,LIZ3(GenX,APPEL_RECURSIF(ax03,F2z,tx03,F1x,F1y,F1z,bx03) \
,GenY,APPEL_RECURSIF(ay03,F2x,ty03,F1x,F1y,F1z,by03) \
,GenZ,APPEL_RECURSIF(az03,F2y,tz03,F1x,F1y,F1z,bz03) \
) \
); \
/* Cas du segment [t3,t4] : transformation 4. */ \
CHOIX_D_UN_SEGMENT(SEGMENT_05 \
,LIZ3(GenX,APPEL_RECURSIF(ax04,F2z,tx04,F1x,F1y,F1z,bx04) \
,GenY,APPEL_RECURSIF(ay04,F2x,ty04,F1x,F1y,F1z,by04) \
,GenZ,APPEL_RECURSIF(az04,F2y,tz04,F1x,F1y,F1z,bz04) \
) \
); \
/* Cas du segment [t4,t5] : transformation 5. */ \
CHOIX_D_UN_SEGMENT(SEGMENT_06 \
,LIZ3(GenX,APPEL_RECURSIF(ax05,F2x,tx05,F1x,F1y,F1z,bx05) \
,GenY,APPEL_RECURSIF(ay05,F2y,ty05,F1x,F1y,F1z,by05) \
,GenZ,APPEL_RECURSIF(az05,F2z,tz05,F1x,F1y,F1z,bz05) \
) \
); \
/* Cas du segment [t5,t6] : transformation 6. */ \
CHOIX_D_UN_SEGMENT(SEGMENT_07 \
,LIZ3(GenX,APPEL_RECURSIF(ax06,F2z,tx06,F1x,F1y,F1z,bx06) \
,GenY,APPEL_RECURSIF(ay06,F2y,ty06,F1x,F1y,F1z,by06) \
,GenZ,APPEL_RECURSIF(az06,F2x,tz06,F1x,F1y,F1z,bz06) \
) \
); \
/* Cas du segment [t6,t7] : transformation 7. */ \
CHOIX_D_UN_SEGMENT(SEGMENT_08 \
,LIZ3(GenX,APPEL_RECURSIF(ax07,F2x,tx07,F1x,F1y,F1z,bx07) \
,GenY,APPEL_RECURSIF(ay07,F2z,ty07,F1x,F1y,F1z,by07) \
,GenZ,APPEL_RECURSIF(az07,F2y,tz07,F1x,F1y,F1z,bz07) \
) \
); \
/* Cas du segment [t7,t8] : transformation 8. */ \
Defo \
Bblock \
PRINT_ERREUR("le parametre 'T' est hors limite"); \
CAL1(Prer3("(il vaut %f alors qu'il devrait etre dans [%f,%f])\n" \
,t \
,t1,t8 \
) \
); \
Eblock \
EDef \
Eblock \
ECho \
\
RETU(DIVI(ValeurDeLaFonction,diviseur)); \
Eblock \
EFonctionF
GENERE_fnx_fny_fnz(f2x
,f1x,f1y,f1z
,f0x,f0y,f0z
,_____Generer,NePasGenerer,NePasGenerer
,ax00,bx00,tx00,ay00,by00,ty00,az00,bz00,tz00
,ax01,bx01,tx01,ay01,by01,ty01,az01,bz01,tz01
,ax02,bx02,tx02,ay02,by02,ty02,az02,bz02,tz02
,ax03,bx03,tx03,ay03,by03,ty03,az03,bz03,tz03
,ax04,bx04,tx04,ay04,by04,ty04,az04,bz04,tz04
,ax05,bx05,tx05,ay05,by05,ty05,az05,bz05,tz05
,ax06,bx06,tx06,ay06,by06,ty06,az06,bz06,tz06
,ax07,bx07,tx07,ay07,by07,ty07,az07,bz07,tz07
);
GENERE_fnx_fny_fnz(f2y
,f1x,f1y,f1z
,f0x,f0y,f0z
,NePasGenerer,_____Generer,NePasGenerer
,ax00,bx00,tx00,ay00,by00,ty00,az00,bz00,tz00
,ax01,bx01,tx01,ay01,by01,ty01,az01,bz01,tz01
,ax02,bx02,tx02,ay02,by02,ty02,az02,bz02,tz02
,ax03,bx03,tx03,ay03,by03,ty03,az03,bz03,tz03
,ax04,bx04,tx04,ay04,by04,ty04,az04,bz04,tz04
,ax05,bx05,tx05,ay05,by05,ty05,az05,bz05,tz05
,ax06,bx06,tx06,ay06,by06,ty06,az06,bz06,tz06
,ax07,bx07,tx07,ay07,by07,ty07,az07,bz07,tz07
);
GENERE_fnx_fny_fnz(f2z
,f1x,f1y,f1z
,f0x,f0y,f0z
,NePasGenerer,NePasGenerer,_____Generer
,ax00,bx00,tx00,ay00,by00,ty00,az00,bz00,tz00
,ax01,bx01,tx01,ay01,by01,ty01,az01,bz01,tz01
,ax02,bx02,tx02,ay02,by02,ty02,az02,bz02,tz02
,ax03,bx03,tx03,ay03,by03,ty03,az03,bz03,tz03
,ax04,bx04,tx04,ay04,by04,ty04,az04,bz04,tz04
,ax05,bx05,tx05,ay05,by05,ty05,az05,bz05,tz05
,ax06,bx06,tx06,ay06,by06,ty06,az06,bz06,tz06
,ax07,bx07,tx07,ay07,by07,ty07,az07,bz07,tz07
);
/* Definition des fonctions {f2x(...),f2y(...),f2z(...)} de la suite de fonctions recursives */
/* a valeur dans [0,1]... */
GENERE_fnx_fny_fnz(f3x
,f2x,f2y,f2z
,f1x,f1y,f1z
,_____Generer,NePasGenerer,NePasGenerer
,ax00,bx00,tx00,ay00,by00,ty00,az00,bz00,tz00
,ax01,bx01,tx01,ay01,by01,ty01,az01,bz01,tz01
,ax02,bx02,tx02,ay02,by02,ty02,az02,bz02,tz02
,ax03,bx03,tx03,ay03,by03,ty03,az03,bz03,tz03
,ax04,bx04,tx04,ay04,by04,ty04,az04,bz04,tz04
,ax05,bx05,tx05,ay05,by05,ty05,az05,bz05,tz05
,ax06,bx06,tx06,ay06,by06,ty06,az06,bz06,tz06
,ax07,bx07,tx07,ay07,by07,ty07,az07,bz07,tz07
);
GENERE_fnx_fny_fnz(f3y
,f2x,f2y,f2z
,f1x,f1y,f1z
,NePasGenerer,_____Generer,NePasGenerer
,ax00,bx00,tx00,ay00,by00,ty00,az00,bz00,tz00
,ax01,bx01,tx01,ay01,by01,ty01,az01,bz01,tz01
,ax02,bx02,tx02,ay02,by02,ty02,az02,bz02,tz02
,ax03,bx03,tx03,ay03,by03,ty03,az03,bz03,tz03
,ax04,bx04,tx04,ay04,by04,ty04,az04,bz04,tz04
,ax05,bx05,tx05,ay05,by05,ty05,az05,bz05,tz05
,ax06,bx06,tx06,ay06,by06,ty06,az06,bz06,tz06
,ax07,bx07,tx07,ay07,by07,ty07,az07,bz07,tz07
);
GENERE_fnx_fny_fnz(f3z
,f2x,f2y,f2z
,f1x,f1y,f1z
,NePasGenerer,NePasGenerer,_____Generer
,ax00,bx00,tx00,ay00,by00,ty00,az00,bz00,tz00
,ax01,bx01,tx01,ay01,by01,ty01,az01,bz01,tz01
,ax02,bx02,tx02,ay02,by02,ty02,az02,bz02,tz02
,ax03,bx03,tx03,ay03,by03,ty03,az03,bz03,tz03
,ax04,bx04,tx04,ay04,by04,ty04,az04,bz04,tz04
,ax05,bx05,tx05,ay05,by05,ty05,az05,bz05,tz05
,ax06,bx06,tx06,ay06,by06,ty06,az06,bz06,tz06
,ax07,bx07,tx07,ay07,by07,ty07,az07,bz07,tz07
);
/* Definition des fonctions {f3x(...),f3y(...),f3z(...)} de la suite de fonctions recursives */
/* a valeur dans [0,1]... */
GENERE_fnx_fny_fnz(f4x
,f3x,f3y,f3z
,f2x,f2y,f2z
,_____Generer,NePasGenerer,NePasGenerer
,ax00,bx00,tx00,ay00,by00,ty00,az00,bz00,tz00
,ax01,bx01,tx01,ay01,by01,ty01,az01,bz01,tz01
,ax02,bx02,tx02,ay02,by02,ty02,az02,bz02,tz02
,ax03,bx03,tx03,ay03,by03,ty03,az03,bz03,tz03
,ax04,bx04,tx04,ay04,by04,ty04,az04,bz04,tz04
,ax05,bx05,tx05,ay05,by05,ty05,az05,bz05,tz05
,ax06,bx06,tx06,ay06,by06,ty06,az06,bz06,tz06
,ax07,bx07,tx07,ay07,by07,ty07,az07,bz07,tz07
);
GENERE_fnx_fny_fnz(f4y
,f3x,f3y,f3z
,f2x,f2y,f2z
,NePasGenerer,_____Generer,NePasGenerer
,ax00,bx00,tx00,ay00,by00,ty00,az00,bz00,tz00
,ax01,bx01,tx01,ay01,by01,ty01,az01,bz01,tz01
,ax02,bx02,tx02,ay02,by02,ty02,az02,bz02,tz02
,ax03,bx03,tx03,ay03,by03,ty03,az03,bz03,tz03
,ax04,bx04,tx04,ay04,by04,ty04,az04,bz04,tz04
,ax05,bx05,tx05,ay05,by05,ty05,az05,bz05,tz05
,ax06,bx06,tx06,ay06,by06,ty06,az06,bz06,tz06
,ax07,bx07,tx07,ay07,by07,ty07,az07,bz07,tz07
);
GENERE_fnx_fny_fnz(f4z
,f3x,f3y,f3z
,f2x,f2y,f2z
,NePasGenerer,NePasGenerer,_____Generer
,ax00,bx00,tx00,ay00,by00,ty00,az00,bz00,tz00
,ax01,bx01,tx01,ay01,by01,ty01,az01,bz01,tz01
,ax02,bx02,tx02,ay02,by02,ty02,az02,bz02,tz02
,ax03,bx03,tx03,ay03,by03,ty03,az03,bz03,tz03
,ax04,bx04,tx04,ay04,by04,ty04,az04,bz04,tz04
,ax05,bx05,tx05,ay05,by05,ty05,az05,bz05,tz05
,ax06,bx06,tx06,ay06,by06,ty06,az06,bz06,tz06
,ax07,bx07,tx07,ay07,by07,ty07,az07,bz07,tz07
);
/* Definition des fonctions {f4x(...),f4y(...),f4z(...)} de la suite de fonctions recursives */
/* a valeur dans [0,1]... */
GENERE_fnx_fny_fnz(f5x
,f4x,f4y,f4z
,f3x,f3y,f3z
,_____Generer,NePasGenerer,NePasGenerer
,ax00,bx00,tx00,ay00,by00,ty00,az00,bz00,tz00
,ax01,bx01,tx01,ay01,by01,ty01,az01,bz01,tz01
,ax02,bx02,tx02,ay02,by02,ty02,az02,bz02,tz02
,ax03,bx03,tx03,ay03,by03,ty03,az03,bz03,tz03
,ax04,bx04,tx04,ay04,by04,ty04,az04,bz04,tz04
,ax05,bx05,tx05,ay05,by05,ty05,az05,bz05,tz05
,ax06,bx06,tx06,ay06,by06,ty06,az06,bz06,tz06
,ax07,bx07,tx07,ay07,by07,ty07,az07,bz07,tz07
);
GENERE_fnx_fny_fnz(f5y
,f4x,f4y,f4z
,f3x,f3y,f3z
,NePasGenerer,_____Generer,NePasGenerer
,ax00,bx00,tx00,ay00,by00,ty00,az00,bz00,tz00
,ax01,bx01,tx01,ay01,by01,ty01,az01,bz01,tz01
,ax02,bx02,tx02,ay02,by02,ty02,az02,bz02,tz02
,ax03,bx03,tx03,ay03,by03,ty03,az03,bz03,tz03
,ax04,bx04,tx04,ay04,by04,ty04,az04,bz04,tz04
,ax05,bx05,tx05,ay05,by05,ty05,az05,bz05,tz05
,ax06,bx06,tx06,ay06,by06,ty06,az06,bz06,tz06
,ax07,bx07,tx07,ay07,by07,ty07,az07,bz07,tz07
);
GENERE_fnx_fny_fnz(f5z
,f4x,f4y,f4z
,f3x,f3y,f3z
,NePasGenerer,NePasGenerer,_____Generer
,ax00,bx00,tx00,ay00,by00,ty00,az00,bz00,tz00
,ax01,bx01,tx01,ay01,by01,ty01,az01,bz01,tz01
,ax02,bx02,tx02,ay02,by02,ty02,az02,bz02,tz02
,ax03,bx03,tx03,ay03,by03,ty03,az03,bz03,tz03
,ax04,bx04,tx04,ay04,by04,ty04,az04,bz04,tz04
,ax05,bx05,tx05,ay05,by05,ty05,az05,bz05,tz05
,ax06,bx06,tx06,ay06,by06,ty06,az06,bz06,tz06
,ax07,bx07,tx07,ay07,by07,ty07,az07,bz07,tz07
);
/* Definition des fonctions {f5x(...),f5y(...),f5z(...)} de la suite de fonctions recursives */
/* a valeur dans [0,1]... */
GENERE_fnx_fny_fnz(f6x
,f5x,f5y,f5z
,f4x,f4y,f4z
,_____Generer,NePasGenerer,NePasGenerer
,ax00,bx00,tx00,ay00,by00,ty00,az00,bz00,tz00
,ax01,bx01,tx01,ay01,by01,ty01,az01,bz01,tz01
,ax02,bx02,tx02,ay02,by02,ty02,az02,bz02,tz02
,ax03,bx03,tx03,ay03,by03,ty03,az03,bz03,tz03
,ax04,bx04,tx04,ay04,by04,ty04,az04,bz04,tz04
,ax05,bx05,tx05,ay05,by05,ty05,az05,bz05,tz05
,ax06,bx06,tx06,ay06,by06,ty06,az06,bz06,tz06
,ax07,bx07,tx07,ay07,by07,ty07,az07,bz07,tz07
);
GENERE_fnx_fny_fnz(f6y
,f5x,f5y,f5z
,f4x,f4y,f4z
,NePasGenerer,_____Generer,NePasGenerer
,ax00,bx00,tx00,ay00,by00,ty00,az00,bz00,tz00
,ax01,bx01,tx01,ay01,by01,ty01,az01,bz01,tz01
,ax02,bx02,tx02,ay02,by02,ty02,az02,bz02,tz02
,ax03,bx03,tx03,ay03,by03,ty03,az03,bz03,tz03
,ax04,bx04,tx04,ay04,by04,ty04,az04,bz04,tz04
,ax05,bx05,tx05,ay05,by05,ty05,az05,bz05,tz05
,ax06,bx06,tx06,ay06,by06,ty06,az06,bz06,tz06
,ax07,bx07,tx07,ay07,by07,ty07,az07,bz07,tz07
);
GENERE_fnx_fny_fnz(f6z
,f5x,f5y,f5z
,f4x,f4y,f4z
,NePasGenerer,NePasGenerer,_____Generer
,ax00,bx00,tx00,ay00,by00,ty00,az00,bz00,tz00
,ax01,bx01,tx01,ay01,by01,ty01,az01,bz01,tz01
,ax02,bx02,tx02,ay02,by02,ty02,az02,bz02,tz02
,ax03,bx03,tx03,ay03,by03,ty03,az03,bz03,tz03
,ax04,bx04,tx04,ay04,by04,ty04,az04,bz04,tz04
,ax05,bx05,tx05,ay05,by05,ty05,az05,bz05,tz05
,ax06,bx06,tx06,ay06,by06,ty06,az06,bz06,tz06
,ax07,bx07,tx07,ay07,by07,ty07,az07,bz07,tz07
);
/* Definition des fonctions {f6x(...),f6y(...),f6z(...)} de la suite de fonctions recursives */
/* a valeur dans [0,1]... */
GENERE_fnx_fny_fnz(f7x
,f6x,f6y,f6z
,f5x,f5y,f5z
,_____Generer,NePasGenerer,NePasGenerer
,ax00,bx00,tx00,ay00,by00,ty00,az00,bz00,tz00
,ax01,bx01,tx01,ay01,by01,ty01,az01,bz01,tz01
,ax02,bx02,tx02,ay02,by02,ty02,az02,bz02,tz02
,ax03,bx03,tx03,ay03,by03,ty03,az03,bz03,tz03
,ax04,bx04,tx04,ay04,by04,ty04,az04,bz04,tz04
,ax05,bx05,tx05,ay05,by05,ty05,az05,bz05,tz05
,ax06,bx06,tx06,ay06,by06,ty06,az06,bz06,tz06
,ax07,bx07,tx07,ay07,by07,ty07,az07,bz07,tz07
);
GENERE_fnx_fny_fnz(f7y
,f6x,f6y,f6z
,f5x,f5y,f5z
,NePasGenerer,_____Generer,NePasGenerer
,ax00,bx00,tx00,ay00,by00,ty00,az00,bz00,tz00
,ax01,bx01,tx01,ay01,by01,ty01,az01,bz01,tz01
,ax02,bx02,tx02,ay02,by02,ty02,az02,bz02,tz02
,ax03,bx03,tx03,ay03,by03,ty03,az03,bz03,tz03
,ax04,bx04,tx04,ay04,by04,ty04,az04,bz04,tz04
,ax05,bx05,tx05,ay05,by05,ty05,az05,bz05,tz05
,ax06,bx06,tx06,ay06,by06,ty06,az06,bz06,tz06
,ax07,bx07,tx07,ay07,by07,ty07,az07,bz07,tz07
);
GENERE_fnx_fny_fnz(f7z
,f6x,f6y,f6z
,f5x,f5y,f5z
,NePasGenerer,NePasGenerer,_____Generer
,ax00,bx00,tx00,ay00,by00,ty00,az00,bz00,tz00
,ax01,bx01,tx01,ay01,by01,ty01,az01,bz01,tz01
,ax02,bx02,tx02,ay02,by02,ty02,az02,bz02,tz02
,ax03,bx03,tx03,ay03,by03,ty03,az03,bz03,tz03
,ax04,bx04,tx04,ay04,by04,ty04,az04,bz04,tz04
,ax05,bx05,tx05,ay05,by05,ty05,az05,bz05,tz05
,ax06,bx06,tx06,ay06,by06,ty06,az06,bz06,tz06
,ax07,bx07,tx07,ay07,by07,ty07,az07,bz07,tz07
);
/* Definition des fonctions {f7x(...),f7y(...),f7z(...)} de la suite de fonctions recursives */
/* a valeur dans [0,1]... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* T R A N S F O R M A T I O N A U T O - S I M I L A I R E D E H I L B E R T */
/* D A N S [ 0 , 1 ] x [ 0 , 1 ] x [ 0 , 1 ] : */
/* */
/*************************************************************************************************************************************/
BCommande(nombre_d_arguments,arguments)
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
DEFV(Logical,INIT(editer_la_definition_du_cube,EDITER_LA_DEFINITION_DU_CUBE));
DEFV(Logical,INIT(editer_la_definition_des_sous_cubes,EDITER_LA_DEFINITION_DES_SOUS_CUBES));
/* Faut-il editer la definition du cube ('VRAI') ou pas ('FAUX') ? L'edition de la */
/* definition des 8 sous-cubes a ete introduite le 20220519182554.. */
DEFV(CHAR,INIC(POINTERc(f1x_____nom_paletteA),NOM_PIPE));
DEFV(CHAR,INIT(POINTERc(f1x_____nom_de_la_substitution_de_definition),f1x_____NOM_DE_LA_SUBSTITUTION_DE_DEFINITION));
DEFV(Int,INIT(f1x_____substitution_courante_de_definition,f1x_____SUBSTITUTION_COURANTE_DE_DEFINITION));
DEFV(Logical,INIT(f1x_____lissage_de_la_substitution_de_definition,f1x_____LISSAGE_DE_LA_SUBSTITUTION_DE_DEFINITION));
DEFV(Int,INIT(f1x_____nombre_de_passes_de_lissage_de_la_substitution_de_definition
,f1x_____NOMBRE_DE_PASSES_DE_LISSAGE_DE_LA_SUBSTITUTION_DE_DEFINITION
)
);
DEFV(Int,INIT(f1x_____pas_de_lissage_de_la_substitution_de_definition,f1x_____PAS_DE_LISSAGE_DE_LA_SUBSTITUTION_DE_DEFINITION));
DEFV(Float,INIT(f1x_____minimum_de_la_substitution_de_definition,f1x_____MINIMUM_DE_LA_SUBSTITUTION_DE_DEFINITION));
DEFV(Float,INIT(f1x_____maximum_de_la_substitution_de_definition,f1x_____MAXIMUM_DE_LA_SUBSTITUTION_DE_DEFINITION));
/* Definition de 'f1x(...)' via '$xiP' (inutilise par defaut...). */
/* */
/* Le 20220427092531, l'interpolation des listes de substitution est passee de 'FAUX' */
/* a 'VRAI' par defaut et ce contrairement a 'v $xci/valeurs_TransformationPeano2D$K' */
/* qui reste a 'FAUX' pour des raisons de compatibilite anterieure... */
DEFV(CHAR,INIC(POINTERc(f1y_____nom_paletteA),NOM_PIPE));
DEFV(CHAR,INIT(POINTERc(f1y_____nom_de_la_substitution_de_definition),f1y_____NOM_DE_LA_SUBSTITUTION_DE_DEFINITION));
DEFV(Int,INIT(f1y_____substitution_courante_de_definition,f1y_____SUBSTITUTION_COURANTE_DE_DEFINITION));
DEFV(Logical,INIT(f1y_____lissage_de_la_substitution_de_definition,f1y_____LISSAGE_DE_LA_SUBSTITUTION_DE_DEFINITION));
DEFV(Int,INIT(f1y_____nombre_de_passes_de_lissage_de_la_substitution_de_definition
,f1y_____NOMBRE_DE_PASSES_DE_LISSAGE_DE_LA_SUBSTITUTION_DE_DEFINITION
)
);
DEFV(Int,INIT(f1y_____pas_de_lissage_de_la_substitution_de_definition,f1y_____PAS_DE_LISSAGE_DE_LA_SUBSTITUTION_DE_DEFINITION));
DEFV(Float,INIT(f1y_____minimum_de_la_substitution_de_definition,f1y_____MINIMUM_DE_LA_SUBSTITUTION_DE_DEFINITION));
DEFV(Float,INIT(f1y_____maximum_de_la_substitution_de_definition,f1y_____MAXIMUM_DE_LA_SUBSTITUTION_DE_DEFINITION));
/* Definition de 'f1y(...)' via '$xiP' (inutilise par defaut...). */
/* */
/* Le 20220427092531, l'interpolation des listes de substitution est passee de 'FAUX' */
/* a 'VRAI' par defaut et ce contrairement a 'v $xci/valeurs_TransformationPeano2D$K' */
/* qui reste a 'FAUX' pour des raisons de compatibilite anterieure... */
DEFV(CHAR,INIC(POINTERc(f1z_____nom_paletteA),NOM_PIPE));
DEFV(CHAR,INIT(POINTERc(f1z_____nom_de_la_substitution_de_definition),f1z_____NOM_DE_LA_SUBSTITUTION_DE_DEFINITION));
DEFV(Int,INIT(f1z_____substitution_courante_de_definition,f1z_____SUBSTITUTION_COURANTE_DE_DEFINITION));
DEFV(Logical,INIT(f1z_____lissage_de_la_substitution_de_definition,f1z_____LISSAGE_DE_LA_SUBSTITUTION_DE_DEFINITION));
DEFV(Int,INIT(f1z_____nombre_de_passes_de_lissage_de_la_substitution_de_definition
,f1z_____NOMBRE_DE_PASSES_DE_LISSAGE_DE_LA_SUBSTITUTION_DE_DEFINITION
)
);
DEFV(Int,INIT(f1z_____pas_de_lissage_de_la_substitution_de_definition,f1z_____PAS_DE_LISSAGE_DE_LA_SUBSTITUTION_DE_DEFINITION));
DEFV(Float,INIT(f1z_____minimum_de_la_substitution_de_definition,f1z_____MINIMUM_DE_LA_SUBSTITUTION_DE_DEFINITION));
DEFV(Float,INIT(f1z_____maximum_de_la_substitution_de_definition,f1z_____MAXIMUM_DE_LA_SUBSTITUTION_DE_DEFINITION));
/* Definition de 'f1z(...)' via '$xiP' (inutilise par defaut...). */
/* */
/* Le 20220427092531, l'interpolation des listes de substitution est passee de 'FAUX' */
/* a 'VRAI' par defaut et ce contrairement a 'v $xci/valeurs_TransformationPeano2D$K' */
/* qui reste a 'FAUX' pour des raisons de compatibilite anterieure... */
DEFV(Logical,INIT(chainer_les_points,CHAINER_LES_POINTS));
/* Faut-il chainer les points ('VRAI') ou pas ('FAUX') ? */
DEFV(Logical,INIT(calculer_une_seule_iteration,CALCULER_UNE_SEULE_ITERATION));
DEFV(Int,INIT(numero_de_l_iteration_unique,NUMERO_DE_L_ITERATION_UNIQUE));
/* Choix du mode "une" ou "plusieurs iterations"... */
DEFV(Logical,INIT(editer_iteration_01,EDITER_ITERATION_01));
DEFV(Logical,INIT(editer_iteration_02,EDITER_ITERATION_02));
DEFV(Logical,INIT(editer_iteration_03,EDITER_ITERATION_03));
DEFV(Logical,INIT(editer_iteration_04,EDITER_ITERATION_04));
DEFV(Logical,INIT(editer_iteration_05,EDITER_ITERATION_05));
DEFV(Logical,INIT(editer_iteration_06,EDITER_ITERATION_06));
DEFV(Logical,INIT(editer_iteration_07,EDITER_ITERATION_07));
/* Choix des iterations a editer... */
DEFV(Float,INIT(pas_de_l_iteration_01,PAS_DE_L_ITERATION_01));
DEFV(Float,INIT(pas_de_l_iteration_02,PAS_DE_L_ITERATION_02));
DEFV(Float,INIT(pas_de_l_iteration_03,PAS_DE_L_ITERATION_03));
DEFV(Float,INIT(pas_de_l_iteration_04,PAS_DE_L_ITERATION_04));
DEFV(Float,INIT(pas_de_l_iteration_05,PAS_DE_L_ITERATION_05));
DEFV(Float,INIT(pas_de_l_iteration_06,PAS_DE_L_ITERATION_06));
DEFV(Float,INIT(pas_de_l_iteration_07,PAS_DE_L_ITERATION_07));
/* Pas d'edition des iterations... */
DEFV(Float,INIT(permutation_XX,PERMUTATION_XX));
DEFV(Float,INIT(permutation_XY,PERMUTATION_XY));
DEFV(Float,INIT(permutation_XZ,PERMUTATION_XZ));
DEFV(Float,INIT(translation_X,TRANSLATION_X));
DEFV(Float,INIT(permutation_YX,PERMUTATION_YX));
DEFV(Float,INIT(permutation_YY,PERMUTATION_YY));
DEFV(Float,INIT(permutation_YZ,PERMUTATION_YZ));
DEFV(Float,INIT(translation_Y,TRANSLATION_Y));
DEFV(Float,INIT(permutation_ZX,PERMUTATION_ZX));
DEFV(Float,INIT(permutation_ZY,PERMUTATION_ZY));
DEFV(Float,INIT(permutation_ZZ,PERMUTATION_ZZ));
DEFV(Float,INIT(translation_Z,TRANSLATION_Z));
/* Le 20220428110814, les coordonnees 'X' et 'Z' ont ete permutees afin d'assurer la */
/* compatibilite des orientations des courbes ainsi generees avec des courbes anterieures */
/* (voir par exemple 'v $xiirv/PEAN.61' et 'v $xiirv/HILB.I2' respectivement...) generees */
/* par 'v $xci/valeurs_Hilbert3D$K' en particulier... */
DEFV(Float,INIT(ponderation_de_T,PONDERATION_DE_T));
DEFV(Float,INIT(ponderation_de_X,PONDERATION_DE_X));
DEFV(Float,INIT(ponderation_de_Y,PONDERATION_DE_Y));
DEFV(Float,INIT(ponderation_de_Z,PONDERATION_DE_Z));
/* Ponderations respectives de 'X', 'Y' et 'Z'. */
#include xci/valeurs.03.I"
/*..............................................................................................................................*/
GET_ARGUMENTSi(nombre_d_arguments
,BLOC(GET_ARGUMENT_L("listes_quelconques=""lq=",remplacer_les_listes_de_substitution_par_des_listes_quelconques);
GET_ARGUMENT_N("listes_substitution=""ls=",remplacer_les_listes_de_substitution_par_des_listes_quelconques);
/* Arguments introduits le 20220513105553... */
GET_ARGUMENT_L("interpoler_listes_quelconques=""ilq=",interpoler_les_listes_quelconques);
/* Argument introduit le 20220513142518... */
PROCESS_ARGUMENT_I("nombre_elements=""ne=",nombre_d_elements
,BLOC(VIDE;)
,BLOC(Bblock
PRINT_AVERTISSEMENT("'ne=' doit etre defini avant toute entree de fichiers");
Eblock
)
);
PROCESS_ARGUMENTS_DE_DEFINITION_DES_FICHIERS_01;
PROKESF_ARGUMENT_FICHIER("LISTE_X="
,fichier_LISTE_X
,liste_initiale_des_X
,X_IMPLICITE
,lTRANSFORMAT_0d
,iGENERATION_D_UN_FICHIER
);
PROKESF_ARGUMENT_FICHIER("LISTE_Y="
,fichier_LISTE_Y
,liste_initiale_des_Y
,Y_IMPLICITE
,lTRANSFORMAT_0d
,iGENERATION_D_UN_FICHIER
);
PROKESF_ARGUMENT_FICHIER("LISTE_Z="
,fichier_LISTE_Z
,liste_initiale_des_Z
,Z_IMPLICITE
,lTRANSFORMAT_0d
,iGENERATION_D_UN_FICHIER
);
GET_ARGUMENT_C("f1x_palette=""f1x_pA=""f1x_p=",f1x_____nom_paletteA);
GET_ARGUMENT_L("f1x_lissage=",f1x_____lissage_de_la_substitution_de_definition);
GET_ARGUMENT_I("f1x_passes=",f1x_____nombre_de_passes_de_lissage_de_la_substitution_de_definition);
GET_ARGUMENT_I("f1x_pl=""f1x_pas_lissage=",f1x_____pas_de_lissage_de_la_substitution_de_definition);
GET_ARGUMENT_C("f1x_substitution=""f1x_s=",f1x_____nom_de_la_substitution_de_definition);
GET_ARGUMENT_F("f1x_minimum=""f1x_m=",f1x_____minimum_de_la_substitution_de_definition);
GET_ARGUMENT_F("f1x_maximum=""f1x_M=",f1x_____maximum_de_la_substitution_de_definition);
GET_ARGUMENT_L("f1x_interpoler=""f1x_i=",f1x_____interpoler_la_substitution_de_definition);
GET_ARGUMENT_L("f1x_interpoler_lineairement=""f1x_il="
,f1x_____interpoler_la_substitution_de_definition__lineairement
);
GET_ARGUMENT_N("f1x_interpoler_cubiquement=""f1x_ic="
,f1x_____interpoler_la_substitution_de_definition__lineairement
);
GET_ARGUMENT_F("f1x_derivee_origine=""f1x_do="
,f1x_____interpoler_la_substitution_de_definition__cubiquement__derivee_origine__
);
GET_ARGUMENT_F("f1x_derivee_extremite=""f1x_de="
,f1x_____interpoler_la_substitution_de_definition__cubiquement__derivee_extremite
);
GET_ARGUMENT_C("f1y_palette=""f1y_pA=""f1y_p=",f1y_____nom_paletteA);
GET_ARGUMENT_L("f1y_lissage=",f1y_____lissage_de_la_substitution_de_definition);
GET_ARGUMENT_I("f1y_passes=",f1y_____nombre_de_passes_de_lissage_de_la_substitution_de_definition);
GET_ARGUMENT_I("f1y_pl=""f1y_pas_lissage=",f1y_____pas_de_lissage_de_la_substitution_de_definition);
GET_ARGUMENT_C("f1y_substitution=""f1y_s=",f1y_____nom_de_la_substitution_de_definition);
GET_ARGUMENT_F("f1y_minimum=""f1y_m=",f1y_____minimum_de_la_substitution_de_definition);
GET_ARGUMENT_F("f1y_maximum=""f1y_M=",f1y_____maximum_de_la_substitution_de_definition);
GET_ARGUMENT_L("f1y_interpoler=""f1y_i=",f1y_____interpoler_la_substitution_de_definition);
GET_ARGUMENT_L("f1y_interpoler_lineairement=""f1y_il="
,f1y_____interpoler_la_substitution_de_definition__lineairement
);
GET_ARGUMENT_N("f1y_interpoler_cubiquement=""f1y_ic="
,f1y_____interpoler_la_substitution_de_definition__lineairement
);
GET_ARGUMENT_F("f1y_derivee_origine=""f1y_do="
,f1y_____interpoler_la_substitution_de_definition__cubiquement__derivee_origine__
);
GET_ARGUMENT_F("f1y_derivee_extremite=""f1y_de="
,f1y_____interpoler_la_substitution_de_definition__cubiquement__derivee_extremite
);
GET_ARGUMENT_C("f1z_palette=""f1z_pA=""f1z_p=",f1z_____nom_paletteA);
GET_ARGUMENT_L("f1z_lissage=",f1z_____lissage_de_la_substitution_de_definition);
GET_ARGUMENT_I("f1z_passes=",f1z_____nombre_de_passes_de_lissage_de_la_substitution_de_definition);
GET_ARGUMENT_I("f1z_pl=""f1z_pas_lissage=",f1z_____pas_de_lissage_de_la_substitution_de_definition);
GET_ARGUMENT_C("f1z_substitution=""f1z_s=",f1z_____nom_de_la_substitution_de_definition);
GET_ARGUMENT_F("f1z_minimum=""f1z_m=",f1z_____minimum_de_la_substitution_de_definition);
GET_ARGUMENT_F("f1z_maximum=""f1z_M=",f1z_____maximum_de_la_substitution_de_definition);
GET_ARGUMENT_L("f1z_interpoler=""f1z_i=",f1z_____interpoler_la_substitution_de_definition);
GET_ARGUMENT_L("f1z_interpoler_lineairement=""f1z_il="
,f1z_____interpoler_la_substitution_de_definition__lineairement
);
GET_ARGUMENT_N("f1z_interpoler_cubiquement=""f1z_ic="
,f1z_____interpoler_la_substitution_de_definition__lineairement
);
GET_ARGUMENT_F("f1z_derivee_origine=""f1z_do="
,f1z_____interpoler_la_substitution_de_definition__cubiquement__derivee_origine__
);
GET_ARGUMENT_F("f1z_derivee_extremite=""f1z_de="
,f1z_____interpoler_la_substitution_de_definition__cubiquement__derivee_extremite
);
GET_ARGUMENT_L("definition_cube=""dc=",editer_la_definition_du_cube);
GET_ARGUMENT_L("definition_sous_cubes=""dsc=",editer_la_definition_des_sous_cubes);
/* Argument introduit le 20220519182608... */
GET_ARGUMENT_L("chainer_points=""cp=",chainer_les_points);
GET_ARGUMENT_F("min_t=""mt=",minimum_t);
GET_ARGUMENT_F("max_t=""Mt=",maximum_t);
GET_ARGUMENT_F("ax00=",ax00);
/* Je note le 20220522101354 que changer "ax00=+1" en "ax00=+0.5" est interessant (conserve */
/* la continuite et cree des zones vides...). */
GET_ARGUMENT_F("bx00=",bx00);
GET_ARGUMENT_F("tx00=",tx00);
GET_ARGUMENT_F("ay00=",ay00);
GET_ARGUMENT_F("by00=",by00);
GET_ARGUMENT_F("ty00=",ty00);
GET_ARGUMENT_F("az00=",az00);
GET_ARGUMENT_F("bz00=",bz00);
GET_ARGUMENT_F("tz00=",tz00);
GET_ARGUMENT_F("ax01=",ax01);
GET_ARGUMENT_F("bx01=",bx01);
GET_ARGUMENT_F("tx01=",tx01);
GET_ARGUMENT_F("ay01=",ay01);
GET_ARGUMENT_F("by01=",by01);
GET_ARGUMENT_F("ty01=",ty01);
GET_ARGUMENT_F("az01=",az01);
GET_ARGUMENT_F("bz01=",bz01);
GET_ARGUMENT_F("tz01=",tz01);
GET_ARGUMENT_F("ax02=",ax02);
GET_ARGUMENT_F("bx02=",bx02);
GET_ARGUMENT_F("tx02=",tx02);
GET_ARGUMENT_F("ay02=",ay02);
GET_ARGUMENT_F("by02=",by02);
GET_ARGUMENT_F("ty02=",ty02);
GET_ARGUMENT_F("az02=",az02);
GET_ARGUMENT_F("bz02=",bz02);
GET_ARGUMENT_F("tz02=",tz02);
GET_ARGUMENT_F("ax03=",ax03);
/* Je note le 20220522101354 que changer "ax03=+1" en "ax03=+0.5" est interessant (conserve */
/* la continuite et cree des zones vides...). */
GET_ARGUMENT_F("bx03=",bx03);
GET_ARGUMENT_F("tx03=",tx03);
GET_ARGUMENT_F("ay03=",ay03);
GET_ARGUMENT_F("by03=",by03);
GET_ARGUMENT_F("ty03=",ty03);
GET_ARGUMENT_F("az03=",az03);
GET_ARGUMENT_F("bz03=",bz03);
GET_ARGUMENT_F("tz03=",tz03);
GET_ARGUMENT_F("ax04=",ax04);
GET_ARGUMENT_F("bx04=",bx04);
GET_ARGUMENT_F("tx04=",tx04);
GET_ARGUMENT_F("ay04=",ay04);
GET_ARGUMENT_F("by04=",by04);
GET_ARGUMENT_F("ty04=",ty04);
GET_ARGUMENT_F("az04=",az04);
GET_ARGUMENT_F("bz04=",bz04);
GET_ARGUMENT_F("tz04=",tz04);
GET_ARGUMENT_F("ax05=",ax05);
GET_ARGUMENT_F("bx05=",bx05);
GET_ARGUMENT_F("tx05=",tx05);
GET_ARGUMENT_F("ay05=",ay05);
GET_ARGUMENT_F("by05=",by05);
GET_ARGUMENT_F("ty05=",ty05);
GET_ARGUMENT_F("az05=",az05);
GET_ARGUMENT_F("bz05=",bz05);
GET_ARGUMENT_F("tz05=",tz05);
GET_ARGUMENT_F("ax06=",ax06);
GET_ARGUMENT_F("bx06=",bx06);
GET_ARGUMENT_F("tx06=",tx06);
GET_ARGUMENT_F("ay06=",ay06);
GET_ARGUMENT_F("by06=",by06);
GET_ARGUMENT_F("ty06=",ty06);
GET_ARGUMENT_F("az06=",az06);
GET_ARGUMENT_F("bz06=",bz06);
GET_ARGUMENT_F("tz06=",tz06);
GET_ARGUMENT_F("ax07=",ax07);
GET_ARGUMENT_F("bx07=",bx07);
GET_ARGUMENT_F("tx07=",tx07);
GET_ARGUMENT_F("ay07=",ay07);
GET_ARGUMENT_F("by07=",by07);
GET_ARGUMENT_F("ty07=",ty07);
GET_ARGUMENT_F("az07=",az07);
GET_ARGUMENT_F("bz07=",bz07);
GET_ARGUMENT_F("tz07=",tz07);
GET_ARGUMENT_F("diviseur=""d=",diviseur);
GET_ARGUMENT_L("une_iteration=""ui=",calculer_une_seule_iteration);
GET_ARGUMENT_I("numero_iteration=""ni=",numero_de_l_iteration_unique);
GET_ARGUMENT_L("iteration_01=""i01=",editer_iteration_01);
GET_ARGUMENT_L("iteration_02=""i02=",editer_iteration_02);
GET_ARGUMENT_L("iteration_03=""i03=",editer_iteration_03);
GET_ARGUMENT_L("iteration_04=""i04=",editer_iteration_04);
GET_ARGUMENT_L("iteration_05=""i05=",editer_iteration_05);
GET_ARGUMENT_L("iteration_06=""i06=",editer_iteration_06);
GET_ARGUMENT_L("iteration_07=""i07=",editer_iteration_07);
GET_ARGUMENT_F("pas_01=""p01=",pas_de_l_iteration_01);
GET_ARGUMENT_F("pas_02=""p02=",pas_de_l_iteration_02);
GET_ARGUMENT_F("pas_03=""p03=",pas_de_l_iteration_03);
GET_ARGUMENT_F("pas_04=""p04=",pas_de_l_iteration_04);
GET_ARGUMENT_F("pas_05=""p05=",pas_de_l_iteration_05);
GET_ARGUMENT_F("pas_06=""p06=",pas_de_l_iteration_06);
GET_ARGUMENT_F("pas_07=""p07=",pas_de_l_iteration_07);
GET_ARGUMENT_F("Pxx=""PXX=",permutation_XX);
GET_ARGUMENT_F("Pxy=""PXY=",permutation_XY);
GET_ARGUMENT_F("Pxz=""PXZ=",permutation_XZ);
GET_ARGUMENT_F("Tx=""TX=",translation_X);
GET_ARGUMENT_F("Pyx=""PYX=",permutation_YX);
GET_ARGUMENT_F("Pyy=""PYY=",permutation_YY);
GET_ARGUMENT_F("Pyz=""PYZ=",permutation_YZ);
GET_ARGUMENT_F("Ty=""TY=",translation_Y);
GET_ARGUMENT_F("Pzx=""PZX=",permutation_ZX);
GET_ARGUMENT_F("Pzy=""PZY=",permutation_ZY);
GET_ARGUMENT_F("Pzz=""PZZ=",permutation_ZZ);
GET_ARGUMENT_F("Tz=""TZ=",translation_Z);
/* Les options de permutation des coordonnees ont ete introduites le 20220428110814... */
GET_ARGUMENT_F("Pt=""PT=",ponderation_de_T);
GET_ARGUMENT_F("Px=""PX=",ponderation_de_X);
GET_ARGUMENT_F("Py=""PY=",ponderation_de_Y);
GET_ARGUMENT_F("Pz=""PZ=",ponderation_de_Z);
PROCESS_ARGUMENTS_DE_PARAMETRAGE_DE_LA_GENERATION_DE_SUITE_DE_VALEURS_1;
)
);
MISE_EN_PLACE_D_UNE_LISTE_DE_SUBSTITUTION(f1x_____nom_paletteA
,f1x_____nom_de_la_substitution_de_definition
,f1x_____substitution_courante_de_definition
,f1x_____liste_flottante_substitution_de_definition
,f1x_____lissage_de_la_substitution_de_definition
,f1x_____nombre_de_passes_de_lissage_de_la_substitution_de_definition
,f1x_____pas_de_lissage_de_la_substitution_de_definition
,f1x_____minimum_de_la_substitution_de_definition
,f1x_____maximum_de_la_substitution_de_definition
,f1x_____generer_avec_une_liste_de_substitution
);
MISE_EN_PLACE_D_UNE_LISTE_DE_SUBSTITUTION(f1y_____nom_paletteA
,f1y_____nom_de_la_substitution_de_definition
,f1y_____substitution_courante_de_definition
,f1y_____liste_flottante_substitution_de_definition
,f1y_____lissage_de_la_substitution_de_definition
,f1y_____nombre_de_passes_de_lissage_de_la_substitution_de_definition
,f1y_____pas_de_lissage_de_la_substitution_de_definition
,f1y_____minimum_de_la_substitution_de_definition
,f1y_____maximum_de_la_substitution_de_definition
,f1y_____generer_avec_une_liste_de_substitution
);
MISE_EN_PLACE_D_UNE_LISTE_DE_SUBSTITUTION(f1z_____nom_paletteA
,f1z_____nom_de_la_substitution_de_definition
,f1z_____substitution_courante_de_definition
,f1z_____liste_flottante_substitution_de_definition
,f1z_____lissage_de_la_substitution_de_definition
,f1z_____nombre_de_passes_de_lissage_de_la_substitution_de_definition
,f1z_____pas_de_lissage_de_la_substitution_de_definition
,f1z_____minimum_de_la_substitution_de_definition
,f1z_____maximum_de_la_substitution_de_definition
,f1z_____generer_avec_une_liste_de_substitution
);
Test(IL_FAUT(calculer_une_seule_iteration))
Bblock
EGAL(editer_iteration_01,FAUX);
EGAL(editer_iteration_02,FAUX);
EGAL(editer_iteration_03,FAUX);
EGAL(editer_iteration_04,FAUX);
EGAL(editer_iteration_05,FAUX);
EGAL(editer_iteration_06,FAUX);
EGAL(editer_iteration_07,FAUX);
Choi(numero_de_l_iteration_unique)
Bblock
PARAMETRAGE_DE_L_ITERATION_UNIQUE(ITERATION_01,editer_iteration_01,pas_de_l_iteration_01);
PARAMETRAGE_DE_L_ITERATION_UNIQUE(ITERATION_02,editer_iteration_02,pas_de_l_iteration_02);
PARAMETRAGE_DE_L_ITERATION_UNIQUE(ITERATION_03,editer_iteration_03,pas_de_l_iteration_03);
PARAMETRAGE_DE_L_ITERATION_UNIQUE(ITERATION_04,editer_iteration_04,pas_de_l_iteration_04);
PARAMETRAGE_DE_L_ITERATION_UNIQUE(ITERATION_05,editer_iteration_05,pas_de_l_iteration_05);
PARAMETRAGE_DE_L_ITERATION_UNIQUE(ITERATION_06,editer_iteration_06,pas_de_l_iteration_06);
PARAMETRAGE_DE_L_ITERATION_UNIQUE(ITERATION_07,editer_iteration_07,pas_de_l_iteration_07);
Defo
Bblock
PRINT_ERREUR("le numero d'iteration demande n'existe pas");
CAL1(Prer2("(l'iteration %d etait demandee et l'iteration %d est forcee)\n"
,numero_de_l_iteration_unique
,ITERATION_05
)
);
EGAL(editer_iteration_05,VRAI);
Eblock
EDef
Eblock
ECho
Eblock
ATes
Bblock
Eblock
ETes
begin_nouveau_block
Bblock
EDITION_EVENTUELLE_D_UNE_ITERATION(editer_iteration_01,f1x,f1y,f1z,f0x,f0y,f0z,pas_de_l_iteration_01);
EDITION_EVENTUELLE_D_UNE_ITERATION(editer_iteration_02,f2x,f2y,f2z,f1x,f1y,f1z,pas_de_l_iteration_02);
EDITION_EVENTUELLE_D_UNE_ITERATION(editer_iteration_03,f3x,f3y,f3z,f2x,f2y,f2z,pas_de_l_iteration_03);
EDITION_EVENTUELLE_D_UNE_ITERATION(editer_iteration_04,f4x,f4y,f4z,f3x,f3y,f3z,pas_de_l_iteration_04);
EDITION_EVENTUELLE_D_UNE_ITERATION(editer_iteration_05,f5x,f5y,f5z,f4x,f4y,f4z,pas_de_l_iteration_05);
EDITION_EVENTUELLE_D_UNE_ITERATION(editer_iteration_06,f6x,f6y,f6z,f5x,f5y,f5z,pas_de_l_iteration_06);
EDITION_EVENTUELLE_D_UNE_ITERATION(editer_iteration_07,f7x,f7y,f7z,f6x,f6y,f6z,pas_de_l_iteration_07);
Test(IL_FAUT(editer_la_definition_du_cube))
Bblock
Test(IL_FAUT(chainer_les_points))
Bblock
#include xci/valeurs_Hilbert3D.I"
/* Afin d'etre compatible avec 'v $xiirv/.PEAN.21.$U', il faut que le cube soit trace apres */
/* la trajectoire de 'T' et ce afin que ce cube semble etre derriere cette trajectoire... */
Eblock
ATes
Bblock
PRINT_ATTENTION("lors de l'edition de points isoles, la definition du cube ne peut etre editee");
Eblock
ETes
Eblock
ATes
Bblock
Eblock
ETes
Eblock
end_nouveau_block
RETU_Commande;
Eblock
ECommande