/*************************************************************************************************************************************/
/* */
/* I N T E R P O L A T I O N P A R D E S S P L I N E S E N T R E D E U X V A L E U R S : */
/* */
/* */
/* Definition : */
/* */
/* Cette commande genere une sequence */
/* de valeurs numeriques flottantes obtenues */
/* par interpolation par des splines entre */
/* deux valeurs donnees. On notera que */
/* l'interpolation lineaire est aussi disponible... */
/* */
/* */
/* Exemple : */
/* */
/* $xci/valeurs_inte$X cubique=FAUX p=1 d=128 vD=1 vA=1017 genere (1,9,17,...,1001,1009,1017), en notant */
/* que (d-p)=(128-1) divise (vA-vD)=(1017-1), et */
/* donc que (vA-vD) est un multiple de (d-p) si */
/* l'on travaille en nombres entiers ; dans ce */
/* cas, on aura donc la relation : */
/* */
/* vA = vD + k.(d-p) */
/* */
/* ou 'k' represente une constante entiere... */
/* */
/* */
/* Author of '$xci/valeurs_inte$K' : */
/* */
/* Jean-Francois COLONNA (LACTAMME, 1992??????????). */
/* */
/*************************************************************************************************************************************/
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* 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 INTERPOLER_PAR_DES_SPLINES_CUBIQUES \
VRAI \
/* Cet indicateur permet la selection entre une interpolation "cubique" ('VRAI') ou bien */ \
/* "lineaire" ('FAUX'). */
#define TRANSFORMER_LES_VALEURS_INTERPOLEES \
FAUX \
/* Cet indicateur permet la selection entre transformer les valeurs interpolees ('VRAI') ou */ \
/* bien les laisser en l'etat ('FAUX'). */
#define NOM_SUBSTITUTION \
"L_SUBSTITUTION_NEUTRE" \
/* Nom de la liste de substitution recherchee. ATTENTION, le 19990310151141, afin d'eviter */ \
/* les messages d'erreur de 'RECHERCHE_D_UNE_LISTE_DE_SUBSTITUTION(...)', eux-memes */ \
/* introduits le 19990302094348, il a ete decide de passer de la valeur par defaut */ \
/* 'NOM_UNDEF' pour 'nom_substitution' a une valeur existante ('L_SUBSTITUTION_NEUTRE'). */
#define SUBSTITUTION_COURANTE \
L_SUBSTITUTION_NEUTRE \
/* Designation de la liste de substitution courante ; la liste 'NEUTRE' */ \
/* etant choisie a priori... */
#define LISSAGE_DES_LISTES_DE_SUBSTITUTION \
FAUX \
/* Afin de savoir s'il faut lisser ('VRAI') ou pas ('FAUX') la liste de SUBSTITUTION */
/* courante lors de sa conversion... */
#define NOMBRE_DE_PASSES_DE_LISSAGE_DES_LISTES_DE_SUBSTITUTION \
UN \
/* Indique alors le nombre de passes de lissage ("plus on lisse, plus c'est lisse..."). */
#define PAS_DE_LISSAGE_DES_LISTES_DE_SUBSTITUTION \
PAS_COULEURS \
/* Pas des couleurs pour les fonctions 'nPREK(...)' et 'nSUCK(...)' lors du lissage. */
#define REPLIER_LES_NOMBRES_ENTIERS \
FAUX
#define MODULE_DE_REPLIEMENT_DES_NOMBRES_ENTIERS \
UN
/* Definition de l'eventuel repliement des nombres entiers ('IL_FAUT(des_nombres_entiers)'). */
/* Ceci fut introduit le 20120510093846 afin de permettre de generer des listes du type : */
/* */
/* {0,2,4,6,1,3,5,7} */
/* */
/* a la place de : */
/* */
/* {0,1,2,3,4,5,6,7} */
/* */
#include xci/sequence.01.I"
#define VALEUR_DE_DEPART \
FZERO
#define DERIVEE_DE_LA_VALEUR_DE_DEPART \
FZERO
/* Definition de la valeur de depart et de sa derivee. */
#define VALEUR_D_ARRIVEE \
FU
#define DERIVEE_DE_LA_VALEUR_D_ARRIVEE \
FZERO
/* Definition de la valeur d'arrivee et de sa derivee. */
#define N_EDITER_QU_UNE_SEULE_VALEUR \
FAUX
#define NUMERO_DE_LA_VALEUR_UNIQUE_A_EDITER \
MOYE(premiere_image,derniere_image)
/* Doit-on n'editer qu'une seule valeur et la quelle ('VRAI') ou toutes ('FAUX') ? Cette */
/* possibilite a ete introduite pour permettre d'interpoler simplement entre deux valeurs */
/* 'V1' et 'V2' ; Par exemple : */
/* */
/* $xci/valeurs_inte$X premiere=1 derniere=3 \ */
/* cubique=FAUX \ */
/* unique=VRAI numero=2 \ */
/* vD=V1 vA=V2 */
/* */
/* donnera la valeur moyenne de 'V1' et 'V2'... A titre d'exemple, on verra la generation */
/* de la sequence : */
/* */
/* xivPdf 7 1 / 001545_001672 */
/* */
#define EDITER_TOUTES_LES_VALEURS_SAUF_UNE \
FAUX
#define NUMERO_DE_LA_VALEUR_UNIQUE_A_NE_PAS_EDITER \
MOYE(premiere_image,derniere_image)
/* Doit-on editer toutes les valeurs sauf une et la quelle ('VRAI') ou toutes ('FAUX') ? */
/* Cette possibilite a ete introduite pour permettre de ne pas generer, par exemple, la */
/* premiere valeur. A titre d'exemple, on verra 'v $xrq/nucleon.L42$Z'. */
#include xci/valeurs.01.I"
#define S_IL_N_Y_A_QU_UNE_SEULE_IMAGE_UTILISER_LA_VALEUR_DE_DEPART \
VRAI \
/* Cet indicateur permet, lorsqu'il n'y a qu'une seule image ('premiere_image' et */ \
/* 'derniere_image' sont egaux), de choisir entre la valeur 'valeur_de_depart' ('VRAI') */ \
/* et 'valeur_d_arrivee' ('FAUX'). */
#define AMPLITUDE_ENTIERE \
TRPU(INTE(SOUS(valeur_d_arrivee,valeur_de_depart))) \
/* Constante utile pour les repliements de nombres entiers... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* M A C R O S U T I L E S : */
/* */
/*************************************************************************************************************************************/
#include xci/valeurs.02.I"
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* I N T E R P O L A T I O N P A R D E S S P L I N E S E N T R E D E U X V A L E U R S : */
/* */
/*************************************************************************************************************************************/
BCommande(nombre_d_arguments,arguments)
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
DEFV(Logical,INIT(interpoler_par_des_splines_cubiques,INTERPOLER_PAR_DES_SPLINES_CUBIQUES));
/* Cet indicateur permet la selection entre une interpolation "cubique" ('VRAI') ou bien */
/* "lineaire" ('FAUX'). */
DEFV(Logical,INIT(transformer_les_valeurs_interpolees,TRANSFORMER_LES_VALEURS_INTERPOLEES));
/* Cet indicateur permet la selection entre transformer les valeurs interpolees ('VRAI') ou */
/* bien les laisser en l'etat ('FAUX'). */
DEFV(Logical,INIT(lissage_des_listes_de_SUBSTITUTION,LISSAGE_DES_LISTES_DE_SUBSTITUTION));
/* Afin de savoir s'il faut lisser ('VRAI') ou pas ('FAUX') la liste de SUBSTITUTION */
/* courante lors de sa conversion... */
DEFV(Int,INIT(nombre_de_passes_de_lissage_des_listes_de_SUBSTITUTION,NOMBRE_DE_PASSES_DE_LISSAGE_DES_LISTES_DE_SUBSTITUTION));
/* Indique alors le nombre de passes de lissage ("plus on lisse, plus c'est lisse..."). */
DEFV(Int,INIT(pas_de_lissage_des_listes_de_SUBSTITUTION,PAS_DE_LISSAGE_DES_LISTES_DE_SUBSTITUTION));
/* Pas des couleurs pour les fonctions 'nPREK(...)' et 'nSUCK(...)' lors du lissage. */
DEFV(CHAR,INIT(POINTERc(nom_substitution),NOM_SUBSTITUTION));
/* Nom de la liste de substitution recherchee. */
DEFV(CHAR,INIC(POINTERc(nom_paletteA),NOM_PIPE));
/* Nom de la palette Argument a utiliser au cas ou la 'substitution_courante' serait */
/* 'L_SUBSTITUTION_ROUGE', 'L_SUBSTITUTION_VERTE' ou encore 'L_SUBSTITUTION_BLEUE'. */
DEFV(Int,INIT(substitution_courante,SUBSTITUTION_COURANTE));
/* A priori, on ne substitue pas... */
DEFV(genere_Float,DTb1(liste_flottante_approximee_de_substitution_courante,COULEURS));
/* Cette table contient la liste de SUBSTITUTION courante convertie en 'genere_Float' et */
/* mise dans [COORDONNEE_BARYCENTRIQUE_MINIMALE,COORDONNEE_BARYCENTRIQUE_MAXIMALE], puis */
/* eventuellement lissee par approximation. */
DEFV(Logical,INIT(replier_les_nombres_entiers,REPLIER_LES_NOMBRES_ENTIERS));
DEFV(Int,INIT(module_de_repliement_des_nombres_entiers,MODULE_DE_REPLIEMENT_DES_NOMBRES_ENTIERS));
/* Definition de l'eventuel repliement des nombres entiers ('IL_FAUT(des_nombres_entiers)'). */
/* Ceci fut introduit le 20120510093846 afin de permettre de generer des listes du type : */
/* */
/* {0,2,4,6,1,3,5,7} */
/* */
/* a la place de : */
/* */
/* {0,1,2,3,4,5,6,7} */
/* */
DEFV(Int,INIT(premiere_image,PREMIERE_IMAGE));
/* Numero de la premiere image, */
DEFV(Int,INIT(derniere_image,DERNIERE_IMAGE));
/* Numero de la derniere image. */
DEFV(Int,INIT(numero_d_image,UNDEF));
/* Numero de l'image courante. */
DEFV(Int,INIT(pas_des_images,PAS_DES_IMAGES));
/* Pas de passage d'un numero d'image a une autre. */
DEFV(Float,INIT(valeur_de_depart,VALEUR_DE_DEPART));
DEFV(Float,INIT(derivee_de_la_valeur_de_depart,DERIVEE_DE_LA_VALEUR_DE_DEPART));
/* Definition de la valeur de depart et de sa derivee. */
DEFV(Float,INIT(valeur_d_arrivee,VALEUR_D_ARRIVEE));
DEFV(Float,INIT(derivee_de_la_valeur_d_arrivee,DERIVEE_DE_LA_VALEUR_D_ARRIVEE));
/* Definition de la valeur d'arrivee et de sa derivee. */
#include xci/valeurs.03.I"
DEFV(Logical,INIT(n_editer_qu_une_seule_valeur,N_EDITER_QU_UNE_SEULE_VALEUR));
DEFV(Int,INIT(numero_de_la_valeur_unique_a_editer,NUMERO_DE_LA_VALEUR_UNIQUE_A_EDITER));
/* Doit-on n'editer qu'une seule valeur et la quelle ('VRAI') ou toutes ('FAUX') ? Cette */
/* possibilite a ete introduite pour permettre d'interpoler simplement entre deux valeurs */
/* 'V1' et 'V2' ; Par exemple : */
/* */
/* $xci/valeurs_inte$X premiere=1 derniere=3 \ */
/* cubique=FAUX \ */
/* unique=VRAI numero=2 \ */
/* vD=V1 vA=V2 */
/* */
/* donnera la valeur moyenne de 'V1' et 'V2'... A titre d'exemple, on verra la generation */
/* de la sequence : */
/* */
/* xivPdf 7 1 / 001545_001672 */
/* */
DEFV(Logical,INIT(editer_toutes_les_valeurs_sauf_une,EDITER_TOUTES_LES_VALEURS_SAUF_UNE));
DEFV(Int,INIT(numero_de_la_valeur_unique_a_ne_pas_editer,NUMERO_DE_LA_VALEUR_UNIQUE_A_NE_PAS_EDITER));
/* Doit-on editer toutes les valeurs sauf une et la quelle ('VRAI') ou toutes ('FAUX') ? */
/* Cette possibilite a ete introduite pour permettre de ne pas generer, par exemple, la */
/* premiere valeur. A titre d'exemple, on verra 'v $xrq/nucleon.L42$Z'. */
DEFV(Logical,INIT(s_il_n_y_a_qu_une_seule_image_utiliser_la_valeur_de_depart
,S_IL_N_Y_A_QU_UNE_SEULE_IMAGE_UTILISER_LA_VALEUR_DE_DEPART
)
);
/* Cet indicateur permet, lorsqu'il n'y a qu'une seule image ('premiere_image' et */
/* 'derniere_image' sont egaux), de choisir entre la valeur 'valeur_de_depart' ('VRAI') */
/* et 'valeur_d_arrivee' ('FAUX'). */
/*..............................................................................................................................*/
GET_ARGUMENTSi(nombre_d_arguments
,BLOC(GET_ARGUMENT_I("premiere=""p=""D=",premiere_image);
GET_ARGUMENT_I("derniere=""d=""A=",derniere_image);
GET_ARGUMENT_I("pas=",pas_des_images);
GET_ARGUMENT_L("cubique=",interpoler_par_des_splines_cubiques);
GET_ARGUMENT_N("lineaire=",interpoler_par_des_splines_cubiques);
GET_ARGUMENT_L("transformer=",transformer_les_valeurs_interpolees);
GET_ARGUMENT_L("lissage=",lissage_des_listes_de_SUBSTITUTION);
GET_ARGUMENT_I("passes=",nombre_de_passes_de_lissage_des_listes_de_SUBSTITUTION);
GET_ARGUMENT_I("pl=""pas_lissage=",pas_de_lissage_des_listes_de_SUBSTITUTION);
GET_ARGUMENT_C("substitution=""s=",nom_substitution);
GET_ARGUMENT_C("paletteA=""palette=""pA=",nom_paletteA);
GET_ARGUMENT_L("replier_nombres_entiers=""replier=""rne=",replier_les_nombres_entiers);
GET_ARGUMENT_I("module_repliement_nombres_entiers=""module=""mrne="
,module_de_repliement_des_nombres_entiers
);
/* Arguments introduits le 20120510093846... */
GET_ARGUMENT_L("utiliser_la_valeur_de_depart=",s_il_n_y_a_qu_une_seule_image_utiliser_la_valeur_de_depart);
GET_ARGUMENT_F("vd=""vD=",valeur_de_depart);
GET_ARGUMENT_F("dd=""dD=",derivee_de_la_valeur_de_depart);
GET_ARGUMENT_F("va=""vA=",valeur_d_arrivee);
GET_ARGUMENT_F("da=""dA=",derivee_de_la_valeur_d_arrivee);
PROCESS_ARGUMENTS_DE_PARAMETRAGE_DE_LA_GENERATION_DE_SUITE_DE_VALEURS_1;
/* Cette procedure fut introduite le 20061226185810... */
GET_ARGUMENT_L("modulo=",etre_modulo);
GET_ARGUMENT_F("origine=",origine_modulo);
GET_ARGUMENT_F("extremite=",extremite_modulo);
GET_ARGUMENT_L("unique=",n_editer_qu_une_seule_valeur);
GET_ARGUMENT_I("numero=",numero_de_la_valeur_unique_a_editer);
GET_ARGUMENT_L("Cunique=",editer_toutes_les_valeurs_sauf_une);
GET_ARGUMENT_I("Cnumero=",numero_de_la_valeur_unique_a_ne_pas_editer);
)
);
Test(IFET(IL_FAUT(replier_les_nombres_entiers)
,IL_NE_FAUT_PAS(des_nombres_entiers)
)
)
Bblock
PRINT_ATTENTION("le repliement des nombres ne peut avoir lieu que pour les nombres entiers");
Eblock
ATes
Bblock
Eblock
ETes
Test(IL_FAUT(transformer_les_valeurs_interpolees))
Bblock
Test(IFNE_chaine(nom_paletteA,NOM_PIPE))
Bblock
CALS(Iload_palette_de_couleurs(nom_paletteA,ESPACE_DE_COULEURS_RVB));
Eblock
ATes
Bblock
Eblock
ETes
Test(IFNE_chaine(nom_substitution,NOM_UNDEF))
Bblock
RECHERCHE_D_UNE_LISTE_DE_SUBSTITUTION(nom_substitution,substitution_courante,substitution_courante);
/* Tentative de recherche de la substitution demandee... */
Eblock
ATes
Bblock
Eblock
ETes
PUSH_SUBSTITUTION;
/* Sauvegarde de la SUBSTITUTION courante. */
SUBSTITUTION(substitution_courante);
/* Mise en place de la SUBSTITUTION demandee. */
PUSH_FILTRAGE;
/* Sauvegarde de l'etat courant du filtrage des niveaux. */
SET_FILTRAGE(ACTIF);
/* Et on active le filtrage puisque la fonction 'Nsubstitution(...)' va etre utilisee */
/* ci-apres dans 'CONVERSION_FLOTTANTE_D_UNE_LISTE_DE_SUBSTITUTION(...)'. */
CONVERSION_FLOTTANTE_D_UNE_LISTE_DE_SUBSTITUTION(liste_flottante_approximee_de_substitution_courante
,COORDONNEE_BARYCENTRIQUE_MINIMALE
,COORDONNEE_BARYCENTRIQUE_MAXIMALE
,lissage_des_listes_de_SUBSTITUTION
,nombre_de_passes_de_lissage_des_listes_de_SUBSTITUTION
,pas_de_lissage_des_listes_de_SUBSTITUTION
);
PULL_FILTRAGE;
PULL_SUBSTITUTION;
/* Et restauration des conditions initiales... */
Eblock
ATes
Bblock
Eblock
ETes
Test(IFLT(premiere_image,derniere_image))
/* ATTENTION : on ne peut ecrire : */
/* */
/* Test(IFLE(premiere_image,derniere_image)) */
/* */
/* a cause de 'iINTERPOLATION_...(...)' qui calcule 'derniere_image-premiere_image' */
/* ('v $xci/valeurs.02$I iTRANSFORMATION'). */
Bblock
Test(IFET(IL_FAUT(n_editer_qu_une_seule_valeur)
,IFEXff(numero_de_la_valeur_unique_a_editer,premiere_image,derniere_image)
)
)
Bblock
/* ATTENTION, si le parametre 'numero_de_la_valeur_unique_a_editer' n'a pas ete */
/* effectivement introduit par : */
/* */
/* numero=... */
/* */
/* il conserve sa valeur initiale, c'est-a-dire 'NUMERO_DE_LA_VALEUR_UNIQUE_A_EDITER' qui */
/* peut etre hors de [premiere_image,derniere_image] si l'un (ou les deux) de ces deux */
/* parametres a ete redefini(s)... */
PRINT_ERREUR("la seule valeur a editer n'est pas accessible, toutes les valeurs seront donc editees");
CAL1(Prer3(" %d E/ [%d,%d]\n",numero_de_la_valeur_unique_a_editer,premiere_image,derniere_image));
EGAL(n_editer_qu_une_seule_valeur,N_EDITER_QU_UNE_SEULE_VALEUR);
Eblock
ATes
Bblock
Eblock
ETes
Test(IFET(IL_FAUT(editer_toutes_les_valeurs_sauf_une)
,IFEXff(numero_de_la_valeur_unique_a_ne_pas_editer,premiere_image,derniere_image)
)
)
Bblock
/* ATTENTION, si le parametre 'numero_de_la_valeur_unique_a_ne_pas_editer' n'a pas ete */
/* effectivement introduit par : */
/* */
/* Cnumero=... */
/* */
/* il conserve sa valeur initiale, c'est-a-dire 'NUMERO_DE_LA_VALEUR_UNIQUE_A_NE_PAS_EDITER' */
/* qui peut etre hors de [premiere_image,derniere_image] si l'un (ou les deux) de ces deux */
/* parametres a ete redefini(s)... */
PRINT_ERREUR("la seule valeur a ne pas editer n'est pas accessible, toutes les valeurs seront donc editees");
CAL1(Prer3(" %d E/ [%d,%d]\n",numero_de_la_valeur_unique_a_ne_pas_editer,premiere_image,derniere_image));
EGAL(numero_de_la_valeur_unique_a_ne_pas_editer,NUMERO_DE_LA_VALEUR_UNIQUE_A_NE_PAS_EDITER);
Eblock
ATes
Bblock
Eblock
ETes
DoIn(numero_d_image,premiere_image,derniere_image,pas_des_images)
Bblock
Test(I3OU(IFET(IL_NE_FAUT_PAS(n_editer_qu_une_seule_valeur)
,IL_NE_FAUT_PAS(editer_toutes_les_valeurs_sauf_une)
)
,IFET(IL_FAUT(n_editer_qu_une_seule_valeur)
,IFEQ(numero_d_image,numero_de_la_valeur_unique_a_editer)
)
,IFET(IL_FAUT(editer_toutes_les_valeurs_sauf_une)
,IFNE(numero_d_image,numero_de_la_valeur_unique_a_ne_pas_editer)
)
)
)
Bblock
DEFV(Float,INIT(valeur_courante_interpolee,FLOT__UNDEF));
/* Valeur courante interpolee cubiquement ou lineairement... */
DEFV(Float,INIT(valeur_courante_interpolee_puis_transformee,FLOT__UNDEF));
/* Valeur courante interpolee cubiquement ou lineairement puis transformee... */
Test(IL_FAUT(interpoler_par_des_splines_cubiques))
Bblock
EGAL(valeur_courante_interpolee
,iINTERPOLATION_CUBIQUE(valeur_de_depart
,derivee_de_la_valeur_de_depart
,valeur_d_arrivee
,derivee_de_la_valeur_d_arrivee
,numero_d_image
,premiere_image,derniere_image
)
);
/* Valeur courante interpolee cubiquement... */
Eblock
ATes
Bblock
EGAL(valeur_courante_interpolee
,iINTERPOLATION_LINEAIRE(valeur_de_depart
,derivee_de_la_valeur_de_depart
,valeur_d_arrivee
,derivee_de_la_valeur_d_arrivee
,numero_d_image
,premiere_image,derniere_image
)
);
/* Valeur courante interpolee lineairement... */
Eblock
ETes
EGAL(valeur_courante_interpolee_puis_transformee
,gSUBSTITUTION_D_UNE_COORDONNEE_BARYCENTRIQUE(valeur_courante_interpolee
,transformer_les_valeurs_interpolees
,liste_flottante_approximee_de_substitution_courante
,valeur_de_depart
,valeur_d_arrivee
)
);
/* Transformation (eventuelle) de la valeur courante interpolee cubiquement ou lineairement. */
Test(IFET(IL_FAUT(des_nombres_entiers)
,IL_FAUT(replier_les_nombres_entiers)
)
)
Bblock
DEFV(Int,INIT(valeur_courante_entiere_repliee
,ADD2(REST(MUL2(INTE(valeur_courante_interpolee_puis_transformee)
,module_de_repliement_des_nombres_entiers
)
,AMPLITUDE_ENTIERE
)
,DIVI(INTE(valeur_courante_interpolee_puis_transformee)
,DIVI(AMPLITUDE_ENTIERE,module_de_repliement_des_nombres_entiers)
)
)
)
);
EGAL(valeur_courante_interpolee_puis_transformee,FLOT(valeur_courante_entiere_repliee));
/* Repliement eventuel des nombres entiers introduit le 20120510093846... */
Eblock
ATes
Bblock
Eblock
ETes
CAL2(Prin2(Cara(chain_Aconcaten5(INTRODUCTION_FORMAT,valeurs_signees,".*",format_d_edition,"\n"))
,NOMBRE_DE_DECIMALES_EFFECTIF(nombre_de_decimales)
,MULTIPLE_DE(ENTIER_FLOTTANT(MODULO(valeur_courante_interpolee_puis_transformee)))
)
);
/* Edition de la valeur courante. ATTENTION, on notera qu'il y avait autrefois : */
/* */
/* CAL2(Prin1("%.16g\n",...)); */
/* */
/* malheureusement, sur 'SYSTEME_ES9000_AIX_CC', par exemple, la sequence suivante : */
/* */
/* $xci/valeurs_inte$X cubique=FAUX p=1 d=80 vD=4100 vA=5680 */
/* */
/* donnait : */
/* */
/* 4100 */
/* 4119.999999999999 */
/* 4139.999999999999 */
/* 4160 */
/* 4179.999999999999 */
/* 4199.999999999999 */
/* */
/* d'ou cette nouvelle valeur parametrable, et plus faible... */
/* */
/* */
/* On notera le 20180623121923 ce probleme avec le calcul de nombres entiers, par exemple */
/* avec les arguments suivants : */
/* */
/* entier=VRAI */
/* lineaire=VRAI */
/* premiere=0 derniere=22 */
/* vD=+0 vA=22 */
/* */
/* qui donne la liste suivante d'entiers : */
/* */
/* {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,14,16,17,18,19,20,21,22} */
/* -- -- */
/* */
/* ou l'on voit que '14' figure deux fois, alors que '15' manque. Ce phenomene peut */
/* disparaitre a condition d'utiliser l'un des arguments suivants : */
/* */
/* entier=FAUX (un peu paradoxal...) */
/* */
/* ou encore : */
/* */
/* epsilon=0.0001 (par exemple...) */
/* */
/* ('v $xtc/interpolation.01$c' a ce propos...). */
Eblock
ATes
Bblock
Eblock
ETes
Eblock
EDoI
Eblock
ATes
Bblock
Test(IFEQ(premiere_image,derniere_image))
Bblock
CAL2(Prin2(Cara(chain_Aconcaten5(INTRODUCTION_FORMAT,valeurs_signees,".*",format_d_edition,"\n"))
,NOMBRE_DE_DECIMALES_EFFECTIF(nombre_de_decimales)
,MULTIPLE_DE(ENTIER_FLOTTANT(MODULO(COND(EST_VRAI(s_il_n_y_a_qu_une_seule_image_utiliser_la_valeur_de_depart)
,valeur_de_depart
,valeur_d_arrivee
)
)
)
)
)
);
/* Edition de la valeur de depart lorsqu'une seule valeur est demandee... */
Eblock
ATes
Bblock
PRINT_ERREUR("la relation d'ordre ('premier <= dernier') n'est pas respectee");
Eblock
ETes
Eblock
ETes
RETU_Commande;
Eblock
ECommande