/*************************************************************************************************************************************/
/* */
/* S E C O N D E P A R T I E D E S D E F I N I T I O N S D U L A N G A G E ' K ' */
/* I N D E P E N D A N T E S D U L A N G A G E S O U R C E ( ' C ' ) : */
/* */
/* */
/* Definition : */
/* */
/* Dans ce fichier, se trouvent toutes les */
/* constantes, les definitions et les macros */
/* utiles a la definition du langage 'K' et */
/* qui sont independantes du langage source */
/* (le 'C'). */
/* */
/* */
/* Author of '$xil/defi_K2$vv$DEF' : */
/* */
/* Jean-Francois COLONNA (LACTAMME, 19940000000000). */
/* */
/*************************************************************************************************************************************/
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N D U S Y S T E M E U T I L I S E : */
/* */
/* */
/* Nota : */
/* */
/* on definit ici le systeme utilise */
/* pour compiler les modules, et ce sous */
/* la forme : ORDINATEUR/OS/COMPILATEUR, */
/* ou 'OS' designe le systeme d'exploitation. */
/* Les noms suivants sont reconnus pour */
/* la variable-shell 'SYSTEME' : */
/* */
/* SYSTEME_APC_LinuxDebian_GCC, */
/* SYSTEME_APC_LinuxMandrake_GCC, */
/* SYSTEME_APC_LinuxRedHat_GCC, */
/* SYSTEME_APC_LinuxUbuntu_GCC, */
/* SYSTEME_APC_LinuxUbuntu_ICC, */
/* SYSTEME_APC_LinuxUlmint_GCC, */
/* SYSTEME_APC_LinuxUlmint_ICC, */
/* SYSTEME_CRAY2_UNICOS_CC, */
/* SYSTEME_CRAY2_UNICOS_SCC, */
/* SYSTEME_CRAYC98_UNICOS_CC, */
/* SYSTEME_CRAYC98_UNICOS_SCC, */
/* SYSTEME_CRAYC916_UNICOS_CC, */
/* SYSTEME_CRAYC916_UNICOS_SCC, */
/* SYSTEME_CRAYYMP1_UNICOS_CC, */
/* SYSTEME_CRAYYMP1_UNICOS_SCC, */
/* SYSTEME_CRAYYMP2_UNICOS_CC, */
/* SYSTEME_CRAYYMP2_UNICOS_SCC, */
/* SYSTEME_CRAYYMP4_UNICOS_CC, */
/* SYSTEME_CRAYYMP4_UNICOS_SCC, */
/* SYSTEME_DECALPHA340_OSF1_CC, */
/* SYSTEME_DECALPHA340_OSF1_GCC, */
/* SYSTEME_DECALPHA350_OSF1_CC, */
/* SYSTEME_DECALPHA350_OSF1_GCC, */
/* SYSTEME_DECALPHA464_OSF1_CC, */
/* SYSTEME_DPX2000_SPIX_CC, */
/* SYSTEME_DPX5000_SPIX_CC, */
/* SYSTEME_ES9000_AIX_CC, */
/* SYSTEME_FX2800_CONCENTRIX_FXC, */
/* SYSTEME_FX2800_CONCENTRIX_PCC, */
/* SYSTEME_FX2800_CONCENTRIX_SCC, */
/* SYSTEME_FX40_CONCENTRIX_CC, */
/* SYSTEME_FX40_CONCENTRIX_FXC, */
/* SYSTEME_HP705_HPUX_CC, */
/* SYSTEME_HP710_HPUX_CC, */
/* SYSTEME_HP720_HPUX_CC, */
/* SYSTEME_HP750_HPUX_CC, */
/* SYSTEME_HP755_HPUX_CC, */
/* SYSTEME_HP819_HPUX_CC, */
/* SYSTEME_NWS3000_NEWSOS_CC, */
/* SYSTEME_NWS3000_NEWSOS_2CC, */
/* SYSTEME_RS6000_AIX_CC, */
/* SYSTEME_SG4D20G_IRIX_CC, */
/* SYSTEME_SG4D25TG_IRIX_CC, */
/* SYSTEME_SG4D310VGX_IRIX_CC, */
/* SYSTEME_SG4D35TG_IRIX_CC, */
/* SYSTEME_SG4D85GT_IRIX_CC, */
/* SYSTEME_SGIND308_IRIX_CC, */
/* SYSTEME_SGIND324_IRIX_CC, */
/* SYSTEME_SGIND3GA_IRIX_CC, */
/* SYSTEME_SGIND408_IRIX_CC, */
/* SYSTEME_SGIND424_IRIX_CC, */
/* SYSTEME_SGIND4GA_IRIX_CC, */
/* SYSTEME_SGIND508_IRIX_CC, */
/* SYSTEME_SGIND524_IRIX_CC, */
/* SYSTEME_SGIND5GA_IRIX_CC, */
/* SYSTEME_SGIND808_IRIX_CC, */
/* SYSTEME_SGIND824_IRIX_CC, */
/* SYSTEME_SGIND8GA_IRIX_CC, */
/* SYSTEME_SGINDA08_IRIX_CC, */
/* SYSTEME_SGINDA24_IRIX_CC, */
/* SYSTEME_SGINDAGA_IRIX_CC, */
/* SYSTEME_SGO200A1_IRIX_CC, */
/* SYSTEME_SGO200A2_IRIX_CC, */
/* SYSTEME_SGO200A4_IRIX_CC, */
/* SYSTEME_SGO25224_IRIX_CC, */
/* SYSTEME_SGO252VA_IRIX_CC, */
/* SYSTEME_SGO252VN_IRIX_CC, */
/* SYSTEME_SGPCM801_IRIX_CC, */
/* SYSTEME_SGPCMA01_IRIX_CC, */
/* SYSTEME_SPS9_ROS_CC, */
/* SYSTEME_SPS9_ROS_RC, */
/* SYSTEME_SUN3_SUNOS_CC, */
/* SYSTEME_SUN4_SUNOS_CC, */
/* SYSTEME_SUN4NCUBE2S_SUNOS_CC, */
/* SYSTEME_SUN4NCUBE2S_SUNOS_NCC, */
/* SYSTEME_VAX8600_ULTRIX_CC, */
/* SYSTEME_VAX8600_ULTRIX_VCC, */
/* SYSTEME_VAX9000_ULTRIX_CC, */
/* SYSTEME_VAX9000_ULTRIX_GCC, */
/* SYSTEME_VAX9000_ULTRIX_VCC. */
/* */
/* La variable 'SYSTEME' est definie par un */
/* "#define" implicite lors de la phase de */
/* pre-processing par 'cpp' (option "-D"). */
/* */
/* Mais ATTENTION, actuellement, l'ensemble */
/* des logiciels n'a ete teste que pour (le */
/* symbole "-->" indiquant le compilateur qui est */
/* effectivement utilise lorsqu'il y a le choix */
/* entre plusieurs) : */
/* */
/* --> SYSTEME_APC_LinuxDebian_GCC, */
/* --> SYSTEME_APC_LinuxMandrake_GCC, */
/* --> SYSTEME_APC_LinuxRedHat_GCC, */
/* --> SYSTEME_APC_LinuxUbuntu_GCC, */
/* --> SYSTEME_APC_LinuxUlmint_GCC, */
/* --> SYSTEME_APC_LinuxUlmint_ICC, */
/* --> SYSTEME_CRAY2_UNICOS_SCC, */
/* --> SYSTEME_CRAYC98_UNICOS_SCC, */
/* --> SYSTEME_CRAYC916_UNICOS_SCC, */
/* --> SYSTEME_CRAYYMP1_UNICOS_SCC, */
/* --> SYSTEME_CRAYYMP2_UNICOS_SCC, */
/* --> SYSTEME_CRAYYMP4_UNICOS_SCC, */
/* --> SYSTEME_DECALPHA340_OSF1_CC, */
/* --> SYSTEME_DECALPHA340_OSF1_GCC, */
/* --> SYSTEME_DECALPHA350_OSF1_CC, */
/* --> SYSTEME_DECALPHA350_OSF1_GCC, */
/* --> SYSTEME_DECALPHA464_OSF1_CC, */
/* --> SYSTEME_DPX5000_SPIX_CC, */
/* --> SYSTEME_ES9000_AIX_CC, */
/* SYSTEME_FX2800_CONCENTRIX_FXC, */
/* --> SYSTEME_FX2800_CONCENTRIX_SCC, */
/* --> SYSTEME_HP705_HPUX_CC, */
/* --> SYSTEME_HP710_HPUX_CC, */
/* --> SYSTEME_HP720_HPUX_CC, */
/* --> SYSTEME_HP750_HPUX_CC, */
/* --> SYSTEME_HP755_HPUX_CC, */
/* --> SYSTEME_HP819_HPUX_CC, */
/* SYSTEME_NWS3000_NEWSOS_CC, */
/* --> SYSTEME_NWS3000_NEWSOS_2CC, */
/* --> SYSTEME_RS6000_AIX_CC, */
/* --> SYSTEME_SG4D20G_IRIX_CC, */
/* --> SYSTEME_SG4D25TG_IRIX_CC, */
/* --> SYSTEME_SG4D310VGX_IRIX_CC, */
/* --> SYSTEME_SG4D35TG_IRIX_CC, */
/* --> SYSTEME_SG4D85GT_IRIX_CC, */
/* --> SYSTEME_SGIND308_IRIX_CC, */
/* --> SYSTEME_SGIND324_IRIX_CC, */
/* --> SYSTEME_SGIND3GA_IRIX_CC, */
/* --> SYSTEME_SGIND408_IRIX_CC, */
/* --> SYSTEME_SGIND424_IRIX_CC, */
/* --> SYSTEME_SGIND4GA_IRIX_CC, */
/* --> SYSTEME_SGIND508_IRIX_CC, */
/* --> SYSTEME_SGIND524_IRIX_CC, */
/* --> SYSTEME_SGIND5GA_IRIX_CC, */
/* --> SYSTEME_SGIND808_IRIX_CC, */
/* --> SYSTEME_SGIND824_IRIX_CC, */
/* --> SYSTEME_SGIND8GA_IRIX_CC, */
/* --> SYSTEME_SGINDA08_IRIX_CC, */
/* --> SYSTEME_SGINDA24_IRIX_CC, */
/* --> SYSTEME_SGINDAGA_IRIX_CC, */
/* --> SYSTEME_SGO200A1_IRIX_CC, */
/* --> SYSTEME_SGO200A2_IRIX_CC, */
/* --> SYSTEME_SGO200A4_IRIX_CC, */
/* --> SYSTEME_SGO25224_IRIX_CC, */
/* --> SYSTEME_SGO252VA_IRIX_CC, */
/* --> SYSTEME_SGO252VN_IRIX_CC, */
/* --> SYSTEME_SGPCM801_IRIX_CC, */
/* --> SYSTEME_SGPCMA01_IRIX_CC, */
/* SYSTEME_SPS9_ROS_CC, */
/* --> SYSTEME_SPS9_ROS_RC, */
/* --> SYSTEME_SUN3_SUNOS_CC, */
/* --> SYSTEME_SUN4_SUNOS_CC, */
/* --> SYSTEME_SUN4NCUBE2S_SUNOS_CC, */
/* --> SYSTEME_SUN4NCUBE2S_SUNOS_NCC, */
/* --> SYSTEME_VAX9000_ULTRIX_GCC. */
/* */
/* et avec une bonne probabilite de reussite */
/* pour : */
/* */
/* SYSTEME_CRAY2_UNICOS_CC, */
/* SYSTEME_CRAYC98_UNICOS_CC, */
/* SYSTEME_CRAYC916_UNICOS_CC, */
/* SYSTEME_CRAYYMP1_UNICOS_CC, */
/* SYSTEME_CRAYYMP2_UNICOS_CC, */
/* SYSTEME_CRAYYMP4_UNICOS_CC, */
/* SYSTEME_FX40_CONCENTRIX_CC, */
/* SYSTEME_FX40_CONCENTRIX_FXC, */
/* SYSTEME_VAX8600_ULTRIX_CC, */
/* SYSTEME_VAX9000_ULTRIX_CC. */
/* */
/*************************************************************************************************************************************/
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* O R D R E D E S P A S S E S D E P R E - P R O C E S S I N G : */
/* */
/* */
/* Nota important : */
/* */
/* Il y a une, cinq ou trois passes de */
/* pre-processing suivant la version : */
/* */
/* VERSION_01 : */
/* */
/* PASSE 1 : # */
/* */
/* VERSION_02 : */
/* */
/* PASSE 1 : # */
/* PASSE 2 : % */
/* PASSE 3 : = */
/* PASSE 4 : @ */
/* PASSE 5 : & */
/* */
/* VERSION_03 : */
/* */
/* PASSE F : # (destinee a generer les fichiers d'includes) */
/* */
/* PASSE D : _ (destinee a traiter la derivation formelle) */
/* */
/* PASSE E : # (destinee a traiter les extensions) */
/* */
/* PASSE 1 : # */
/* PASSE A : <> (destinee a traiter les arguments des fonctions) */
/* PASSE 2 : = */
/* PASSE 3 : % */
/* PASSE 4 : & (destinee a prendre en compte les 'defines' contenues dans d'autres) */
/* */
/* PASSE 5 : @ (destinee a prendre en compte les includes systemes a la compilation) */
/* */
/* PASSE 6 : (destinee a eliminer les references 'extern' conflictuelles) */
/* */
/*************************************************************************************************************************************/
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* V A R I A B L E S I N T R I N S E Q U E S D U P R E - P R O C E S S I N G : */
/* */
/*************************************************************************************************************************************/
#ifndef FICHIER_COURANT_RELATIF
/* Introduit le 20230125142132 suite a la remarque 'v $xcc/RecompileAll$Z 20230125133123'... */
# define FICHIER_COURANT_RELATIF \
__FILER__ \
/* Permet d'acceder au nom relatif au "home directory" (par rapport a '$x') du fichier */ \
/* courant ; ceci est du a la definition de la variable 'Includes' (dans la commande de */ \
/* compilation 'cb$Z') avec le nom relatif au "home directory" du directory general */ \
/* d'includes ; enfin ceci est aussi du a l'option '-I' du pre-processing fixant le */ \
/* "home directory" ('$x') : */ \
/* */ \
/* nous avons donc : */ \
/* */ \
/* Includes ==> "includes" */ \
/* -I ==> "$x" */ \
/* */ \
/* et donc : */ \
/* */ \
/* __FILER__ ==> "le nom du fichier courant relativement a '$x'". */ \
/* */ \
/* On notera que suite a l'introduction de 'FICHIER_COURANT_ABSOLU' le 20040924143237, */ \
/* 'FICHIER_COURANT' a ete rebaptise en 'FICHIER_COURANT_RELATIF'... */
#Aifndef FICHIER_COURANT_RELATIF
#Eifndef FICHIER_COURANT_RELATIF
#ifndef FICHIER_COURANT_ABSOLU
/* Introduit le 20230125142132 suite a la remarque 'v $xcc/RecompileAll$Z 20230125133123'... */
# define FICHIER_COURANT_ABSOLU \
__FILE__ \
/* Permet d'acceder au nom absolu (par rapport a la racine du systeme '$Dracine') du */ \
/* fichier courant (introduit le 20040924143237). */
#Aifndef FICHIER_COURANT_ABSOLU
#Eifndef FICHIER_COURANT_ABSOLU
#define FICHIER_COURANT_ABSOLU_x \
"$x/" QDQD@@QDQD FICHIER_COURANT_RELATIF \
/* Permet d'acceder au nom absolu du fichier courant (introduit le 20120412091711), mais en */ \
/* se referencant a '$x', contrairement a 'FICHIER_COURANT_ABSOLU'... */
#define NOM_SYNTHETIQUE_DU_FICHIER_COURANT \
__NOM_SYNTHETIQUE__
#define NOM_SYNTHETIQUE_NON_QUOTE_DU_FICHIER_COURANT \
__NOM_SYNTHETIQUE_NON_QUOTE__
/* Permet d'acceder au nom "synthetique" du fichier courant qui est ensuite exploite dans */
/* 'v $xig/fonct$vv$DEF EN_TETE_DE_titre_attendu_LORS_DES_ENTREES_VIA_DES_SETENV'. La */
/* version "non quotee" a ete introduite le 20040421112538. */
#define LIGNE_COURANTE \
INTE(__LINE__) \
/* Permet d'acceder au numero de la ligne courante de la macro la plus externe qui */ \
/* reference 'LIGNE_COURANTE'. On notera la fonction 'INTE(...)' mise en place le 1995072400 */ \
/* afin d'eviter des problemes du type : */ \
/* */ \
/* ...: warning(1177): argument is incompatible with formal */ \
/* */ \
/* dans 'print_defaut(...)' sur 'SYSTEME_SGPCM801_IRIX_CC'... */ \
/* */ \
/* On notera qu'a compter du 20000720115851 cette valeur peut etre nulle dans le cas ou */ \
/* l'on n'a pu determiner sa valeur ('v $xcc/cpp$Z 20000720115851'), par exemple donc dans */ \
/* le cas de la derivation formelle... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* F O N C T I O N S D E P R E S E N T A T I O N D E S F O R M U L E S : */
/* */
/* */
/* Nota important : */
/* */
/* Les noms des fonctions suivantes */
/* sont choisis de telle facon qu'ils */
/* fassent exactement 4 caracteres ; */
/* ainsi, en ajoutant la parenthese */
/* qui suit leur appel, on trouve 4+1=5, */
/* ce qui correspond a la tabulation */
/* choisie (5), qui elle-meme divise */
/* exactement 10... */
/* */
/* De plus, les definitions ne sont */
/* suivies d'aucun ";", afin de pouvoir */
/* les combiner sans limites... */
/* */
/*************************************************************************************************************************************/
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* B U G S T R E S G E N E R A U X : */
/* */
/*************************************************************************************************************************************/
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N D ' U N E L I G N E S O U R C E : */
/* */
/*************************************************************************************************************************************/
#define LONGUEUR_D_UNE_LIGNE_SOURCE PARE(134) \
/* Longueur maximale des lignes de source ; elle correspond a ce qu'il faut essayer de ne */ \
/* depasser en ce qui concerne les lignes d'instructions standard (non commentaires et non */ \
/* suite de macro-procedures). */ \
/* */ \
/* ATTENTION : on notera le fait que la definition precedente tient sur une seule ligne ; */ \
/* ceci est du au fait qu'elle est recuperee pour validation par '$Fenviron'... */
#define LONGUEUR_D_UNE_LIGNE_SOURCE_ETOILE \
LONGUEUR_D_UNE_LIGNE_SOURCE \
/* Nombre de caracteres d'une ligne de commentaires jusqu'a la derniere '*' comprise. */
#define LONGUEUR_D_UNE_LIGNE_SOURCE_SLASH \
SUCC(LONGUEUR_D_UNE_LIGNE_SOURCE_ETOILE) \
/* Nombre de caracteres d'une ligne de commentaires jusqu'au dernier '/' compris. */
#define LONGUEUR_D_UNE_LIGNE_SOURCE_BLANC \
SUCC(LONGUEUR_D_UNE_LIGNE_SOURCE_SLASH) \
/* Nombre de caracteres d'une ligne suite de macro-procedure jusqu'au dernier ' ' compris ; */ \
/* elle correspond a la variable 'LONGUEUR_LIGNE' definie dans '$Fenviron'. */
#define LONGUEUR_D_UNE_LIGNE_SOURCE_ANTI_SLASH \
SUCC(LONGUEUR_D_UNE_LIGNE_SOURCE_BLANC) \
/* Nombre de caracteres d'une ligne suite de macro-procedure jusqu'au dernier '\' compris. */
#define LONGUEUR_D_UNE_LIGNE_SOURCE_LINE_FEED \
SUCC(LONGUEUR_D_UNE_LIGNE_SOURCE_ANTI_SLASH) \
/* Nombre de caracteres d'une ligne suite de macro-procedure jusqu'au caractere 'K_LF'. */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* T Y P E D ' E V A L U A T I O N D E S A R G U M E N T S D ' U N E F O N C T I O N : */
/* */
/*************************************************************************************************************************************/
#define PARG(fonction) \
NEUT(fonction) \
/* Autorise l'evaluation parallele des arguments de la fonction 'fonction(...)'. C'est */ \
/* l'etat implicite... */
#define SARG(fonction) \
NEUT(fonction) \
/* Demande l'evaluation sequentielle des arguments de la fonction 'fonction(...)'. */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N D E L ' I N D E F I N I L E P L U S G E N E R A L : */
/* */
/*************************************************************************************************************************************/
#define gUNDEF \
ZERO \
/* Cet 'UNDEF' a ete introduit le 19971118091526 a cause de la nouvelle procedure */ \
/* 'gLOAD_FICHIER_AVEC_CONVERSION(...)' qui doit generer la variable 'valeur_du_nom' */ \
/* dont le type est a priori inconnu. Il convient donc alors de choisir une valeur initiale */ \
/* dont la "taille" soit compatible avec tous les types possibles. Le zero est le meilleur */ \
/* candidat... */
#define gnnUNDEF \
UN \
/* Cet 'UNDEF' a ete introduit le 20030528154708 a cause, en particulier, de la definition */ \
/* 'v $xci/valeurs_alea$K NOMBRE_DE_NOMBRES_ENTIERS_DIFFERENTS'. En effet, dans ce cas, il */ \
/* est souhaitable de faire une allocation memoire minimale, mais Non Nulle... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N D U " V I D E " : */
/* */
/*************************************************************************************************************************************/
#ifdef DEFV_CAST_VERSION_01
# define VIDE
/* Block vide... */
# define NOM_VIDE \
VIDE
/* Pour caracteriser un nom absent dans un 'DstructXY()' ou un 'Dunion_XY()' par exemple... */
#Aifdef DEFV_CAST_VERSION_01
#Eifdef DEFV_CAST_VERSION_01
#ifdef DEFV_CAST_VERSION_02
& define VIDE
/* Block vide... */
& define NOM_VIDE VIDE
/* Pour caracteriser un nom absent dans un 'DstructXY()' ou un 'Dunion_XY()' par exemple... */
#Aifdef DEFV_CAST_VERSION_02
#Eifdef DEFV_CAST_VERSION_02
#ifdef DEFV_CAST_VERSION_03
# define VIDE
/* Block vide... */
# define NOM_VIDE \
VIDE
/* Pour caracteriser un nom absent dans un 'DstructXY()' ou un 'Dunion_XY()' par exemple... */
#Aifdef DEFV_CAST_VERSION_03
#Eifdef DEFV_CAST_VERSION_03
@define SUPPRIMER(sequence) VIDE
/* Pour supprimer une certaine sequence (introduit le 20050104133253). */
/* */
/* ATTENTION : on notera l'absence de ligne suite ci-dessus ('\') du a l'utilisation de la */
/* 'PASSE_5' pour la definition 'SUPPRIMER(...)'... */
/* */
/* On n'oubliera pas l'existence de 'SEQUENCE_ARCHAIQUE(...)', de 'AAAAMMJJhhmmss(...)' */
/* (ou 'AAAAMMJJhhmmss' est une date a laquelle fut supprimee une certaine sequence...) */
/* ainsi que de 'SUPPRIME_LE_AAAAMMJJhhmmss(...)'. */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* A C T I O N S U R L E S S T R U C T U R E S : */
/* */
/*************************************************************************************************************************************/
#define OPST(nom_de_structure) \
PARE(PARE(PARE(PARE(PARE(PARE(PARE(PARE(PARE(PARE(PARE(PARE(PARE(PARE(PARE(PARE(nom_de_structure)))))))))))))))) \
/* Pour permettre d'appeler une macro avec comme argument un nom de structure, sachant */ \
/* que dans cette macro certains elements de celle-ci vont etre affectes par une fonction */ \
/* dont le nom "encadre" ce nom de structure. Par exemple : */ \
/* */ \
/* 'normF3D(vectorA)' permet de calculer la norme d'un vecteur quelconque 'vectorA'. */ \
/* */ \
/* si on appelle cette macro par : */ \
/* */ \
/* normF3D(SINX(OPST(V1))) */ \
/* */ \
/* la fonction 'SINX()' sera appliquee a chaque element du vecteur 'V1'. */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* C A S P A R T I C U L I E R D E S T A B L E A U X : */
/* */
/*************************************************************************************************************************************/
#ifdef DEFV_CAST_VERSION_01
# message "La version 'DEFV_CAST_VERSION_01' n'est plus disponible."
#Aifdef DEFV_CAST_VERSION_01
#Eifdef DEFV_CAST_VERSION_01
#ifdef DEFV_CAST_VERSION_02
# message "La version 'DEFV_CAST_VERSION_02' n'est plus disponible."
#Aifdef DEFV_CAST_VERSION_02
#Eifdef DEFV_CAST_VERSION_02
#ifdef DEFV_CAST_VERSION_03
# define TypedefD1(vecteur,dimension_X,type) \
= define vecteur(var) type(DTb1(var,dimension_X))
/* Definition d'un tableau a une dimension (ou vecteur). */
# define TypedefD2(matrice,dimension_Y,dimension_X,type) \
= define matrice(var) type(DTb2(var,dimension_Y,dimension_X))
/* Definition d'un tableau a deux dimensions (ou matrice). */
# define TypedefD3(tenseur3,dimension_Z,dimension_Y,dimension_X,type) \
= define tenseur3(var) type(DTb3(var,dimension_Z,dimension_Y,dimension_X))
/* Definition d'un tableau a trois dimensions (ou tenseur3). */
# define TypedefD4(tenseur4,dimension_Z,dimension_Y,dimension_X,type) \
= define tenseur4(var) type(DTb4(var,dimension_T,dimension_Z,dimension_Y,dimension_X))
/* Definition d'un tableau a quatre dimensions (ou tenseur4) introduite le 20081216141452. */
#Aifdef DEFV_CAST_VERSION_03
#Aifdef DEFV_CAST_VERSION_03
#Eifdef DEFV_CAST_VERSION_03
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* T Y P E S " V I D E " : */
/* */
/*************************************************************************************************************************************/
TypedefS(A___Void,Void)
TypedefS(E___Void,Void)
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* T Y P E S C A R A C T E R E S : */
/* */
/*************************************************************************************************************************************/
TypedefS(A___Char,Char)
TypedefS(E___Char,Char)
TypedefS(A___CHAR,CHAR)
TypedefS(E___CHAR,CHAR)
/* Definition des types caracteres... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* C A S T S T A N D A R D S ( D E B U T ) : */
/* */
/*************************************************************************************************************************************/
/* ATTENTION : le 20071121130434 a cause de 'SYSTEME_APC_LinuxUbuntu_GCC' les 'CAST's */
/* 'CARA(...)' et 'ptCARA(...)' ont ete mis ici... */
#define CARA(x) \
CAST(CHAR,x) \
/* Cast "CHAR", */
#define ptCARA(x) \
ptCAST(CHAR,x) \
/* Et son pointeur associe... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* " C A S T " D E P O R T A B I L I T E E T D E B O O T S T R A P P I N G : */
/* */
/*************************************************************************************************************************************/
@if ( (defined(SYSTEME_CRAY2_UNICOS_SCC)) \
|| (defined(SYSTEME_CRAYC98_UNICOS_SCC)) \
|| (defined(SYSTEME_CRAYC916_UNICOS_SCC)) \
|| (defined(SYSTEME_CRAYYMP1_UNICOS_SCC)) \
|| (defined(SYSTEME_CRAYYMP2_UNICOS_SCC)) \
|| (defined(SYSTEME_CRAYYMP4_UNICOS_SCC)) \
|| (defined(SYSTEME_FX2800_CONCENTRIX_FXC)) \
|| (defined(SYSTEME_FX2800_CONCENTRIX_PCC)) \
|| (defined(SYSTEME_FX2800_CONCENTRIX_SCC)) \
|| (defined(SYSTEME_SGIND308_IRIX_CC)) \
|| (defined(SYSTEME_SGIND324_IRIX_CC)) \
|| (defined(SYSTEME_SGIND3GA_IRIX_CC)) \
|| (defined(SYSTEME_SGIND408_IRIX_CC)) \
|| (defined(SYSTEME_SGIND424_IRIX_CC)) \
|| (defined(SYSTEME_SGIND4GA_IRIX_CC)) \
|| (defined(SYSTEME_SGIND508_IRIX_CC)) \
|| (defined(SYSTEME_SGIND524_IRIX_CC)) \
|| (defined(SYSTEME_SGIND5GA_IRIX_CC)) \
|| (defined(SYSTEME_SGIND808_IRIX_CC)) \
|| (defined(SYSTEME_SGIND824_IRIX_CC)) \
|| (defined(SYSTEME_SGIND8GA_IRIX_CC)) \
|| (defined(SYSTEME_SGINDA08_IRIX_CC)) \
|| (defined(SYSTEME_SGINDA24_IRIX_CC)) \
|| (defined(SYSTEME_SGINDAGA_IRIX_CC)) \
|| (defined(SYSTEME_SGO200A1_IRIX_CC)) \
|| (defined(SYSTEME_SGO200A2_IRIX_CC)) \
|| (defined(SYSTEME_SGO200A4_IRIX_CC)) \
|| (defined(SYSTEME_SGO25224_IRIX_CC)) \
|| (defined(SYSTEME_SGO252VA_IRIX_CC)) \
|| (defined(SYSTEME_SGO252VN_IRIX_CC)) \
|| (defined(SYSTEME_SGPCM801_IRIX_CC)) \
|| (defined(SYSTEME_SGPCMA01_IRIX_CC)) \
|| (defined(SYSTEME_SUN3_SUNOS_CC)) \
|| (defined(SYSTEME_SUN4_SUNOS_CC)) \
|| (defined(SYSTEME_SUN4NCUBE2S_SUNOS_CC)) \
|| (defined(SYSTEME_SUN4NCUBE2S_SUNOS_NCC)) \
|| (defined(SYSTEME_VAX8600_ULTRIX)) \
|| (defined(SYSTEME_VAX9000_ULTRIX)) \
)
/* Introduit sous cette forme grace a la modification 'v $xcc/cpp$Z 20070926141449'... */
@ define Cara(x) ptCAST(Char,x)
/* Cast "Cara" destine a resoudre le probleme des fonctions du type 'Print' et 'Scan' */
/* pour lesquelles, sur ces 'SYSTEME's les caracteres sont signes... */
/* */
/* ATTENTION : on notera l'absence de ligne suite ci-dessus ('\') du a l'utilisation de */
/* la 'PASSE_5' pour la definition 'Cara(...)', de plus 'ptCAST(...)' doit etre defini... */
@Aif ( (defined(SYSTEME_CRAY2_UNICOS_SCC)) \
|| (defined(SYSTEME_CRAYC98_UNICOS_SCC)) \
|| (defined(SYSTEME_CRAYC916_UNICOS_SCC)) \
|| (defined(SYSTEME_CRAYYMP1_UNICOS_SCC)) \
|| (defined(SYSTEME_CRAYYMP2_UNICOS_SCC)) \
|| (defined(SYSTEME_CRAYYMP4_UNICOS_SCC)) \
|| (defined(SYSTEME_FX2800_CONCENTRIX_FXC)) \
|| (defined(SYSTEME_FX2800_CONCENTRIX_PCC)) \
|| (defined(SYSTEME_FX2800_CONCENTRIX_SCC)) \
|| (defined(SYSTEME_SGIND308_IRIX_CC)) \
|| (defined(SYSTEME_SGIND324_IRIX_CC)) \
|| (defined(SYSTEME_SGIND3GA_IRIX_CC)) \
|| (defined(SYSTEME_SGIND408_IRIX_CC)) \
|| (defined(SYSTEME_SGIND424_IRIX_CC)) \
|| (defined(SYSTEME_SGIND4GA_IRIX_CC)) \
|| (defined(SYSTEME_SGIND508_IRIX_CC)) \
|| (defined(SYSTEME_SGIND524_IRIX_CC)) \
|| (defined(SYSTEME_SGIND5GA_IRIX_CC)) \
|| (defined(SYSTEME_SGIND808_IRIX_CC)) \
|| (defined(SYSTEME_SGIND824_IRIX_CC)) \
|| (defined(SYSTEME_SGIND8GA_IRIX_CC)) \
|| (defined(SYSTEME_SGINDA08_IRIX_CC)) \
|| (defined(SYSTEME_SGINDA24_IRIX_CC)) \
|| (defined(SYSTEME_SGINDAGA_IRIX_CC)) \
|| (defined(SYSTEME_SGO200A1_IRIX_CC)) \
|| (defined(SYSTEME_SGO200A2_IRIX_CC)) \
|| (defined(SYSTEME_SGO200A4_IRIX_CC)) \
|| (defined(SYSTEME_SGO25224_IRIX_CC)) \
|| (defined(SYSTEME_SGO252VA_IRIX_CC)) \
|| (defined(SYSTEME_SGO252VN_IRIX_CC)) \
|| (defined(SYSTEME_SGPCM801_IRIX_CC)) \
|| (defined(SYSTEME_SGPCMA01_IRIX_CC)) \
|| (defined(SYSTEME_SUN3_SUNOS_CC)) \
|| (defined(SYSTEME_SUN4_SUNOS_CC)) \
|| (defined(SYSTEME_SUN4NCUBE2S_SUNOS_CC)) \
|| (defined(SYSTEME_SUN4NCUBE2S_SUNOS_NCC)) \
|| (defined(SYSTEME_VAX8600_ULTRIX)) \
|| (defined(SYSTEME_VAX9000_ULTRIX)) \
)
@ if ( (defined(SYSTEME_APC_LinuxRedHat_GCC)) \
|| (defined(SYSTEME_APC_LinuxUbuntu_GCC)) \
|| (defined(SYSTEME_APC_LinuxUbuntu_ICC)) \
|| (defined(SYSTEME_APC_LinuxUlmint_GCC)) \
|| (defined(SYSTEME_APC_LinuxUlmint_ICC)) \
)
/* Le SYSTEME 'SYSTEME_APC_LinuxRedHat_GCC' a ete introduit le 20090318090909 suite au */
/* remplacement de "trinite.polytechnique.fr" par "europe.polytechnique.fr" (='$CMAP28', */
/* 'v $Fmachines 20090316110150'). */
@ define Cara(x) ptCARA(x)
@ Aif ( (defined(SYSTEME_APC_LinuxRedHat_GCC)) \
|| (defined(SYSTEME_APC_LinuxUbuntu_GCC)) \
|| (defined(SYSTEME_APC_LinuxUbuntu_ICC)) \
|| (defined(SYSTEME_APC_LinuxUlmint_GCC)) \
|| (defined(SYSTEME_APC_LinuxUlmint_ICC)) \
)
@ define Cara(x) NEUT(x)
/* Cast "Cara". */
/* */
/* ATTENTION : on notera l'absence de ligne suite ci-dessus ('\') du a l'utilisation de */
/* la 'PASSE_5' pour la definition 'Cara(...)', de plus 'ptCAST(...)' doit etre defini... */
@ Eif ( (defined(SYSTEME_APC_LinuxRedHat_GCC)) \
|| (defined(SYSTEME_APC_LinuxUbuntu_GCC)) \
|| (defined(SYSTEME_APC_LinuxUbuntu_ICC)) \
|| (defined(SYSTEME_APC_LinuxUlmint_GCC)) \
|| (defined(SYSTEME_APC_LinuxUlmint_ICC)) \
)
@Eif ( (defined(SYSTEME_CRAY2_UNICOS_SCC)) \
|| (defined(SYSTEME_CRAYC98_UNICOS_SCC)) \
|| (defined(SYSTEME_CRAYC916_UNICOS_SCC)) \
|| (defined(SYSTEME_CRAYYMP1_UNICOS_SCC)) \
|| (defined(SYSTEME_CRAYYMP2_UNICOS_SCC)) \
|| (defined(SYSTEME_CRAYYMP4_UNICOS_SCC)) \
|| (defined(SYSTEME_FX2800_CONCENTRIX_FXC)) \
|| (defined(SYSTEME_FX2800_CONCENTRIX_PCC)) \
|| (defined(SYSTEME_FX2800_CONCENTRIX_SCC)) \
|| (defined(SYSTEME_SGIND308_IRIX_CC)) \
|| (defined(SYSTEME_SGIND324_IRIX_CC)) \
|| (defined(SYSTEME_SGIND3GA_IRIX_CC)) \
|| (defined(SYSTEME_SGIND408_IRIX_CC)) \
|| (defined(SYSTEME_SGIND424_IRIX_CC)) \
|| (defined(SYSTEME_SGIND4GA_IRIX_CC)) \
|| (defined(SYSTEME_SGIND508_IRIX_CC)) \
|| (defined(SYSTEME_SGIND524_IRIX_CC)) \
|| (defined(SYSTEME_SGIND5GA_IRIX_CC)) \
|| (defined(SYSTEME_SGIND808_IRIX_CC)) \
|| (defined(SYSTEME_SGIND824_IRIX_CC)) \
|| (defined(SYSTEME_SGIND8GA_IRIX_CC)) \
|| (defined(SYSTEME_SGINDA08_IRIX_CC)) \
|| (defined(SYSTEME_SGINDA24_IRIX_CC)) \
|| (defined(SYSTEME_SGINDAGA_IRIX_CC)) \
|| (defined(SYSTEME_SGO200A1_IRIX_CC)) \
|| (defined(SYSTEME_SGO200A2_IRIX_CC)) \
|| (defined(SYSTEME_SGO200A4_IRIX_CC)) \
|| (defined(SYSTEME_SGO25224_IRIX_CC)) \
|| (defined(SYSTEME_SGO252VA_IRIX_CC)) \
|| (defined(SYSTEME_SGO252VN_IRIX_CC)) \
|| (defined(SYSTEME_SGPCM801_IRIX_CC)) \
|| (defined(SYSTEME_SGPCMA01_IRIX_CC)) \
|| (defined(SYSTEME_SUN3_SUNOS_CC)) \
|| (defined(SYSTEME_SUN4_SUNOS_CC)) \
|| (defined(SYSTEME_SUN4NCUBE2S_SUNOS_CC)) \
|| (defined(SYSTEME_SUN4NCUBE2S_SUNOS_NCC)) \
|| (defined(SYSTEME_VAX8600_ULTRIX)) \
|| (defined(SYSTEME_VAX9000_ULTRIX)) \
)
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* T Y P E S E N T I E R : */
/* */
/*************************************************************************************************************************************/
TypedefS(A___Int,Int)
TypedefS(E___Int,Int)
TypedefS(A___ShortInt,ShortInt)
TypedefS(E___ShortInt,ShortInt)
TypedefS(A___LongInt,LongInt)
TypedefS(E___LongInt,LongInt)
/* Definition des types 'short' et 'long' a partir de '_Int'. */
TypedefS(A___Positive,Positive)
TypedefS(E___Positive,Positive)
/* Definition des types 'Positive' a partir de 'Int' (et non pas de '_int', afin qu'il */
/* soit 'Long' ou 'Short' suivant le cas...). */
/* */
/* ATTENTION : on notera le danger de l'utilisation conjointe des type 'Int' et 'Positive'. */
/* Soit l'exemple suivant : */
/* */
/* DEFV(Int,INIT(index,UNDEF)); */
/* DEFV(Positive,INIT(borne,...)); */
/* . */
/* . */
/* . */
/* DoIn(index,NEGA(borne),NEUT(borne),I) */
/* Bblock */
/* . */
/* . */
/* . */
/* Eblock */
/* EDoI */
/* */
/* la boucle 'DoIn(...)' ne sera jamais executee, car en effet 'NEGA(borne)' est considere */
/* comme etant positif et sa valeur est superieure a 'NEUT(borne)' a cause du bit de signe. */
TypedefS(A___PointerInt,PointerInt)
TypedefS(E___PointerInt,PointerInt)
/* Definition des types 'PointerInt'. */
TypedefS(Dummy,Int)
/* Definition d'un type "bidon" destine par exemple a definir des structures qui devraient */
/* etre vide, mais ce que le compilateur du CRAY2 refuse... */
TypedefS(tI,Int)
TypedefS(A___tI,Int)
/* Introduits le 20040623093006 pour 'v $xig/fonct$vv$FON GENERE__FonctionI_Fload' depuis */
/* que les 'GENERE__Fonction...(...)' sont pris en compte dans les '$EXT'... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* T Y P E S F L O T T A N T S : */
/* */
/*************************************************************************************************************************************/
TypedefS(A___Float,Float)
TypedefS(E___Float,Float)
TypedefS(A___Double,Double)
TypedefS(E___Double,Double)
/* Definition des types flottants... */
TypedefS(tF,Float)
TypedefS(A___tF,Float)
/* Introduits le 20040623093006 pour 'v $xig/fonct$vv$FON GENERE__FonctionI_Fload' depuis */
/* que les 'GENERE__Fonction...(...)' sont pris en compte dans les '$EXT'... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* T Y P E S A C C E S O I R E S : */
/* */
/*************************************************************************************************************************************/
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* M O T S C L E F S P O U R L E S T Y P E S : */
/* */
/*************************************************************************************************************************************/
TypedefT(Logical,Positive)
TypedefS(A___Logical,Logical)
TypedefS(E___Logical,Logical)
/* Type logique. */
TypedefT(binaire,Positive)
TypedefS(A___binaire,binaire)
TypedefS(E___binaire,binaire)
/* Type binaire. */
#ifdef Register_VERSION_01
TypedefT(Rchar,CONC(Register,CHAR))
/* Type "CHAR" dans un registre. */
TypedefT(Rint,CONC(Register,Int))
/* Type "Int" dans un registre. */
TypedefT(Runsigned,CONC(Register,Positive))
/* Type "Positive" dans un registre. */
TypedefT(Rfloat,CONC(Register,Float))
/* Type "Float" dans un registre. */
#Aifdef Register_VERSION_01
#Eifdef Register_VERSION_01
#ifdef Register_VERSION_02
#Aifdef Register_VERSION_02
#Eifdef Register_VERSION_02
TypedefT(Schar,CONC(Static,CHAR))
/* Type "CHAR" statique. */
TypedefT(Sint,CONC(Static,Int))
/* Type "Int" statique. */
TypedefT(Sunsigned,CONC(Static,Positive))
/* Type "Positive" statique. */
TypedefT(Sfloat,CONC(Static,Float))
/* Type "Float" statique. */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N D E S O B J E T S D E D I M E N S I O N S T A T I Q U E S : */
/* */
/*************************************************************************************************************************************/
TypedefAES(Statique,S___ <><> )
/* Ce mot clef doit etre mis devant toutes les definitions des objets dont la dimension */
/* est statique : c'est le cas par exemple des images de '$xiii/Images$STR' et de */
/* '$xiii/Imagess$STR'. On notera la syntaxe tres particuliere 'S___ <><> ' destinee a */
/* obtenir la concatenation du prefixe 'S___' des objets statiques a un type quelconque */
/* ('Int', 'Float',...). */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* T A I L L E S D E S T Y P E S S T A N D A R D S : */
/* */
/*************************************************************************************************************************************/
#define size_char \
SIZP(_char)
#define size_CHAR \
SIZP(KONC(_unsigned,_char))
#define size_vrai_Int_de_base \
SIZP(_int)
#define size_vrai_Positive_de_base \
SIZP(KONC(_unsigned,_int))
/* Types introduits le 20100326184826... */
#if (PRECISION_DU_Int==SIMPLE_PRECISION)
# define size_Int \
size_vrai_Int_de_base
# define size_Positive \
size_vrai_Positive_de_base
#Aif (PRECISION_DU_Int==SIMPLE_PRECISION)
#Eif (PRECISION_DU_Int==SIMPLE_PRECISION)
#if (PRECISION_DU_Int==DOUBLE_PRECISION)
# define size_Int \
SIZP(KONC(_long,_int))
# define size_Positive \
SIZP(KONC(_unsigned,KONC(_long,_int)))
#Aif (PRECISION_DU_Int==DOUBLE_PRECISION)
#Eif (PRECISION_DU_Int==DOUBLE_PRECISION)
/* ATTENTION, on notera que l'on ne peut ecrire : */
/* */
/* #define size_Int \ */
/* SIZP(Int) */
/* #define size_Int \ */
/* SIZP(Positive) */
/* */
/* puisque 'Int' et 'Positive' sont en fait des fonctions. Pour eviter des conflits et des */
/* incoherences, il serait bon qu'il n'y ait plus qu'un seul type d'entier... */
#define size_LPositive \
SIZP(KONC(_unsigned,KONC(_long,_int))) \
/* Ajoute le 20001102164045 car il manquait et provoquait une grosse anomalie au niveau */ \
/* des images de type 'imageU' dont la longueur (au niveau des fichiers) etait moitie de */ \
/* qu'elle devait etre... */
#if (SYSTEME_32_64_BITS==SYSTEME_32_BITS)
# define ADRESSAGE_VERSION_32_BITS_DEFINI
TypedefS(PointerInt,Int)
# define size_PointerInt \
size_vrai_Int_de_base \
/* Cas des machines "32 bits" (introduit le 20000221094143 et modifie le 20000222085131)... */
#Aif (SYSTEME_32_64_BITS==SYSTEME_32_BITS)
# if (SYSTEME_32_64_BITS==SYSTEME_64_BITS)
# define ADRESSAGE_VERSION_64_BITS_DEFINI
TypedefS(PointerInt,LongInt)
# define size_PointerInt \
SIZP(KONC(_long,_int)) \
/* Cas des machines "64 bits" (introduit le 20000221094143 et modifie le 20000222085131)... */
# Aif (SYSTEME_32_64_BITS==SYSTEME_64_BITS)
# message "ATTENTION : le type d'adressage (32/64 bits) n'a pas ete defini."
# define ADRESSAGE_VERSION_64_BITS_INDEFINI
TypedefS(PointerInt,LongInt)
# define size_PointerInt \
SIZP(KONC(_long,_int)) \
/* Cas indetermines (introduit le 20000221094143 et modifie le 20000222085131). Il vaut */
/* mieux etre prudent... */
# Eif (SYSTEME_32_64_BITS==SYSTEME_64_BITS)
#Eif (SYSTEME_32_64_BITS==SYSTEME_32_BITS)
#define size_Logical \
size_Positive
#define k___size_Float \
SIZP(_float)
#define size_vrai_float_de_base \
k___size_Float
/* Taille d'un element 'Float'. */
/* */
/* ATTENTION : la constante 'size_Float' est pre-generee dans '$xcp/Konstantes$K'. */
/* Ceci a ete introduit le 19970905140951 afin de permettre de connaitre cette valeur a */
/* l'exterieur des programmes (via '$xcp/Konstantes$K') et par exemple dans les fichiers */
/* de '$xE'. */
/* */
/* La constante 'size_vrai_float_de_base' a ete introduite le 20170406105520... */
#define size_Double \
SIZP(_double)
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* S A U V E G A R D E E T R E S T A U R A T I O N D E V A R I A B L E S S C A L A I R E S : */
/* */
/*************************************************************************************************************************************/
#define EnTete_de_sauvegardA \
SavA_____
#define EnTete_de_sauvegardM \
SavM_____
/* En tete precedant a priori le nom des variables scalaires de type "sauvegarde"... */
/* */
/* Le 20110418171139, 'EnTete_de_sauvegarde' a ete remplace par 'EnTete_de_sauvegardA' */
/* (pour "Automatique", c'est-a-dire via les procedures de type 'SaveVariable(...)' et */
/* par 'EnTete_de_sauvegardM' (pour "Manuel", c'est-a-dire via des 'DEFV(...)' explicites). */
#define gBSaveVariable(type,variable) \
DEFV(type,INIT(EnTete_de_sauvegardA ## variable,variable));
#define BSaveVariable(type,variable) \
BblockV \
gBSaveVariable(type,variable);
/* Sauvagarde d'une variable scalaire (introduite le 20090506152409 et complete le */
/* 20090506224542 avec 'SaveVariable(...)' pour prendre en compte les cas ou il ne */
/* faut surtout pas de 'ESave...(...)', c'est-a-dire les cas ou il ne faut pas restaurer */
/* la valeur anterieure de la variable : voir 'v $xig/fonct$vv$DEF SaveVariable'). */
/* */
/* Le 20111212162652 'SaveVariable(...)' a ete rebaptise en 'gBSaveVariable(...)' afin */
/* de permettre l'introduction de 'gESaveVariable(...)'... */
#define BSaveModifyVariable(type,variable,nouvelle_valeur) \
BblockV \
BSaveVariable(type,variable); \
EGAL(variable,nouvelle_valeur); \
/* Sauvagarde et modification d'une variable scalaire (introduite le 20090506152409). */
#define ESaveModifyVariable(type,variable) \
ESaveVariable(type,variable); \
EblockV
#define ESaveVariable(type,variable) \
gESaveVariable(type,variable); \
EblockV
#define gESaveVariable(type,variable) \
EGAL(variable,EnTete_de_sauvegardA ## variable); \
/* Restauration d'une variable scalaire (introduite le 20090506152409). */
/* */
/* Le 20111212162652 'gBSaveVariable(...)' a ete introduit... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* " P R E - G E N E R A T I O N " D E S C O N S T A N T E S F O N D A M E N T A L E S : */
/* */
/*************************************************************************************************************************************/
#TestADef size_Float \
k___size_Float
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* C A S T S T A N D A R D S ( S U I T E ) : */
/* */
/*************************************************************************************************************************************/
/* ATTENTION : le 20071121130434 a cause de 'SYSTEME_APC_LinuxUbuntu_GCC' les 'CAST's */
/* 'CARA(...)' et 'ptCARA(...)' ont ete deplaces... */
#define LOGI(x) \
CAST(Logical,x) \
/* Cast "Logical", */
#define fLOGI(x) \
LOGI(AINT_a_peu_pres(x,tgEPSILON)) \
/* Cast "Logical" a partir d'un 'x' flottant. Cela fut introduit le 20060602094911 pour */ \
/* 'v $xrs/surfaces.12$I 20060602091942' et 'v $xrs/volumes.12$I 20060602091935'... */
#define SHOR(x) \
CAST(ShortInt,x) \
/* Cast "Short Int", */
#if ( (defined(SYSTEME_CRAY2)) \
|| (defined(SYSTEME_CRAYC98)) \
|| (defined(SYSTEME_CRAYC916)) \
|| (defined(SYSTEME_CRAYYMP1)) \
|| (defined(SYSTEME_CRAYYMP2)) \
|| (defined(SYSTEME_CRAYYMP4)) \
|| (defined(SYSTEME_DECALPHA340_OSF1_CC)) \
|| (defined(SYSTEME_DECALPHA350_OSF1_CC)) \
|| (defined(SYSTEME_DECALPHA464_OSF1_CC)) \
|| (defined(SYSTEME_SGIND308_IRIX_CC)) \
|| (defined(SYSTEME_SGIND324_IRIX_CC)) \
|| (defined(SYSTEME_SGIND3GA_IRIX_CC)) \
|| (defined(SYSTEME_SGIND408_IRIX_CC)) \
|| (defined(SYSTEME_SGIND424_IRIX_CC)) \
|| (defined(SYSTEME_SGIND4GA_IRIX_CC)) \
|| (defined(SYSTEME_SGIND508_IRIX_CC)) \
|| (defined(SYSTEME_SGIND524_IRIX_CC)) \
|| (defined(SYSTEME_SGIND5GA_IRIX_CC)) \
|| (defined(SYSTEME_SGIND808_IRIX_CC)) \
|| (defined(SYSTEME_SGIND824_IRIX_CC)) \
|| (defined(SYSTEME_SGIND8GA_IRIX_CC)) \
|| (defined(SYSTEME_SGINDA08_IRIX_CC)) \
|| (defined(SYSTEME_SGINDA24_IRIX_CC)) \
|| (defined(SYSTEME_SGINDAGA_IRIX_CC)) \
|| (defined(SYSTEME_SGO200A1_IRIX_CC)) \
|| (defined(SYSTEME_SGO200A2_IRIX_CC)) \
|| (defined(SYSTEME_SGO200A4_IRIX_CC)) \
|| (defined(SYSTEME_SGO25224_IRIX_CC)) \
|| (defined(SYSTEME_SGO252VA_IRIX_CC)) \
|| (defined(SYSTEME_SGO252VN_IRIX_CC)) \
|| (defined(SYSTEME_SGPCM801_IRIX_CC)) \
|| (defined(SYSTEME_SGPCMA01_IRIX_CC)) \
)
# define INTE(x) \
CAST(Int,x) \
/* Version CRAY2, */ \
/* version CRAYC98, */ \
/* version CRAYC916, */ \
/* version CRAYYMP1, */ \
/* version CRAYYMP2, */ \
/* version CRAYYMP4, */ \
/* version DECALPHA340/OSF1/CC, */ \
/* version DECALPHA350/OSF1/CC, */ \
/* version DECALPHA464/OSF1/CC. */ \
/* */ \
/* ATTENTION, sur 'SYSTEME_DECALPHA340_OSF1_CC' et 'SYSTEME_DECALPHA350_OSF1_CC, ne pas */ \
/* faire cela conduit a des problemes lors de l'evaluation de certaines constantes, et en */ \
/* particulier 'MHEXA' (sa valeur dans '$xcp/Konstantes$X' est '0x00000001'). */
#Aif ( (defined(SYSTEME_CRAY2)) \
|| (defined(SYSTEME_CRAYC98)) \
|| (defined(SYSTEME_CRAYC916)) \
|| (defined(SYSTEME_CRAYYMP1)) \
|| (defined(SYSTEME_CRAYYMP2)) \
|| (defined(SYSTEME_CRAYYMP4)) \
|| (defined(SYSTEME_DECALPHA340_OSF1_CC)) \
|| (defined(SYSTEME_DECALPHA350_OSF1_CC)) \
|| (defined(SYSTEME_DECALPHA464_OSF1_CC)) \
|| (defined(SYSTEME_SGIND308_IRIX_CC)) \
|| (defined(SYSTEME_SGIND324_IRIX_CC)) \
|| (defined(SYSTEME_SGIND3GA_IRIX_CC)) \
|| (defined(SYSTEME_SGIND408_IRIX_CC)) \
|| (defined(SYSTEME_SGIND424_IRIX_CC)) \
|| (defined(SYSTEME_SGIND4GA_IRIX_CC)) \
|| (defined(SYSTEME_SGIND508_IRIX_CC)) \
|| (defined(SYSTEME_SGIND524_IRIX_CC)) \
|| (defined(SYSTEME_SGIND5GA_IRIX_CC)) \
|| (defined(SYSTEME_SGIND808_IRIX_CC)) \
|| (defined(SYSTEME_SGIND824_IRIX_CC)) \
|| (defined(SYSTEME_SGIND8GA_IRIX_CC)) \
|| (defined(SYSTEME_SGINDA08_IRIX_CC)) \
|| (defined(SYSTEME_SGINDA24_IRIX_CC)) \
|| (defined(SYSTEME_SGINDAGA_IRIX_CC)) \
|| (defined(SYSTEME_SGO200A1_IRIX_CC)) \
|| (defined(SYSTEME_SGO200A2_IRIX_CC)) \
|| (defined(SYSTEME_SGO200A4_IRIX_CC)) \
|| (defined(SYSTEME_SGO25224_IRIX_CC)) \
|| (defined(SYSTEME_SGO252VA_IRIX_CC)) \
|| (defined(SYSTEME_SGO252VN_IRIX_CC)) \
|| (defined(SYSTEME_SGPCM801_IRIX_CC)) \
|| (defined(SYSTEME_SGPCMA01_IRIX_CC)) \
)
# if (SYSTEME_32_64_BITS==SYSTEME_32_BITS)
# define INTE(x) \
CAST(LongInt,x) \
/* Cast "Long Int" (version par defaut...), */
# Aif (SYSTEME_32_64_BITS==SYSTEME_32_BITS)
# Eif (SYSTEME_32_64_BITS==SYSTEME_32_BITS)
# if (SYSTEME_32_64_BITS==SYSTEME_64_BITS)
# define INTE(x) \
CAST(Int,x) \
/* Ceci a ete introduit le 20041208142936 pour '$LACT17' car, en effet, en utilisant la */ \
/* definition via 'LongInt', certaines constantes ('NOMBRE_D_OCTETS_DIFFERENTS' par exemple) */ \
/* se retrouvent negatives... */
# Aif (SYSTEME_32_64_BITS==SYSTEME_64_BITS)
# Eif (SYSTEME_32_64_BITS==SYSTEME_64_BITS)
#Eif ( (defined(SYSTEME_CRAY2)) \
|| (defined(SYSTEME_CRAYC98)) \
|| (defined(SYSTEME_CRAYC916)) \
|| (defined(SYSTEME_CRAYYMP1)) \
|| (defined(SYSTEME_CRAYYMP2)) \
|| (defined(SYSTEME_CRAYYMP4)) \
|| (defined(SYSTEME_DECALPHA340_OSF1_CC)) \
|| (defined(SYSTEME_DECALPHA350_OSF1_CC)) \
|| (defined(SYSTEME_DECALPHA464_OSF1_CC)) \
|| (defined(SYSTEME_SGIND308_IRIX_CC)) \
|| (defined(SYSTEME_SGIND324_IRIX_CC)) \
|| (defined(SYSTEME_SGIND3GA_IRIX_CC)) \
|| (defined(SYSTEME_SGIND408_IRIX_CC)) \
|| (defined(SYSTEME_SGIND424_IRIX_CC)) \
|| (defined(SYSTEME_SGIND4GA_IRIX_CC)) \
|| (defined(SYSTEME_SGIND508_IRIX_CC)) \
|| (defined(SYSTEME_SGIND524_IRIX_CC)) \
|| (defined(SYSTEME_SGIND5GA_IRIX_CC)) \
|| (defined(SYSTEME_SGIND808_IRIX_CC)) \
|| (defined(SYSTEME_SGIND824_IRIX_CC)) \
|| (defined(SYSTEME_SGIND8GA_IRIX_CC)) \
|| (defined(SYSTEME_SGINDA08_IRIX_CC)) \
|| (defined(SYSTEME_SGINDA24_IRIX_CC)) \
|| (defined(SYSTEME_SGINDAGA_IRIX_CC)) \
|| (defined(SYSTEME_SGO200A1_IRIX_CC)) \
|| (defined(SYSTEME_SGO200A2_IRIX_CC)) \
|| (defined(SYSTEME_SGO200A4_IRIX_CC)) \
|| (defined(SYSTEME_SGO25224_IRIX_CC)) \
|| (defined(SYSTEME_SGO252VA_IRIX_CC)) \
|| (defined(SYSTEME_SGO252VN_IRIX_CC)) \
|| (defined(SYSTEME_SGPCM801_IRIX_CC)) \
|| (defined(SYSTEME_SGPCMA01_IRIX_CC)) \
)
#define PINTE(x) \
INTE(x) \
/* Introduit le 20230311135805 a cause de 'v $xtc/ImpressionConstanteEntiereNegative.01$c'. */ \
/* On notera que l'on aurait pu utiliser directement 'INTE(...)' dans les impressions (voir */ \
/* par exemple 'v $xci/Ising_2D.11$K PINTE'), mais utiliser explicitement 'INTE(...)' permet */ \
/* de reperer facilement les impressions qui ont pose ce genre de probleme... */
#define POSI(x) \
CAST(Positive,x) \
/* Cast "Positive". */
-define FLOT(x) \
-_-_-_- CAST(Float,x)
/* Cast "Float", */
#if ( (defined(SYSTEME_CRAY2)) \
|| (defined(SYSTEME_CRAYC98)) \
|| (defined(SYSTEME_CRAYC916)) \
|| (defined(SYSTEME_CRAYYMP1)) \
|| (defined(SYSTEME_CRAYYMP2)) \
|| (defined(SYSTEME_CRAYYMP4)) \
)
# define DPRE(x) \
CAST(Float,x) \
/* Version CRAY2, */ \
/* version CRAYC98, */ \
/* version CRAYC916, */ \
/* version CRAYYMP1, */ \
/* version CRAYYMP2, */ \
/* version CRAYYMP4. */
#Aif ( (defined(SYSTEME_CRAY2)) \
|| (defined(SYSTEME_CRAYC98)) \
|| (defined(SYSTEME_CRAYC916)) \
|| (defined(SYSTEME_CRAYYMP1)) \
|| (defined(SYSTEME_CRAYYMP2)) \
|| (defined(SYSTEME_CRAYYMP4)) \
)
# define DPRE(x) \
CAST(Double,x) \
/* Cast "Double" (version par defaut...), */
#Eif ( (defined(SYSTEME_CRAY2)) \
|| (defined(SYSTEME_CRAYC98)) \
|| (defined(SYSTEME_CRAYC916)) \
|| (defined(SYSTEME_CRAYYMP1)) \
|| (defined(SYSTEME_CRAYYMP2)) \
|| (defined(SYSTEME_CRAYYMP4)) \
)
#define vbFLOT(x) \
CAST(vrai_Float_de_base,x) \
/* Cast "vrai Float de base" (introduit le 20090330121519). */ \
/* */ \
/* On notera le 20101220161611 qu'ecrire : */ \
/* */ \
/* FLOT(vbFLOT(x)) */ \
/* */ \
/* 'x' etant de type 'Float' aura en general pour effet de reduire la precision de 'x' de */ \
/* 64 a 32 bits. Cela pourrait donc etre utilise pour "simuler" des calculs effectues en */ \
/* precision reduite ('vrai_Float_de_base', au lieu de 'vrai_Double_de_base' a priori...). */
#ifdef DECLARATIONS_DES_FONCTIONS_ET_DE_LEURS_ARGUMENTS_VERSION_01
# define ConversionEventuelle_CHAR(x) \
NEUT(x) \
/* Introduit le 20040619183253... */
# define ConversionEventuelle_Int(x) \
NEUT(x) \
/* Introduit le 20040623115231... */
# define ConversionEventuelle_Float(x) \
NEUT(x) \
/* Introduit le 20040619191221... */
#Aifdef DECLARATIONS_DES_FONCTIONS_ET_DE_LEURS_ARGUMENTS_VERSION_01
#Eifdef DECLARATIONS_DES_FONCTIONS_ET_DE_LEURS_ARGUMENTS_VERSION_01
#ifdef DECLARATIONS_DES_FONCTIONS_ET_DE_LEURS_ARGUMENTS_VERSION_02
# define ConversionEventuelle_CHAR(x) \
ptCARA(x) \
/* Introduit le 20040619183253... */
# define ConversionEventuelle_Int(x) \
ptCAST(Int,x) \
/* Introduit le 20040623115231... */
# define ConversionEventuelle_Float(x) \
ptCAST(Float,x) \
/* Introduit le 20040619191221... */
#Aifdef DECLARATIONS_DES_FONCTIONS_ET_DE_LEURS_ARGUMENTS_VERSION_02
#Eifdef DECLARATIONS_DES_FONCTIONS_ET_DE_LEURS_ARGUMENTS_VERSION_02
#define DECI(x) \
bSOU(x,AINT(x)) \
/* Procedure "complementaire" de 'INTE(...)' donnant la partie decimale d'un nombre, alors */ \
/* que 'INTE(...)' donne la partie entiere (introduit le 20081222113242). On notera donc */ \
/* que : */ \
/* */ \
/* NEUT(x) == ADD2(INTE(x),DECI(x)) */ \
/* */ \
/* theoriquement... */ \
/* */ \
/* Le 20101120092003, 'bSOU(...)' plus logique a remplace 'SOUS(...)'. */ \
/* */ \
/* Avant le 20151210133045, il y avait ici : */ \
/* */ \
/* #define DECI(x) \ */ \
/* bSOU(x,INTE(x)) */ \
/* */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* H O R R E U R S P O U R A C C E L E R E R L E */
/* P R E - P R O C E S S I N G E T L A C O M P I L A T I O N : */
/* */
/*************************************************************************************************************************************/
/* ATTENTION : les constantes {DEUX,TROIS,...,VINGT_QUATRE,VINGT_CINQ} sont pre-generees */
/* avec '$xcp/Konstantes$K'... */
#define k___DEUX \
ENUM(_2)
#define k___TROIS \
ENUM(_3)
#define k___QUATRE \
ENUM(_4)
#define k___CINQ \
ENUM(_5)
#define k___SIX \
ENUM(_6)
#define k___SEPT \
ENUM(_7)
#define k___HUIT \
ENUM(_8)
#define k___NEUF \
ENUM(_9)
#define k___DIX \
ENUM(_10)
#define k___ONZE \
ENUM(_11)
#define k___DOUZE \
ENUM(_12)
#define k___TREIZE \
ENUM(_13)
#define k___QUATORZE \
ENUM(_14)
#define k___QUINZE \
ENUM(_15)
#define k___SEIZE \
ENUM(_16)
#define k___DIX_SEPT \
ENUM(_17)
#define k___DIX_HUIT \
ENUM(_18)
#define k___DIX_NEUF \
ENUM(_19)
#define k___VINGT \
ENUM(_20)
#define k___VINGT_ET_UN \
ENUM(_21)
#define k___VINGT_DEUX \
ENUM(_22)
#define k___VINGT_TROIS \
ENUM(_23)
#define k___VINGT_QUATRE \
ENUM(_24)
#define k___VINGT_CINQ \
ENUM(_25)
/* ATTENTION : les constantes {DEUX,TROIS,...,VINGT_QUATRE,VINGT_CINQ} sont pre-generees */
/* avec '$xcp/Konstantes$K'... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* " P R E - G E N E R A T I O N " D E S C O N S T A N T E S F O N D A M E N T A L E S : */
/* */
/*************************************************************************************************************************************/
/* ATTENTION : depuis qu'a ete introduite la '$PASSE_D', il est imperatif que certaines */
/* definitions soient faites avant d'autres ; en particulier 'DEUX' doit etre definie */
/* avant tout '-define ...' qui l'utilise... */
#TestADef DEUX \
k___DEUX
#TestADef TROIS \
k___TROIS
#TestADef QUATRE \
k___QUATRE
#TestADef CINQ \
k___CINQ
#TestADef SIX \
k___SIX
#TestADef SEPT \
k___SEPT
#TestADef HUIT \
k___HUIT
#TestADef NEUF \
k___NEUF
#TestADef DIX \
k___DIX
#TestADef ONZE \
k___ONZE
#TestADef DOUZE \
k___DOUZE
#TestADef TREIZE \
k___TREIZE
#TestADef QUATORZE \
k___QUATORZE
#TestADef QUINZE \
k___QUINZE
#TestADef SEIZE \
k___SEIZE
#TestADef DIX_SEPT \
k___DIX_SEPT
#TestADef DIX_HUIT \
k___DIX_HUIT
#TestADef DIX_NEUF \
k___DIX_NEUF
#TestADef VINGT \
k___VINGT
#TestADef VINGT_ET_UN \
k___VINGT_ET_UN
#TestADef VINGT_DEUX \
k___VINGT_DEUX
#TestADef VINGT_TROIS \
k___VINGT_TROIS
#TestADef VINGT_QUATRE \
k___VINGT_QUATRE
#TestADef VINGT_CINQ \
k___VINGT_CINQ
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* C O N S T A N T E S F L O T T A N T E S G E N E R A L E S : */
/* */
/*************************************************************************************************************************************/
/* Les definitions relatives aux constantes flottantes generales furent mises ici le */
/* 20071130225230 suite a la remarque 'v $xcc/cpp$Z 20071130220903' car, en effet, elles */
/* doivent preceder la la definition des operateurs derivables... */
#define k___FZERO \
FLOT(ZERO) \
/* Constante nulle en flottant. */ \
/* */ \
/* ATTENTION : la constante 'FZERO' est pre-generee dans '$xcp/Konstantes$K'. */
#define tgEPSILON \
PARE(1.0E-3) \
/* "Grand" petit nombre flottant... */
#define igEPSILON \
PARE(1.0E-6) \
/* "Intermediaire" petit nombre flottant (introduit le 20120524104144)... */
#define mgEPSILON \
PARE(1.0E-9) \
/* "Moyen" petit nombre flottant... */
#define gEPSILON \
PARE(1.0E-15) \
/* Petit nombre flottant... */
#define pEPSILON \
PARE(1.0E-30) \
/* Tres petit nombre flottant... */
#define UN_MOINS_tgEPSILON \
SOUS(FU,tgEPSILON)
#define UN_MOINS_igEPSILON \
SOUS(FU,igEPSILON)
#define UN_MOINS_mgEPSILON \
SOUS(FU,mgEPSILON)
#define UN_MOINS_gEPSILON \
SOUS(FU,gEPSILON)
#define UN_MOINS_pEPSILON \
SOUS(FU,pEPSILON)
/* Quelques '1-epsilon' introduits le 20150307093000... */
#define W \
UN \
/* Element unique. */
#define UNITE \
UN \
/* Pour calculer par exemple des expressions du type 1-(a/b)... */
#define NEUTRE \
UN
#define FLOT__NEUTRE \
FLOT(NEUTRE)
/* Element neutre de la multiplication, 'FLOT__NEUTRE' ayant ete introduit le 20040229174106 */
/* pour 'v $xiii/tri_image$FON FLOT__NEUTRE'. */
#define k___FU \
FLOT(UN) \
/* Unite flottante. */ \
/* */ \
/* ATTENTION : la constante 'FU' est pre-generee dans '$xcp/Konstantes$K'. */
#define FU___ \
FU \
/* Introduit le 20120520122554 afin d'ameliorer la presentation de la valeur par defaut de */ \
/* certaines matrices. Avant cette date, cette definition figurait etrangement (et de facon */ \
/* non "optimisee") a deux endroits differents : 'v $xiii/di_image$FON 20120520122707' et */ \
/* 'v $xiipf/fonction.2$FON 20120520122602'... */
#define k___FDU \
MOIT(FU) \
/* Demi-unite flottante. */ \
/* */ \
/* ATTENTION : la constante 'FDU' est pre-generee dans '$xcp/Konstantes$K'. */
#define k___FDEUX \
FLOT(DEUX) \
/* Double-unite flottante. */ \
/* */ \
/* ATTENTION : la constante 'FDEUX' est pre-generee dans '$xcp/Konstantes$K'. */
#define k___FTROIS \
FLOT(TROIS) \
/* Triple-unite flottante. */ \
/* */ \
/* ATTENTION : la constante 'FTROIS' est pre-generee dans '$xcp/Konstantes$K'. */
#define k___FQUATRE \
FLOT(QUATRE) \
/* Quadruple-unite flottante. */ \
/* */ \
/* ATTENTION : la constante 'FQUATRE' est pre-generee dans '$xcp/Konstantes$K'. */
#define k___FCINQ \
FLOT(CINQ)
#define k___FSIX \
FLOT(SIX)
#define k___FSEPT \
FLOT(SEPT)
#define k___FHUIT \
FLOT(HUIT)
/* Constantes introduites le 20220425111738 pour 'v $xci/valeurs_TransformationPeano3D$K'... */
#define FQU \
MOIT(FDU) \
/* Quart-unite flottante. */
#define k___BEGIN_AT_0 \
SUCC(ZERO) \
/* Pour ce qui commence a 0. ATTENTION : autrefois cette valeur s'appelait ' Z ', mais */ \
/* afin de permettre d'utiliser la lettre 'Z' pour les troisiemes coordonnees, ce */ \
/* changement a ete opere... */ \
/* */ \
/* Le 20101119160847, 'BEGIN_AT_0' est devenue une constante fondamentale... */
#define CONSTANTE_DE_MOYENNE \
DEUX \
/* Pour faire des moyennes... */
#define B \
BEGIN_AT_0 \
/* Parce que le premier bit d'un mot a le rang 0... */
#define MAGIK \
SEPT \
/* Constante magique de "shuffling". */
#define MASK2 \
BIT \
/* Pour generer un masque a partir d'une puissance de 2, suivant les deux procedures */ \
/* suivantes : */
#define MASK_TO_P2(masque) \
bADD(masque,MASK2) \
/* Passage d'un masque a une puissance de 2... */
#define P2_TO_MASK(puissance_de_2) \
bSOU(puissance_de_2,MASK2) \
/* Passage d'une puissance de 2 a un masque... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* " P R E - G E N E R A T I O N " D E S C O N S T A N T E S F O N D A M E N T A L E S : */
/* */
/*************************************************************************************************************************************/
#TestADef FZERO \
k___FZERO
#TestADef FU \
k___FU
#TestADef FDU \
k___FDU
#TestADef FDEUX \
k___FDEUX
#TestADef FTROIS \
k___FTROIS
#TestADef FQUATRE \
k___FQUATRE
#TestADef FCINQ \
k___FCINQ
#TestADef FSIX \
k___FSIX
#TestADef FSEPT \
k___FSEPT
#TestADef FHUIT \
k___FHUIT
/* Constantes introduites le 20220425111738 pour 'v $xci/valeurs_TransformationPeano3D$K'... */
#TestADef BEGIN_AT_0 \
k___BEGIN_AT_0
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N D E S M A S Q U E S F O N D A M E N T A U X ( D E B U T ) : */
/* */
/*************************************************************************************************************************************/
/* Les definitions relatives a certains masques furent mises ici le */
/* 20071201093658 suite a la remarque 'v $xcc/cpp$Z 20071130220903' car, en effet, elles */
/* doivent preceder la la definition des operateurs derivables... */
#define gMASQUE(nombre_de_bits) \
SCLS(SARS(SBIT(MASQUE_VIDE,BITSIG),TRMU(nombre_de_bits)),nombre_de_bits) \
/* Definition du masque quelconque cadre a droite a partir de son 'nombre_de_bits'... */
#define MASQUE_VIDE \
ZERO \
/* Definition du masque vide... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* I N F I N I : */
/* */
/*************************************************************************************************************************************/
/* ATTENTION, depuis l'introduction de la derivation formelle, et etant donne le bug */
/* 'BUG_SYSTEME_SGIND_C_log', la definition de 'F_MOINS_L_INFINI' (et donc de */
/* 'F_INFINI') doit preceder la definition de 'LOGX(...)'... */
/* Les definitions relatives a l'infini furent mises ici le 20071130225230 suite a la */
/* remarque 'v $xcc/cpp$Z 20071130220903' car, en effet, elles doivent preceder la */
/* la definition des operateurs derivables... */
#if ( (defined(SYSTEME_CRAY2_UNICOS_CC)) \
|| (defined(SYSTEME_CRAY2_UNICOS_SCC)) \
|| (defined(SYSTEME_CRAYC98_UNICOS_CC)) \
|| (defined(SYSTEME_CRAYC98_UNICOS_SCC)) \
|| (defined(SYSTEME_CRAYC916_UNICOS_CC)) \
|| (defined(SYSTEME_CRAYC916_UNICOS_SCC)) \
|| (defined(SYSTEME_CRAYYMP1_UNICOS_CC)) \
|| (defined(SYSTEME_CRAYYMP1_UNICOS_SCC)) \
|| (defined(SYSTEME_CRAYYMP2_UNICOS_CC)) \
|| (defined(SYSTEME_CRAYYMP2_UNICOS_SCC)) \
|| (defined(SYSTEME_CRAYYMP4_UNICOS_CC)) \
|| (defined(SYSTEME_CRAYYMP4_UNICOS_SCC)) \
)
# TestADef BUG_SYSTEME_CRAY_C_INFINI \
/* Malheureusement, sur les CRAYs, il y a un probleme lors de l'initialisation d'une */ \
/* variable flottante avec une valeur entiere signee occupant plus de 48 bits : le bit de */ \
/* signe est alors perdu... */
#Aif ( (defined(SYSTEME_CRAY2_UNICOS_CC)) \
|| (defined(SYSTEME_CRAY2_UNICOS_SCC)) \
|| (defined(SYSTEME_CRAYC98_UNICOS_CC)) \
|| (defined(SYSTEME_CRAYC98_UNICOS_SCC)) \
|| (defined(SYSTEME_CRAYC916_UNICOS_CC)) \
|| (defined(SYSTEME_CRAYC916_UNICOS_SCC)) \
|| (defined(SYSTEME_CRAYYMP1_UNICOS_CC)) \
|| (defined(SYSTEME_CRAYYMP1_UNICOS_SCC)) \
|| (defined(SYSTEME_CRAYYMP2_UNICOS_CC)) \
|| (defined(SYSTEME_CRAYYMP2_UNICOS_SCC)) \
|| (defined(SYSTEME_CRAYYMP4_UNICOS_CC)) \
|| (defined(SYSTEME_CRAYYMP4_UNICOS_SCC)) \
)
#Eif ( (defined(SYSTEME_CRAY2_UNICOS_CC)) \
|| (defined(SYSTEME_CRAY2_UNICOS_SCC)) \
|| (defined(SYSTEME_CRAYC98_UNICOS_CC)) \
|| (defined(SYSTEME_CRAYC98_UNICOS_SCC)) \
|| (defined(SYSTEME_CRAYC916_UNICOS_CC)) \
|| (defined(SYSTEME_CRAYC916_UNICOS_SCC)) \
|| (defined(SYSTEME_CRAYYMP1_UNICOS_CC)) \
|| (defined(SYSTEME_CRAYYMP1_UNICOS_SCC)) \
|| (defined(SYSTEME_CRAYYMP2_UNICOS_CC)) \
|| (defined(SYSTEME_CRAYYMP2_UNICOS_SCC)) \
|| (defined(SYSTEME_CRAYYMP4_UNICOS_CC)) \
|| (defined(SYSTEME_CRAYYMP4_UNICOS_SCC)) \
)
#define k___INFINI \
gMASQUE(TRMU(NBITMO)) \
/* Definition de l'infini entier positif. */ \
/* */ \
/* ATTENTION : la constante 'INFINI' est pre-generee dans '$xcp/Konstantes$K'. */ \
/* */ \
/* On notera qu'aux environs du 20071202113349 et dans les jours suivants, il fut tenter */ \
/* de definir {k___MOINS_L_INFINI,k___INFINI} a l'aide de {INTPTR_MIN,INTPTR_MAX} qui sont */ \
/* definis dans '<stdint.h>', puis a l'aide de {INT_MIN,INT_MAX} qui eux sont definis dans */ \
/* '<limits.h>'. Or cela a conduit a des anomalies considerables dans '$xcc/cpp$Z' au */ \
/* niveau de la '$PASSE_1' ; ainsi, par exemple, la derivation formelle ne fonctionnait */ \
/* plus dans 'v $xrs/sphere.11$K' et 'VISUALISATION_DE_LA_SURFACE_AVEC_DIFFERENCES____(...)' */ \
/* donnait le message : */ \
/* */ \
/* argument mismatch (pas assez d'arguments a l'appel) */ \
/* */ \
/* dans 'v $xrs/CalabiYau.21$K'. Ces problemes disparaissant en supprimant l'include */ \
/* correspondant, sans que je puisse comprendre pourquoi... */ \
/* */ \
/* Ceci avait ete tente le 20071202113349 pour permettre de compiler '$xcp/Konstantes$K' */ \
/* avec 'GET_ARGUMENTSi(...)' a la place de 'GET_ARGUMENTS_(...)'. En effet, dans ce cas, */ \
/* 'SUPER_ECHELLE_GRAND_CARRE' et 'SUPER_ECHELLE_PETIT_CARRE' sont references via */ \
/* 'v $xig/fonct$vv$DEF CHOIX_DE_LA_SUPER_ECHELLE', or l'un comme l'autre font des */ \
/* 'DIVZ(...)'. Or cet operateur est derivable et sa definition lors de '$PASSE_1' de */ \
/* '$xcc/cpp$Z' ne contient plus le symbole 'INFINI', mais la definition a l'aide des */ \
/* operateurs 'RBIT(SARS(SBIT(...)))' qui n'ont pas pu etre remplaces par leur definition, */ \
/* puisque celles-ci n'apparaissent que plus loin (et il semble impossible de les placer */ \
/* au-dessus de ces lignes...). On notera au passage que le traitement de 'INFINI' dans */ \
/* 'v $xcp/Konstantes$K DEFINEX..INFINI..k___INFINI...INFINI....' ne pose pas de probleme */ \
/* puisqu'elle apparait apres la definition des operateurs 'RBIT(SARS(SBIT(...)))'... */ \
/* */ \
/* On notera qu'une solution plus simple fu trouvee le 20071203093149 et qui a consiste */ \
/* simplement a remplacer les 'DIVZ(...)'s par des 'fDIVZ(...)'s dans le fichier */ \
/* 'v $xiii/vecteurs$DEF 20071203093149'... */
#define k___MOINS_L_INFINI \
NEGA(INFINI) \
/* Definition de l'infini entier negatif. ATTENTION, on notera que pendant presqu'une */ \
/* eternite, il y a eu : */ \
/* */ \
/* #define k___MOINS_L_INFINI \ */ \
/* SBIT(MASQUE_VIDE,BITSIG) */ \
/* */ \
/* or, ainsi qu'on peut le voir grace au programme 'v $xtc/infini.02$c', les valeurs ainsi */ \
/* calculees pour 'k___MOINS_L_INFINI' et 'k___INFINI' ne sont pas compatibles : */ \
/* */ \
/* k___MOINS_L_INFINI = 0x80000000 = -2147483648 */ \
/* */ \
/* et : */ \
/* */ \
/* k___INFINI = 0x7fffffff = +2147483647 */ \
/* */ \
/* Ces deux constantes ne sont donc pas egales en valeur absolueR ; d'ou cette nouvelle */ \
/* definition pour 'k___MOINS_L_INFINI' ou l'on ajoute 1 a partir du 1994033000. Comme */ \
/* quoi, on peut vivre longtemps dans l'erreur. Une des consequences, est la modification */ \
/* correlative de la primitive 'VINTE(...)'. On notera au passage que : */ \
/* */ \
/* -0x80000000 = 0x80000000 */ \
/* */ \
/* ce qui est bizarre, mais valable sur tous les SYSTEMEs apparemment... */ \
/* */ \
/* ATTENTION : la constante 'MOINS_L_INFINI' est pre-generee dans '$xcp/Konstantes$K'. */ \
/* */ \
/* Avant le 20100318095202 la definition etait : */ \
/* */ \
/* bADD(SBIT(MASQUE_VIDE,BITSIG),UN) */ \
/* */ \
/* et donc a cette date a ete simplifiee... */
#define k___PETIT_INFINI \
INTE(EXPX(MOIT(LOGX(FLOT(INFINI))))) \
/* Definition d'un "petit" infini positif (utile pour prevenir des debordements */ \
/* ulterieurs...). */
#if ( (defined(BUG_SYSTEME_CRAY_C_INFINI)) \
)
# undef k___MOINS_L_INFINI
# define k___MOINS_L_INFINI \
NEGA(INFINI) \
/* On choisit des nombres entiers sur 48 (64-8-8) bits pour les CRAYs... */ \
/* */ \
/* Version CRAY.../UNICOS (rappelons que les decalages Arithmetiques n'existent pas...). */ \
/* */ \
/* ATTENTION : la constante 'MOINS_L_INFINI' est pre-generee dans '$xcp/Konstantes$K'. */
# if ( (defined(BUG_SYSTEME_C_SARS)) \
)
# undef k___INFINI
# define k___INFINI \
TRMU(MOINS_L_INFINI) \
/* Version CRAY.../UNICOS (rappelons que les decalages Arithmetiques n'existent pas...). */ \
/* */ \
/* ATTENTION : voir le commentaire associe a la definition de 'SIZE_GENERAL(...)'. */ \
/* */ \
/* ATTENTION : la constante 'INFINI' est pre-generee dans '$xcp/Konstantes$K'. */
# Aif ( (defined(BUG_SYSTEME_C_SARS)) \
)
# undef k___INFINI
# define k___INFINI \
TRMU(SLLS(BIT,bSOU(NBITMO,DOUB(NBITOC)))) \
/* On choisit des nombres entiers sur 48 (64-8-8) bits pour les CRAYs... */ \
/* */ \
/* Version CRAY.../UNICOS (rappelons que les decalages Arithmetiques n'existent pas...). */ \
/* */ \
/* ATTENTION : la constante 'INFINI' est pre-generee dans '$xcp/Konstantes$K'. */
# Eif ( (defined(BUG_SYSTEME_C_SARS)) \
)
#Aif ( (defined(BUG_SYSTEME_CRAY_C_INFINI)) \
)
#Eif ( (defined(BUG_SYSTEME_CRAY_C_INFINI)) \
)
#TestADef MOINS_L_INFINI \
k___MOINS_L_INFINI
#TestADef INFINI \
k___INFINI
#define SEPARATEUR_DE_LISTES_DE_COORDONNEES \
FLOT(PETIT_INFINI) \
/* Pour 'v $xrs/surfaces.51$I SEPARATEUR_DE_LISTE_DE_COORDONNEES' en particulier, cela fut */ \
/* introduit le 20230219110412... */
#TestADef PETIT_INFINI \
k___PETIT_INFINI
#define D_INFINI \
PARE(1.0e308) \
/* Definition de l'infini double-precision positif. */
#define D_EPSILON \
PARE(5.0e-308) \
/* Definition de l'epsilon double-precision. Jusqu'au 20000929101624, c'est la valeur */ \
/* 'PARE(1.0e-308)' qui a ete utilisee ; mais en fait elle est trop petite par rapport */ \
/* a ce que sait faire la norme "IEEE 754". En fait, le 20000929180952, j'ai considere */ \
/* en etudiant le probleme de 'v $xiii/conversion$FON 20000929102058' qu'il etait plus */ \
/* astucieux de majore legerement la constante 2.225073858507201383e-308 ; 4.0e-308 */ \
/* me semble une valeur utile. Le 20001010145551 je l'ai augmentee (5.0e-308). */
#if ( (defined(SYSTEME_ES9000_AIX_CC)) \
)
# TestADef BUG_SYSTEME_ES9000_AIX_CC_EPSILON_ET_INFINI_double_precision \
/* Le compilateur 'cc' ne supporte pas les constantes 'double' trop grandes... */
#Aif ( (defined(SYSTEME_ES9000_AIX_CC)) \
)
#Eif ( (defined(SYSTEME_ES9000_AIX_CC)) \
)
#if ( ((defined(SYSTEME_SGIND308_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGIND324_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGIND3GA_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGIND408_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGIND424_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGIND4GA_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGIND508_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGIND524_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGIND5GA_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGIND808_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGIND824_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGIND8GA_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGINDA08_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGINDA24_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGINDAGA_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGO200A1_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGO200A2_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGO200A4_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGO25224_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGO252VA_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGO252VN_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGPCM801_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGPCMA01_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
)
/* Le test 'nSYSTEM_RELEASE < 503000000' a ete ajoute le 20000929103523 car d'une part il */
/* semble que ce probleme soit tres ancien (et ne produise plus aujourd'hui) et d'autre */
/* part a cause de la modification 'v $xiii/conversion$FON 20000929102058'... */
# TestADef BUG_SYSTEME_SGIND_CC_EPSILON_double_precision \
/* Le compilateur 'cc' ne supporte pas les constantes 'double' trop petites... */
#Aif ( ((defined(SYSTEME_SGIND308_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGIND324_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGIND3GA_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGIND408_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGIND424_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGIND4GA_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGIND508_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGIND524_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGIND5GA_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGIND808_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGIND824_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGIND8GA_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGINDA08_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGINDA24_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGINDAGA_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGO200A1_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGO200A2_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGO200A4_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGO25224_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGO252VA_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGO252VN_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGPCM801_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGPCMA01_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
)
#Eif ( ((defined(SYSTEME_SGIND308_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGIND324_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGIND3GA_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGIND408_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGIND424_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGIND4GA_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGIND508_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGIND524_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGIND5GA_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGIND808_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGIND824_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGIND8GA_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGINDA08_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGINDA24_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGINDAGA_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGO200A1_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGO200A2_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGO200A4_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGO25224_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGO252VA_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGO252VN_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGPCM801_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGPCMA01_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
)
#if ( (defined(SYSTEME_VAX9000_ULTRIX_GCC)) \
|| (defined(SYSTEME_VAX9000_ULTRIX_VCC)) \
)
# TestADef BUG_SYSTEME_VAX_C_EPSILON_ET_INFINI_double_precision \
/* Le compilateur 'gcc' ne supporte pas les constantes 'double' trop grandes... */
#Aif ( (defined(SYSTEME_VAX9000_ULTRIX_GCC)) \
|| (defined(SYSTEME_VAX9000_ULTRIX_VCC)) \
)
#Eif ( (defined(SYSTEME_VAX9000_ULTRIX_GCC)) \
|| (defined(SYSTEME_VAX9000_ULTRIX_VCC)) \
)
#if ( (defined(BUG_SYSTEME_ES9000_AIX_CC_EPSILON_ET_INFINI_double_precision)) \
)
# undef D_INFINI
# define D_INFINI \
PARE(1.0e75) \
/* Definition de l'infini double-precision positif. */
# undef D_EPSILON
# define D_EPSILON \
PARE(1.0e-75) \
/* Definition de l'epsilon double-precision. */
#Aif ( (defined(BUG_SYSTEME_ES9000_AIX_CC_EPSILON_ET_INFINI_double_precision)) \
)
#Eif ( (defined(BUG_SYSTEME_ES9000_AIX_CC_EPSILON_ET_INFINI_double_precision)) \
)
#if ( (defined(BUG_SYSTEME_SGIND_CC_EPSILON_double_precision)) \
)
# undef D_EPSILON
# define D_EPSILON \
PARE(1.0e-307) \
/* Definition de l'epsilon double-precision. */
#Aif ( (defined(BUG_SYSTEME_SGIND_CC_EPSILON_double_precision)) \
)
#Eif ( (defined(BUG_SYSTEME_SGIND_CC_EPSILON_double_precision)) \
)
#if ( (defined(BUG_SYSTEME_VAX_C_EPSILON_ET_INFINI_double_precision)) \
)
# undef D_INFINI
# define D_INFINI \
PARE(1.0e38) \
/* Definition de l'infini double-precision positif. */
# undef D_EPSILON
# define D_EPSILON \
PARE(1.0e-38) \
/* Definition de l'epsilon double-precision. */
#Aif ( (defined(BUG_SYSTEME_VAX_C_EPSILON_ET_INFINI_double_precision)) \
)
#Eif ( (defined(BUG_SYSTEME_VAX_C_EPSILON_ET_INFINI_double_precision)) \
)
#define D_MOINS_L_INFINI \
NEGA(D_INFINI) \
/* Definition de l'infini double-precision negatif. */
#if (PRECISION_DU_Float==SIMPLE_PRECISION)
# define k___F_INFINI \
PARE(1.0e38) \
/* Definition de l'infini flottant positif. */
# define F_EPSILON \
PARE(1.0e-38) \
/* Definition de l'epsilon flottant. */
# define GRAND_EPSILON \
PARE(1.0e-06) \
/* Definition du plus petit nombre encore significatif devant 'FU', c'est-a-dire pour */ \
/* lequel cela a un sens d'ecrire : */ \
/* */ \
/* SOUS(FU,GRAND_EPSILON) */ \
/* */ \
/* sans donc retomber sur 'FU'. Cette valeur est calculee grace a 'v $xtc/epsilon.01$c'... */
#Aif (PRECISION_DU_Float==SIMPLE_PRECISION)
#Eif (PRECISION_DU_Float==SIMPLE_PRECISION)
#if (PRECISION_DU_Float==DOUBLE_PRECISION)
# define k___F_INFINI \
D_INFINI \
/* Definition de l'infini flottant positif. */
# define F_EPSILON \
D_EPSILON \
/* Definition de l'epsilon flottant. */
# define GRAND_EPSILON \
PARE(1.0e-15) \
/* Definition du plus petit nombre encore significatif devant 'FU', c'est-a-dire pour */ \
/* lequel cela a un sens d'ecrire : */ \
/* */ \
/* SOUS(FU,GRAND_EPSILON) */ \
/* */ \
/* sans donc retomber sur 'FU'. Cette valeur est calculee grace a 'v $xtc/epsilon.01$c'... */
#Aif (PRECISION_DU_Float==DOUBLE_PRECISION)
#Eif (PRECISION_DU_Float==DOUBLE_PRECISION)
#define TRES_GRAND_EPSILON \
PARE(1.0e-03) \
/* Introduit le 20171113104345 pour 'v $xrf/EpongeDeMenger.01$K TRES_GRAND_EPSILON'... */
#define k___F_MOINS_L_INFINI \
NEGA(F_INFINI) \
/* Definition de l'infini flottant negatif. */
#ifdef PRE_GENERATION
# define k___F_PETIT_INFINI \
EXPX(MOIT(LOGX(F_INFINI))) \
/* Definition d'un "petit" infini flottant positif (utile pour prevenir des debordements */ \
/* ulterieurs...). */
#Aifdef PRE_GENERATION
# define k___F_PETIT_INFINI \
PARE(1.0e16) \
/* Definition d'un "petit" infini flottant positif (utile pour prevenir des debordements */ \
/* ulterieurs...) mais arbitraire lorsque '$xcp/Konstantes$X' n'est pas utilise (voir */ \
/* 'v $xccp/cpp$Y 20100319090856'). */
#Eifdef PRE_GENERATION
#define k___F_MOINS_LE_PETIT_INFINI \
NEGA(F_PETIT_INFINI) \
/* Definition d'un "petit" infini flottant negatif (utile pour prevenir des debordements */ \
/* ulterieurs...). */
#define UN_MOINS_EPSILON \
COMP(GRAND_EPSILON) \
/* Definition d'un nombre legerement inferieur a 1 (introduit le 20110420152113)... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* V A L E U R I N D E T E R M I N E E : */
/* */
/*************************************************************************************************************************************/
#if (PRECISION_DU_Float==SIMPLE_PRECISION)
# define NAN_VALEUR_INDETERMINEE \
PARE(-4194304) \
/* Introduit le 20240625142026 pour 'v $ximcf/fonction$FON NAN_VALEUR_INDETERMINEE'... */
#Aif (PRECISION_DU_Float==SIMPLE_PRECISION)
#Eif (PRECISION_DU_Float==SIMPLE_PRECISION)
#if (PRECISION_DU_Float==DOUBLE_PRECISION)
# define NAN_VALEUR_INDETERMINEE \
PARE(-2251799813685248) \
/* Introduit le 20240625142026 pour 'v $ximcf/fonction$FON NAN_VALEUR_INDETERMINEE'... */
#Aif (PRECISION_DU_Float==DOUBLE_PRECISION)
#Eif (PRECISION_DU_Float==DOUBLE_PRECISION)
Dunion_02(EquivalenceIntFloat
,DEFV(Int,InT)
/* Pour acceder a la valeur en entier (attention au 'T'...), */
,DEFV(Float,FloaT)
/* Pour acceder a la valeur en flottant (attention au 'T'...). */
,NOM_VIDE
);
/* L'union ainsi definie s'appelle "Equivalence_Int_Float", */
TypedefP(IntFloat,UNIO(EquivalenceIntFloat))
#define Equivalence_IntFloat_InT(argument) \
ASD1(argument,InT)
#define Equivalence_IntFloat_FloaT(argument) \
ASD1(argument,FloaT)
/* Procedures d'acces introduites le 20240625142026. */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* " P R E - G E N E R A T I O N " D E S C O N S T A N T E S F O N D A M E N T A L E S : */
/* */
/*************************************************************************************************************************************/
#TestADef F_INFINI \
k___F_INFINI
#TestADef F_MOINS_L_INFINI \
k___F_MOINS_L_INFINI
#TestADef F_PETIT_INFINI \
k___F_PETIT_INFINI
#TestADef F_MOINS_LE_PETIT_INFINI \
k___F_MOINS_LE_PETIT_INFINI
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* " D E R I V E E " D E L ' I N F I N I : */
/* */
/*************************************************************************************************************************************/
#define d_F_INFINI \
d_FCONSTANTES
#define d_F_PETIT_INFINI \
d_FCONSTANTES
#define d_F_MOINS_L_INFINI \
d_FCONSTANTES
#define d_F_MOINS_LE_PETIT_INFINI \
d_FCONSTANTES
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* N O T I O N D E D E R I V A T I O N F O R M E L L E : */
/* */
/* */
/* Definition : */
/* */
/* Les derivees formelles des differents */
/* operateurs arithmetiques et des differentes */
/* fonctions mathematiques vont etre definies */
/* par la suite. Elles sont designees par : */
/* */
/* d_XXXX(...) */
/* */
/* Elles generent des symboles terminaux du type */
/* */
/* d_VARIABLE */
/* d_CONSTANTE */
/* */
/* ou 'd_VARIABLE' designe la differentielle de la */
/* variable 'VARIABLE', et 'd_CONSTANTE' celle de la */
/* constante 'CONSTANTE'. On devra donc bien entendu */
/* definir : */
/* */
/* #define d_CONSTANTE ZERO */
/* */
/* En ce qui concerne les variables, deux cas se */
/* presentent (et qui correspondent a la notion de */
/* derivee partielle). On devra donc definir : */
/* */
/* #define d_VARIABLE d_FVARIABLES_MUETTES */
/* */
/* ou : */
/* */
/* DEFV(Float,INIT(d_VARIABLE,d_FVARIABLES_MUETTES)); */
/* */
/* lorsque le derivation partielle n'a pas lieu par */
/* rapport a la variable 'VARIABLE', et : */
/* */
/* #define d_VARIABLE d_FVARIABLES_DE_DERIVATION */
/* */
/* ou : */
/* */
/* DEFV(Float,INIT(d_VARIABLE,d_FVARIABLES_DE_DERIVATION)); */
/* */
/* dans le cas contraire (ou la derivation partielle */
/* a lieu par rapport a la variable 'VARIABLE')... */
/* */
/* */
/* Un bon exemple d'utilisation est fourni par le */
/* programme 'v $xrf/recursif.11$K' qui fut le premier */
/* a tirer pleinement parti de cette possibilite, de */
/* meme que 'v $xrq/Hspherik.21$K' qui montre ce qu'il */
/* faut faire des '#undef ...' (voir aussi a ce propos */
/* 'v $xcc/cpp$Z'). */
/* */
/* On notera, que la derivee soit pre-definie dans ce */
/* fichier ('$xil/defi_K2$vv$DEF') ou pas (et doive donc */
/* etre calculee formellement), on ecrira systematiquement : */
/* */
/* d#FONCTION(...) */
/* */
/* et par exemple : */
/* */
/* d#MUL2(x1,x2) */
/* */
/* et : */
/* */
/* d#MUL3(x1,x2,x3) */
/* */
/* (voir 'v $xtKg/derivees.11$K'). */
/* */
/* */
/* Le 20101210222213 j'ai fait des tests afin de pouvoir */
/* utiliser : */
/* */
/* d#INTERPOLATION_CUBIQUE(...) */
/* */
/* dans '$ximf/courbes.1$FON d_INTERPOLATION_CUBIQUE_D_UN_ARC_DE_CUBIQUE'. */
/* En fait, si la derivation formelle est referencee directement (au premier */
/* niveau) dans 'v $xbmf/courbes.1$K', cela marche tres bien, a condition */
/* evidemment d'y mettre : */
/* */
/* @define PRAGMA_CPP_____MODULE_DERIVABLE */
/* */
/* Par contre dans '$ximf/courbes.1$FON' (donc au deuxieme niveau des */
/* 'include's) cela ne marche pas, or c'est evidemment la qu'il faudrait */
/* que cela soit implemente... */
/* */
/* */
/*************************************************************************************************************************************/
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E R I V E E D E S C O N S T A N T E S : */
/* */
/*************************************************************************************************************************************/
#define d_CONSTANTES \
ZERO
#define d_FCONSTANTES \
FZERO
/* Elles sont nulles bien entendu ('d_FCONSTANTES' fut introduite le 20101222105716). */
#define d_ZERO \
d_CONSTANTES
#define d_UN \
d_CONSTANTES
#define d_DEUX \
d_CONSTANTES
#define d_TROIS \
d_CONSTANTES
#define d_QUATRE \
d_CONSTANTES
#define d_CINQ \
d_CONSTANTES
#define d_SIX \
d_CONSTANTES
#define d_SEPT \
d_CONSTANTES
#define d_HUIT \
d_CONSTANTES
#define d_NEUF \
d_CONSTANTES
#define d_DIX \
d_CONSTANTES
#define d_ONZE \
d_CONSTANTES
#define d_DOUZE \
d_CONSTANTES
#define d_TREIZE \
d_CONSTANTES
#define d_QUATORZE \
d_CONSTANTES
#define d_QUINZE \
d_CONSTANTES
#define d_SEIZE \
d_CONSTANTES
#define d_I \
d_CONSTANTES
#define d_SIGNE_MOINS \
d_CONSTANTES
#define d_SIGNE_PLUS \
d_CONSTANTES
#define d_INFINI \
d_CONSTANTES
#define d_FZERO \
d_FCONSTANTES
#define d_FDU \
d_FCONSTANTES
#define d_FU \
d_FCONSTANTES
#define d_FDEUX \
d_FCONSTANTES
#define d_FTROIS \
d_FCONSTANTES
#define d_FQUATRE \
d_FCONSTANTES
/* ATTENTION, on notera que l'on definit explicitement les derivees des constantes 'FZERO' */
/* et 'FU' a cause de la pre-generation des constantes par '$xcp/Konstantes$K' ; il s'agit */
/* tout simplement de se simplifier la vie. L'introduction de 'd_FQUATRE' a eu lieu le */
/* 20030309103020 a cause de 'v $xrs/bKlein.51$I d_FQUATRE'. */
#define d_EN \
d_FCONSTANTES
#define d_PI \
d_FCONSTANTES
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E R I V E E D E S V A R I A B L E S : */
/* */
/*************************************************************************************************************************************/
#define d_VARIABLES_DE_DERIVATION \
UN
#define d_FVARIABLES_DE_DERIVATION \
FU
#define d_VARIABLES_MUETTES \
ZERO
#define d_FVARIABLES_MUETTES \
FZERO
/* Elles sont egales a 1 ou a 0 suivant que l'on derive ou non par rapport a elles */
/* (introduites le 20101222105716). */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E R I V E E S D E S O P E R A T E U R S D E B A S E : */
/* */
/*************************************************************************************************************************************/
#define d_PARE(x) \
PARE(d#x) \
/* Derivee de la fonction de parenthesage : */ \
/* */ \
/* d(parenthese(x)) = parenthese(d(x)) */ \
/* */
#define d_NEUT(x) \
NEUT(d#x) \
/* Derivee de la fonction neutre : */ \
/* */ \
/* d(neutre(x)) = neutre(d(x)) */ \
/* */
#define d_CAST(type,x) \
CAST(type,d#x) \
/* Derivee des diverses fonction de conversion : */ \
/* */ \
/* d(cast(x)) = cast(d(x)) */ \
/* */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N D E S U N I T E S D ' I N F O R M A T I O N : */
/* */
/*************************************************************************************************************************************/
#define BIT0 \
ZERO \
/* Numero du premier bit d'un mot. */
#define BIT7 \
LSTX(BIT0,NBITOC) \
/* Numero du dernier bit d'un octet (introduit le 20130707102427). */
#define BITSIG \
BIT0 \
/* Bit de signe d'un mot. */
#define k___NBITHX \
QUATRE \
/* Nombre de bits dans un chiffre hexa-decimal. */ \
/* */ \
/* ATTENTION : la constante 'NBITHX' est pre-generee dans '$xcp/Konstantes$K'. */
#define k___NHXOC \
DEUX \
/* Nombre de chifres hexa-decimaux par octet (introduit le 20130705131934...). */
#define k___NBITOC \
bMUL(NHXOC,NBITHX) \
/* Nombre de bits contenus dans un octet (un octet contient 2 chiffres hexa-decimaux). */ \
/* */ \
/* ATTENTION : la constante 'NBITOC' est pre-generee dans '$xcp/Konstantes$K'. */ \
/* */ \
/* Le 'bDOU(...)' a remplace 'DOUB(...)' le 20100319080932 lors de la mise en place de */ \
/* 'DOUBLE_PRECISION' en ce qui concerne 'PRECISION_DU_Int' car, en effet, la constante */ \
/* 'NBITOC' doit etre absolue, ce qui n'etait plus le cas lors de l'utilisation de */ \
/* 'USs_GooF______CONDITIONNEL(...)' (voir la fonction 'v $xiii/mono_image$FON Ftrefle')... */
@if ( (! defined(SYSTEME_CRAY2_UNICOS)) \
&& (! defined(SYSTEME_CRAYC98_UNICOS)) \
&& (! defined(SYSTEME_CRAYC916_UNICOS)) \
&& (! defined(SYSTEME_CRAYYMP1_UNICOS)) \
&& (! defined(SYSTEME_CRAYYMP2_UNICOS)) \
&& (! defined(SYSTEME_CRAYYMP4_UNICOS)) \
)
@ if (PRECISION_DU_Int==SIMPLE_PRECISION)
@ define NOCMO QUATRE
/* Nombre d'octets par mot. ATTENTION : pas de '\' ci dessus a cause du '@'... */
/* */
/* Introduit sous cette forme le 20100317161407... */
@ Aif (PRECISION_DU_Int==SIMPLE_PRECISION)
@ if (PRECISION_DU_Int==DOUBLE_PRECISION)
@ define NOCMO HUIT
/* Nombre d'octets par mot. ATTENTION : pas de '\' ci dessus a cause du '@'... */
/* */
/* Introduit sous cette forme le 20100317161407... */
@ Aif (PRECISION_DU_Int==DOUBLE_PRECISION)
@ message "ATTENTION : le nombre d'octets par mot va etre defini arbitrairement."
@ define NOCMO QUATRE
/* Nombre d'octets par mot. ATTENTION : pas de '\' ci dessus a cause du '@'... */
@ Eif (PRECISION_DU_Int==DOUBLE_PRECISION)
@ Eif (PRECISION_DU_Int==SIMPLE_PRECISION)
@Aif ( (! defined(SYSTEME_CRAY2_UNICOS)) \
&& (! defined(SYSTEME_CRAYC98_UNICOS)) \
&& (! defined(SYSTEME_CRAYC916_UNICOS)) \
&& (! defined(SYSTEME_CRAYYMP1_UNICOS)) \
&& (! defined(SYSTEME_CRAYYMP2_UNICOS)) \
&& (! defined(SYSTEME_CRAYYMP4_UNICOS)) \
)
@ define NOCMO HUIT
/* Introduit sous cette forme le 20100317161407... */
@Eif ( (! defined(SYSTEME_CRAY2_UNICOS)) \
&& (! defined(SYSTEME_CRAYC98_UNICOS)) \
&& (! defined(SYSTEME_CRAYC916_UNICOS)) \
&& (! defined(SYSTEME_CRAYYMP1_UNICOS)) \
&& (! defined(SYSTEME_CRAYYMP2_UNICOS)) \
&& (! defined(SYSTEME_CRAYYMP4_UNICOS)) \
)
#if ( (defined(BUG_SYSTEME_SYSTEME_APC_LinuxDebian_GCC_numero_de_port)) \
|| (defined(BUG_SYSTEME_SYSTEME_APC_LinuxMandrake_GCC_numero_de_port)) \
|| (defined(BUG_SYSTEME_SYSTEME_APC_LinuxRedHat_GCC_numero_de_port)) \
|| (defined(BUG_SYSTEME_SYSTEME_APC_LinuxUbuntu_GCC_numero_de_port)) \
|| (defined(BUG_SYSTEME_SYSTEME_APC_LinuxUbuntu_ICC_numero_de_port)) \
|| (defined(BUG_SYSTEME_SYSTEME_APC_LinuxUlmint_GCC_numero_de_port)) \
|| (defined(BUG_SYSTEME_SYSTEME_APC_LinuxUlmint_ICC_numero_de_port)) \
)
Dunion_02(PERMUTATION_2_A_2_DES_OCTETS_D_UN_MOT
,DEFV(Positive,nombre_entier)
,DEFV(CHAR,gDTb1(octets,NOCMO))
,NOM_VIDE
);
Typedef(permutation_2_a_2_des_octets_d_un_mot,UNIO(PERMUTATION_2_A_2_DES_OCTETS_D_UN_MOT))
/* Structure mettant en parallele un 'Int' et les 'CHAR's qui le composent. On notera */
/* l'utilisation de 'gDTb1(...)' et non pas de 'DTb1(...)' car sinon, cela pose des */
/* problemes de compilation a cause de la procedure 'DIME(...)' appelee par 'DTb1(...)'... */
#Aif ( (defined(BUG_SYSTEME_SYSTEME_APC_LinuxDebian_GCC_numero_de_port)) \
|| (defined(BUG_SYSTEME_SYSTEME_APC_LinuxMandrake_GCC_numero_de_port)) \
|| (defined(BUG_SYSTEME_SYSTEME_APC_LinuxRedHat_GCC_numero_de_port)) \
|| (defined(BUG_SYSTEME_SYSTEME_APC_LinuxUbuntu_GCC_numero_de_port)) \
|| (defined(BUG_SYSTEME_SYSTEME_APC_LinuxUbuntu_ICC_numero_de_port)) \
|| (defined(BUG_SYSTEME_SYSTEME_APC_LinuxUlmint_GCC_numero_de_port)) \
|| (defined(BUG_SYSTEME_SYSTEME_APC_LinuxUlmint_ICC_numero_de_port)) \
)
#Eif ( (defined(BUG_SYSTEME_SYSTEME_APC_LinuxDebian_GCC_numero_de_port)) \
|| (defined(BUG_SYSTEME_SYSTEME_APC_LinuxMandrake_GCC_numero_de_port)) \
|| (defined(BUG_SYSTEME_SYSTEME_APC_LinuxRedHat_GCC_numero_de_port)) \
|| (defined(BUG_SYSTEME_SYSTEME_APC_LinuxUbuntu_GCC_numero_de_port)) \
|| (defined(BUG_SYSTEME_SYSTEME_APC_LinuxUbuntu_ICC_numero_de_port)) \
|| (defined(BUG_SYSTEME_SYSTEME_APC_LinuxUlmint_GCC_numero_de_port)) \
|| (defined(BUG_SYSTEME_SYSTEME_APC_LinuxUlmint_ICC_numero_de_port)) \
)
#define k___NOCHW \
bMOI(NOCMO) \
/* Nombre d'octets par demi-mot. */ \
/* */ \
/* ATTENTION : la constante 'NOCHW' est pre-generee dans '$xcp/Konstantes$K'. */ \
/* */ \
/* Le 'bMOI(...)' a remplace 'MOIT(...)' le 20100319080932 lors de la mise en place de */ \
/* 'DOUBLE_PRECISION' en ce qui concerne 'PRECISION_DU_Int' car, en effet, la constante */ \
/* 'NOCHW' doit etre absolue, ce qui n'etait plus le cas lors de l'utilisation de */ \
/* 'USs_GooF______CONDITIONNEL(...)' (voir la fonction 'v $xiii/mono_image$FON Ftrefle')... */
#define k___NBITHW \
bMUL(NBITOC,NOCHW) \
/* Nombre de bits dans un demi-mot. */ \
/* */ \
/* ATTENTION : la constante 'NBITHW' est pre-generee dans '$xcp/Konstantes$K'. */
#define k___NBITMO \
bMUL(NBITOC,NOCMO) \
/* Nombre de bits dans un mot. */ \
/* */ \
/* ATTENTION : la constante 'NBITMO' est pre-generee dans '$xcp/Konstantes$K'. */
#define k___NCHXOC \
bDIV(NBITOC,NBITHX) \
/* Nombre de chiffres hexa-decimaux par octet (introduit le 20120329135054)... */ \
/* */ \
/* ATTENTION : la constante 'NCHXOC' est pre-generee dans '$xcp/Konstantes$K'. */
#define k___NCHXMO \
bDIV(NBITMO,NBITHX) \
/* Nombre de chiffres hexa-decimaux par mot (introduit le 20051210174645)... */ \
/* */ \
/* ATTENTION : la constante 'NCHXMO' est pre-generee dans '$xcp/Konstantes$K'. */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* " P R E - G E N E R A T I O N " D E S C O N S T A N T E S F O N D A M E N T A L E S : */
/* */
/*************************************************************************************************************************************/
#TestADef NOCHW \
k___NOCHW
#TestADef NBITHX \
k___NBITHX
#TestADef NHXOC \
k___NHXOC
#TestADef NBITOC \
k___NBITOC
#TestADef NBITHW \
k___NBITHW
#TestADef NBITMO \
k___NBITMO
#TestADef NCHXOC \
k___NCHXOC
#TestADef NCHXMO \
k___NCHXMO
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* F O R M A T S E N M E M O I R E : */
/* */
/*************************************************************************************************************************************/
#define Format_char \
ZERO \
/* Format "CHAR". */
#define Format_int \
(Format_char+I) \
/* Format "Int". ATTENTION : on ne peut utiliser ni 'Enum', ni 'ADD2', */ \
/* ni 'PARE' pour le definir, et ce a cause des "#if" qui le reference... */
#define Format_float \
(Format_int+I) \
/* Format "Float". ATTENTION : on ne peut utiliser ni 'Enum', ni 'ADD2', */ \
/* ni 'PARE' pour le definir, et ce a cause des "#if" qui le reference... */
#define Format_double \
(Format_float+I) \
/* Format "Double". ATTENTION : on ne peut utiliser ni 'Enum', ni 'ADD2', */ \
/* ni 'PARE' pour le definir, et ce a cause des "#if" qui le reference... */
#define Format_complexe \
(Format_double+I) \
/* Format "complexe". ATTENTION : on ne peut utiliser ni 'Enum', ni 'ADD2', */ \
/* ni 'PARE' pour le definir, et ce a cause des "#if" qui le reference... */
#define Format_hyper_complexe \
(Format_complexe+I) \
/* Format "hyper-complexe". ATTENTION : on ne peut utiliser ni 'Enum', ni 'ADD2', */ \
/* ni 'PARE' pour le definir, et ce a cause des "#if" qui le reference... */
#define Format_hyper_hyper_complexe \
(Format_hyper_complexe+I) \
/* Format "hyper-hyper-complexe". ATTENTION : on ne peut utiliser ni 'Enum', ni 'ADD2', */ \
/* ni 'PARE' pour le definir, et ce a cause des "#if" qui le reference (introduit */ \
/* le 20150227105517). */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* R E G L E S D ' I N D E X A T I O N : */
/* */
/*************************************************************************************************************************************/
#define INDX(index,minimum_de_l_index) \
INTE(bADD(INDEX0,bSOU(index,minimum_de_l_index))) \
/* Cette fonction permet de calculer un index de type "C" dans un */ \
/* vecteur que l'on considere comme etant [minimum_de_l_index,...] ; on a : */ \
/* */ \
/* INDX(x,min) = x-min */ \
/* */
#define INVX(index,minimum_de_l_index,maximum_de_l_index) \
bADD(minimum_de_l_index,bSOU(maximum_de_l_index,index)) \
/* "Inversion" d'un index : */ \
/* */ \
/* INVX(x,min,max) = min + (max - x) */ \
/* */ \
/* Cette procedure a ete introduite le 20000204172501 pour 'v $xrv/tri.11$K INVX'. */
#define TRMU(nombre_d_elements) \
INDX(nombre_d_elements,BEGIN_AT_0) \
/* Cette fonction est la fonction "piquet" --> "intervalle" ; elle permet de passer */ \
/* d'un nombre d'elements (qui peut etre considere comme un index commencant a Z=1) */ \
/* a un index commencant a INDEX0=0 ; on a : */ \
/* */ \
/* TRMU(n) = n-1 */ \
/* */
#define TRPU(index) \
bADD(index,BEGIN_AT_0) \
/* Fonction inverse de 'TRMU' ; on a : */ \
/* */ \
/* TRPU(x) = x+1 */ \
/* */
#define LSTX(minimum_de_l_index,nombre_d_elements) \
bADD(minimum_de_l_index,TRMU(nombre_d_elements)) \
/* Cette fonction permet de calculer l'indice logique du dernier element */ \
/* d'un vecteur dont on se donne l'indice logique du premier element */ \
/* et le nombre d'elements (ou longueur) ; on a : */ \
/* */ \
/* LSTX(min,n) = min+n-1 */ \
/* = max (de 'NBRE(max,min)' ci-apres) */ \
/* */
#define NBRE(minimum_de_l_index,maximum_de_l_index) \
TRPU(bSOU(maximum_de_l_index,minimum_de_l_index)) \
/* Cette fonction permet de compter le nombre d'elements d'un vecteur dont on se donne */ \
/* les indices logiques du premier et du dernier element ; on a : */ \
/* */ \
/* NBRE(max,min) = (max-min)+1 */ \
/* = n (de 'LSTX(min,n)' ci-dessus) */ \
/* */
#define CONX(index,ancien_minimum_de_l_index,nouveau_minimum_de_l_index) \
bADD(bSOU(index,ancien_minimum_de_l_index),nouveau_minimum_de_l_index) \
/* Pour passer d'une indexation [ancien,...] a une indexation [nouveau,...]. */
#define LENG(origine,extremite) \
TRPU(SOUA(extremite,origine)) \
/* Afin de calculer la longueur du segment [origine,extremite] bornes incluses, */ \
/* */ \
/* LENG(max,min) = |(max-min)|+1 */ \
/* */ \
/* mais ATTENTION a la valeur absolue 'ABSO'... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* O P E R A T I O N S L O G I Q U E S B I N A I R E S ( B I T A B I T ) : */
/* */
/*************************************************************************************************************************************/
#define OUI03(a,b,c) \
OUIN(OUIN(a,b),c)
#define OUI04(a,b,c,d) \
OUIN(OUI03(a,b,c),d)
#define OUI05(a,b,c,d,e) \
OUIN(OUI04(a,b,c,d),e)
#define OUI06(a,b,c,d,e,f) \
OUIN(OUI05(a,b,c,d,e),f)
#define OUI07(a,b,c,d,e,f,g) \
OUIN(OUI06(a,b,c,d,e,f),g)
#define OUI08(a,b,c,d,e,f,g,h) \
OUIN(OUI07(a,b,c,d,e,f,g),h)
#define OUI09(a,b,c,d,e,f,g,h,i) \
OUIN(OUI08(a,b,c,d,e,f,g,h),i)
#define OUI10(a,b,c,d,e,f,g,h,i,j) \
OUIN(OUI09(a,b,c,d,e,f,g,h,i),j)
#define OUI11(a,b,c,d,e,f,g,h,i,j,k) \
OUIN(OUI10(a,b,c,d,e,f,g,h,i,j),k)
#define OUI12(a,b,c,d,e,f,g,h,i,j,k,l) \
OUIN(OUI11(a,b,c,d,e,f,g,h,i,j,k),l)
#define OUI13(a,b,c,d,e,f,g,h,i,j,k,l,m) \
OUIN(OUI12(a,b,c,d,e,f,g,h,i,j,k,l),m)
#define OUI14(a,b,c,d,e,f,g,h,i,j,k,l,m,n) \
OUIN(OUI13(a,b,c,d,e,f,g,h,i,j,k,l,m),n)
#define OUI15(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o) \
OUIN(OUI14(a,b,c,d,e,f,g,h,i,j,k,l,m,n),o)
#define OUI16(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p) \
OUIN(OUI15(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o),p)
#define OUI17(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q) \
OUIN(OUI16(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p),q)
#define OUI18(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r) \
OUIN(OUI17(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q),r)
#define OUI19(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s) \
OUIN(OUI18(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r),s)
/* La fonction 'OUI03(...)' est introduite afin de "symetriser" les ou inclusifs a 3 */
/* facteurs. Et cela fut etendu le 20170621181337 avec 'OUI4(...)', 'OUI5(...)',... */
/* */
/* Le 20170722143225, les noms 'OUIi(...)' ont ete etendus en 'OUI0i(...)' afin de */
/* permettre l'introduction des procedures 'OUI1i(...)' le 20170723083840... */
#define OUE03(a,b,c) \
OUEX(OUEX(a,b),c)
#define OUE04(a,b,c,d) \
OUEX(OUE03(a,b,c),d)
#define OUE05(a,b,c,d,e) \
OUEX(OUE04(a,b,c,d),e)
#define OUE06(a,b,c,d,e,f) \
OUEX(OUE05(a,b,c,d,e),f)
#define OUE07(a,b,c,d,e,f,g) \
OUEX(OUE06(a,b,c,d,e,f),g)
#define OUE08(a,b,c,d,e,f,g,h) \
OUEX(OUE07(a,b,c,d,e,f,g),h)
#define OUE09(a,b,c,d,e,f,g,h,i) \
OUEX(OUE08(a,b,c,d,e,f,g,h),i)
#define OUE10(a,b,c,d,e,f,g,h,i,j) \
OUEX(OUE09(a,b,c,d,e,f,g,h,i),j)
#define OUE11(a,b,c,d,e,f,g,h,i,j,k) \
OUEX(OUE10(a,b,c,d,e,f,g,h,i,j),k)
#define OUE12(a,b,c,d,e,f,g,h,i,j,k,l) \
OUEX(OUE11(a,b,c,d,e,f,g,h,i,j,k),l)
#define OUE13(a,b,c,d,e,f,g,h,i,j,k,l,m) \
OUEX(OUE12(a,b,c,d,e,f,g,h,i,j,k,l),m)
#define OUE14(a,b,c,d,e,f,g,h,i,j,k,l,m,n) \
OUEX(OUE13(a,b,c,d,e,f,g,h,i,j,k,l,m),n)
#define OUE15(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o) \
OUEX(OUE14(a,b,c,d,e,f,g,h,i,j,k,l,m,n),o)
#define OUE16(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p) \
OUEX(OUE15(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o),p)
#define OUE17(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q) \
OUEX(OUE16(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p),q)
#define OUE18(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r) \
OUEX(OUE17(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q),r)
#define OUE19(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s) \
OUEX(OUE18(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r),s)
/* Les fonctions 'OUEi(...)' ont ete introduites le 20170621181337 par symetrie avec */
/* les fonctions 'OUIi(...)'... */
/* */
/* Le 20170722143225, les noms 'OUEi(...)' ont ete etendus en 'OUE0i(...)' afin de */
/* permettre l'introduction des procedures 'OUE1i(...)' le 20170723083840... */
#define ETL03(a,b,c) \
ETLO(ETLO(a,b),c)
#define ETL04(a,b,c,d) \
ETLO(ETL03(a,b,c),d)
#define ETL05(a,b,c,d,e) \
ETLO(ETL04(a,b,c,d),e)
#define ETL06(a,b,c,d,e,f) \
ETLO(ETL05(a,b,c,d,e),f)
#define ETL07(a,b,c,d,e,f,g) \
ETLO(ETL06(a,b,c,d,e,f),g)
#define ETL08(a,b,c,d,e,f,g,h) \
ETLO(ETL07(a,b,c,d,e,f,g),h)
#define ETL09(a,b,c,d,e,f,g,h,i) \
ETLO(ETL08(a,b,c,d,e,f,g,h),i)
#define ETL10(a,b,c,d,e,f,g,h,i,j) \
ETLO(ETL09(a,b,c,d,e,f,g,h,i),j)
#define ETL11(a,b,c,d,e,f,g,h,i,j,k) \
ETLO(ETL10(a,b,c,d,e,f,g,h,i,j),k)
#define ETL12(a,b,c,d,e,f,g,h,i,j,k,l) \
ETLO(ETL11(a,b,c,d,e,f,g,h,i,j,k),l)
#define ETL13(a,b,c,d,e,f,g,h,i,j,k,l,m) \
ETLO(ETL12(a,b,c,d,e,f,g,h,i,j,k,l),m)
#define ETL14(a,b,c,d,e,f,g,h,i,j,k,l,m,n) \
ETLO(ETL13(a,b,c,d,e,f,g,h,i,j,k,l,m),n)
#define ETL15(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o) \
ETLO(ETL14(a,b,c,d,e,f,g,h,i,j,k,l,m,n),o)
#define ETL16(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p) \
ETLO(ETL15(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o),p)
#define ETL17(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q) \
ETLO(ETL16(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p),q)
#define ETL18(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r) \
ETLO(ETL17(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q),r)
#define ETL19(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s) \
ETLO(ETL18(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r),s)
/* Les fonctions 'ETLi(...)' ont ete introduites le 20170621181337 par symetrie avec */
/* les fonctions 'OUIi(...)'... */
/* */
/* Le 20170722143225, les noms 'ETLi(...)' ont ete etendus en 'ETL0i(...)' afin de */
/* permettre l'introduction des procedures 'ETL1i(...)' le 20170723083840... */
#define COMK(masque) \
OUEX(masque,MMOT) \
/* Obtention du masque complementaire du masque "masque" ; cette fonction */ \
/* vaut en fait pour toute valeur logique. */
#define PARI(x) \
ETLO(x,BIT) \
/* Donne la parite de 'x'. */
#define MASQUE___SET_BIT(masque,bit) \
OUIN(masque,bit) \
/* Mise a 1 d'un bit dans un masque (introduit le 20021109231715 pour des raisons de */ \
/* symetrie avec 'MASQUE_RESET_BIT(...)'. */
#define MASQUE_RESET_BIT(masque,bit) \
OUEX(MASQUE___SET_BIT(masque,bit),bit) \
/* Mise a 0 d'un bit dans un masque (introduit le 20021109231715 pour resoudre un probleme */ \
/* dans 'v $xcp/substitue.01$K MASQUE_RESET_BIT'). */
#define MASQUE__TEST_BIT(masque,bit) \
IFEQ(ETLO(masque,bit),bit) \
/* Test d'un bit a 1 dans un masque (introduit le 20021205134215 pour etre utilise dans */ \
/* 'v $xcp/substitue.01$K MASQUE__TEST_BIT'). */
#define MASQUE_NTEST_BIT(masque,bit) \
IFNE(ETLO(masque,bit),bit) \
/* Test d'un bit a 0 dans un masque (introduit le 20021206095002 pour etre utilise dans */ \
/* 'v $xcp/substitue.01$K MASQUE__TEST_BIT'). */
#define AMPLITUDE_DE_CADRAGE_A_DROITE_D_UN_MASQUE(masque) \
INTE(LO2X(bADD(OUEX(OUIN(bADD(OUEX(masque,MMOT),BIT),masque),MMOT),BIT))) \
/* Permet de connaitre le decalage cadrant a droite un masque (c'est-a-dire de facon a ce */ \
/* qu'il n'y ait plus de bits '0' a droite). Ceci a ete introduit le 20030105105120 pour */ \
/* 'v $xiidX/fonct$vv$FON AMPLITUDE_DE_CADRAGE_A_DROITE_D_UN_MASQUE'. */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* O P E R A T I O N S D E D E C A L A G E : */
/* */
/*************************************************************************************************************************************/
#define gDecalage_bit(numero_de_bit,nombre_de_bits) \
bSOU(bSOU(nombre_de_bits,B),REST(numero_de_bit,nombre_de_bits))
#define Decalage_bit_octet(numero_de_bit) \
gDecalage_bit(numero_de_bit,NBITOC)
#define Decalage_bit_mot(numero_de_bit) \
gDecalage_bit(numero_de_bit,NBITMO)
/* Cette fonction convertit un numero de bit (le bit 0 etant le bit de */
/* gauche) en une amplitude de decalage a droite. */
#if ( ((defined(SYSTEME_CRAY2_UNICOS_CC))) \
|| ((defined(SYSTEME_CRAY2_UNICOS_SCC))) \
|| ((defined(SYSTEME_CRAYC98_UNICOS_CC))) \
|| ((defined(SYSTEME_CRAYC98_UNICOS_SCC))) \
|| ((defined(SYSTEME_CRAYC916_UNICOS_CC))) \
|| ((defined(SYSTEME_CRAYC916_UNICOS_SCC))) \
|| ((defined(SYSTEME_CRAYYMP1_UNICOS_CC))) \
|| ((defined(SYSTEME_CRAYYMP1_UNICOS_SCC))) \
|| ((defined(SYSTEME_CRAYYMP2_UNICOS_CC))) \
|| ((defined(SYSTEME_CRAYYMP2_UNICOS_SCC))) \
|| ((defined(SYSTEME_CRAYYMP4_UNICOS_CC))) \
|| ((defined(SYSTEME_CRAYYMP4_UNICOS_SCC))) \
|| ((defined(SYSTEME_HP705_HPUX_CC))) \
|| ((defined(SYSTEME_HP710_HPUX_CC))) \
|| ((defined(SYSTEME_HP720_HPUX_CC))) \
|| ((defined(SYSTEME_HP750_HPUX_CC))) \
|| ((defined(SYSTEME_HP755_HPUX_CC))) \
|| ((defined(SYSTEME_HP819_HPUX_CC))) \
|| ((defined(SYSTEME_NWS3000_NEWSOS_CC))) \
|| ((defined(SYSTEME_NWS3000_NEWSOS_2CC))) \
)
# TestADef BUG_SYSTEME_C_SARS \
/* Les decalages hardwares a droite et a gauche sont 'zero fill', et ne sont pas simules */ \
/* par le compilateur ; ils doivent donc l'etre par l'utilisateur... */ \
/* */ \
/* ATTENTION : on notera que ce defaut n'apparait pas sur les 'SYSTEME_SG4D..._IRIX_CC' */ \
/* alors qu'il apparait sur 'SYSTEME_NWS3000_NEWSOS', ce qui est paradoxal, puisque */ \
/* theoriquement, il s'agit la du meme compilateur ('Mips'). */ \
/* */ \
/* ATTENTION : voir le commentaire associe a la definition de 'SIZE_GENERAL(...)'. */
#Aif ( ((defined(SYSTEME_CRAY2_UNICOS_CC))) \
|| ((defined(SYSTEME_CRAY2_UNICOS_SCC))) \
|| ((defined(SYSTEME_CRAYC98_UNICOS_CC))) \
|| ((defined(SYSTEME_CRAYC98_UNICOS_SCC))) \
|| ((defined(SYSTEME_CRAYC916_UNICOS_CC))) \
|| ((defined(SYSTEME_CRAYC916_UNICOS_SCC))) \
|| ((defined(SYSTEME_CRAYYMP1_UNICOS_CC))) \
|| ((defined(SYSTEME_CRAYYMP1_UNICOS_SCC))) \
|| ((defined(SYSTEME_CRAYYMP2_UNICOS_CC))) \
|| ((defined(SYSTEME_CRAYYMP2_UNICOS_SCC))) \
|| ((defined(SYSTEME_CRAYYMP4_UNICOS_CC))) \
|| ((defined(SYSTEME_CRAYYMP4_UNICOS_SCC))) \
|| ((defined(SYSTEME_HP705_HPUX_CC))) \
|| ((defined(SYSTEME_HP710_HPUX_CC))) \
|| ((defined(SYSTEME_HP720_HPUX_CC))) \
|| ((defined(SYSTEME_HP750_HPUX_CC))) \
|| ((defined(SYSTEME_HP755_HPUX_CC))) \
|| ((defined(SYSTEME_HP819_HPUX_CC))) \
|| ((defined(SYSTEME_NWS3000_NEWSOS_CC))) \
|| ((defined(SYSTEME_NWS3000_NEWSOS_2CC))) \
)
#Eif ( ((defined(SYSTEME_CRAY2_UNICOS_CC))) \
|| ((defined(SYSTEME_CRAY2_UNICOS_SCC))) \
|| ((defined(SYSTEME_CRAYC98_UNICOS_CC))) \
|| ((defined(SYSTEME_CRAYC98_UNICOS_SCC))) \
|| ((defined(SYSTEME_CRAYC916_UNICOS_CC))) \
|| ((defined(SYSTEME_CRAYC916_UNICOS_SCC))) \
|| ((defined(SYSTEME_CRAYYMP1_UNICOS_CC))) \
|| ((defined(SYSTEME_CRAYYMP1_UNICOS_SCC))) \
|| ((defined(SYSTEME_CRAYYMP2_UNICOS_CC))) \
|| ((defined(SYSTEME_CRAYYMP2_UNICOS_SCC))) \
|| ((defined(SYSTEME_CRAYYMP4_UNICOS_CC))) \
|| ((defined(SYSTEME_CRAYYMP4_UNICOS_SCC))) \
|| ((defined(SYSTEME_HP705_HPUX_CC))) \
|| ((defined(SYSTEME_HP710_HPUX_CC))) \
|| ((defined(SYSTEME_HP720_HPUX_CC))) \
|| ((defined(SYSTEME_HP750_HPUX_CC))) \
|| ((defined(SYSTEME_HP755_HPUX_CC))) \
|| ((defined(SYSTEME_HP819_HPUX_CC))) \
|| ((defined(SYSTEME_NWS3000_NEWSOS_CC))) \
|| ((defined(SYSTEME_NWS3000_NEWSOS_2CC))) \
)
#define SARS(champ,amplitude) \
DECD(INTE(champ),amplitude) \
/* Decalage arithmetique a droite. */
#if ( (defined(BUG_SYSTEME_C_SARS)) \
)
# undef SARS
# define SARS(champ,amplitude) \
COND(IZGE(champ) \
,SLRS(champ,amplitude) \
,COMK(SLRS(COMK(champ),amplitude)) \
) \
/* Decalage arithmetique a droite sur les SYSTEMEs 'zero fill'... */ \
/* */ \
/* ATTENTION : voir le commentaire associe a la definition de 'SIZE_GENERAL(...)'. */
#Aif ( (defined(BUG_SYSTEME_C_SARS)) \
)
#Eif ( (defined(BUG_SYSTEME_C_SARS)) \
)
#define SALS(champ,amplitude) \
DECG(INTE(champ),amplitude) \
/* Decalage arithmetique a gauche. */
#define SLRS(champ,amplitude) \
DECD(POSI(champ),amplitude) \
/* Decalage logique a droite. */
#define SLLS(champ,amplitude) \
DECG(POSI(champ),amplitude) \
/* Decalage logique a gauche ; pour etre logique et consistant avec la definition de */ \
/* 'SLRS(...)', il conviendrait de definir 'SLLS(...)' par : */ \
/* */ \
/* #define SLLS(champ,amplitude) \ */ \
/* DECG(POSI(champ),amplitude) */ \
/* */ \
/* En fait, tous les systemes, sauf 'SYSTEME_SG4D..._IRIX_CC' permettent l'utilisation de */ \
/* 'POSI(...)'. Mais dans la mesure ou l'on souhaite generer parfois des fichiers */ \
/* "bootstrapables" de type '$c' qui soient portables sur des machines arbitraires, il faut */ \
/* choisir la solution qui soit compatible avec le maximum de systemes, et comme le systeme */ \
/* REFERENCE 'SYSTEME_DPX5000_SPIX_CC' autorise 'INTE(...)', on adopte cette solution */ \
/* partout... */ \
/* */ \
/* Le 20200501110041, j'ai remplace (tres tardivement, certainement plus de dix ans, mais */ \
/* cela prouve que ces operations servent tres tres tres peu...) le 'INTE(...)' par un */ \
/* 'POSI(...)' car, en effet, a cette date, lors de la compilation de 'v $xtKg/gMASQUE$K', */ \
/* je decouvre par accident que 'v $xil/defi_K2$vv$DEF gMASQUE' de meme que */ \
/* 'v '$xiiD/definit.1$DEF DEMULTIPLEXAGE_BVR_888_' ne fonctionnaient pas correctement */ \
/* sur '$CMAP28', '$LACT19', '$LACT1A',... */
#define SCRS(champ,amplitude) \
OUIN(SLRS(champ,amplitude) \
,SLLS(champ,bSOU(NBITMO,amplitude)) \
) \
/* Decalage circulaire a droite. */
#define SCLS(champ,amplitude) \
OUIN(SLLS(champ,amplitude) \
,SLRS(champ,bSOU(NBITMO,amplitude)) \
) \
/* Decalage circulaire a gauche. */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* O P E R A T I O N S S U R B I T S D A N S U N E C H A I N E D E B I T S : */
/* */
/*************************************************************************************************************************************/
/* Ces procedures Generales ont ete introduites le 20130703110203... */
#define gTBIT(chaine,numero_de_bit,decalage) \
COND(IFEQ(ETLO(SLRS(chaine,decalage(numero_de_bit)),BIT),BIT),EXIST,NEXIST) \
/* Test d'un bit dans une chaine contenue dans un mot. */
#define gSBIT(chaine,numero_de_bit,decalage) \
OUIN(chaine,SLLS(BIT,decalage(numero_de_bit))) \
/* Mise d'un bit a 1 dans une chaine contenue dans un mot. */
#define gIBIT(chaine,numero_de_bit,decalage) \
OUEX(chaine,SLLS(BIT,decalage(numero_de_bit))) \
/* Inversion d'un bit dans une chaine contenue dans un mot. */
#define gRBIT(chaine,numero_de_bit,decalage) \
gIBIT(gSBIT(chaine,numero_de_bit,decalage),numero_de_bit,decalage) \
/* Mise d'un bit a 0 dans une chaine contenue dans un mot. */
#define gCBIT(chaine,numero_de_bit,decalage,condition_d_existence) \
COND(PRESENT(condition_d_existence) \
,gSBIT(chaine,numero_de_bit,decalage) \
,COND(PAS_PRESENT(condition_d_existence) \
,gRBIT(chaine,numero_de_bit,decalage) \
,chaine \
) \
) \
/* Mise d'un bit a 0/1 dans une chaine contenue dans un mot suivant que la condition est */ \
/* NEXIST/EXIST, valeurs obtenues par exemple par 'TBIT'. */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* O P E R A T I O N S S U R B I T S D A N S U N O C T E T : */
/* */
/*************************************************************************************************************************************/
#define TBITo(octet,numero_de_bit) \
gTBIT(octet,numero_de_bit,Decalage_bit_octet) \
/* Test d'un bit dans une chaine contenue dans un octet (introduit le 20130702092445). */
#define SBITo(octet,numero_de_bit) \
gSBIT(octet,numero_de_bit,Decalage_bit_octet) \
/* Mise d'un bit a 1 dans une chaine contenue dans un octet (introduit le 20130702092445). */
#define IBITo(octet,numero_de_bit) \
gIBIT(octet,numero_de_bit,Decalage_bit_octet) \
/* Inversion d'un bit dans une chaine contenue dans un octet (introduit le 20130702092445). */
#define RBITo(octet,numero_de_bit) \
gRBIT(octet,numero_de_bit,Decalage_bit_octet) \
/* Mise d'un bit a 0 dans une chaine contenue dans un octet (introduit le 20130702092445). */
#define CBITo(octet,numero_de_bit,condition_d_existence) \
gCBIT(octet,numero_de_bit,Decalage_bit_octet,condition_d_existence) \
/* Mise d'un bit a 0/1 dans une chaine contenue dans un mot suivant que la condition est */ \
/* NEXIST/EXIST, valeurs obtenues par exemple par 'TBIT' (introduit le 20130703110203). */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* O P E R A T I O N S S U R B I T S D A N S U N M O T : */
/* */
/*************************************************************************************************************************************/
#define TBIT(mot,numero_de_bit) \
gTBIT(mot,numero_de_bit,Decalage_bit_mot) \
/* Test d'un bit dans une chaine contenue dans un mot. */
#define SBIT(mot,numero_de_bit) \
gSBIT(mot,numero_de_bit,Decalage_bit_mot) \
/* Mise d'un bit a 1 dans une chaine contenue dans un mot. */
#define IBIT(mot,numero_de_bit) \
gIBIT(mot,numero_de_bit,Decalage_bit_mot) \
/* Inversion d'un bit dans une chaine contenue dans un mot. */
#define RBIT(mot,numero_de_bit) \
gRBIT(mot,numero_de_bit,Decalage_bit_mot) \
/* Mise d'un bit a 0 dans une chaine contenue dans un mot. */
#define CBIT(mot,numero_de_bit,condition_d_existence) \
gCBIT(mot,numero_de_bit,Decalage_bit_mot,condition_d_existence) \
/* Mise d'un bit a 0/1 dans une chaine contenue dans un mot suivant que la condition est */ \
/* NEXIST/EXIST, valeurs obtenues par exemple par 'TBIT'. */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N D E S B L O C S : */
/* */
/*************************************************************************************************************************************/
#define Bblock \
BEGIN
#define Eblock \
END
#define begin_nouveau_block \
Bblock
#define end_nouveau_block \
Eblock
/* Ceci a ete introduit le 20030124092944 pour 'v $xiii/di_image$FON begin_nouveau_block', */
/* et ce afin de faciliter la creation de variables locales... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N D E " P S E U D O - B L O C S " D E V A L I D A T I O N */
/* D E S T R U C T U R A T I O N D E S P R O G R A M M E S : */
/* */
/*************************************************************************************************************************************/
#if ( ((defined(SYSTEME_CRAY2_UNICOS_CC))) \
|| ((defined(SYSTEME_CRAY2_UNICOS_SCC))) \
|| ((defined(SYSTEME_CRAYC98_UNICOS_CC))) \
|| ((defined(SYSTEME_CRAYC98_UNICOS_SCC))) \
|| ((defined(SYSTEME_CRAYC916_UNICOS_CC))) \
|| ((defined(SYSTEME_CRAYC916_UNICOS_SCC))) \
|| ((defined(SYSTEME_CRAYYMP1_UNICOS_CC))) \
|| ((defined(SYSTEME_CRAYYMP1_UNICOS_SCC))) \
|| ((defined(SYSTEME_CRAYYMP2_UNICOS_CC))) \
|| ((defined(SYSTEME_CRAYYMP2_UNICOS_SCC))) \
|| ((defined(SYSTEME_CRAYYMP4_UNICOS_CC))) \
|| ((defined(SYSTEME_CRAYYMP4_UNICOS_SCC))) \
|| ((defined(SYSTEME_NWS3000_NEWSOS_CC))) \
|| ((defined(SYSTEME_NWS3000_NEWSOS_2CC))) \
|| ((defined(SYSTEME_SG4D20G_IRIX_CC))) \
|| ((defined(SYSTEME_SG4D25TG_IRIX_CC))) \
|| ((defined(SYSTEME_SG4D310VGX_IRIX_CC))) \
|| ((defined(SYSTEME_SG4D35TG_IRIX_CC))) \
|| ((defined(SYSTEME_SG4D85GT_IRIX_CC))) \
|| ((defined(SYSTEME_SGIND308_IRIX_CC))) \
|| ((defined(SYSTEME_SGIND324_IRIX_CC))) \
|| ((defined(SYSTEME_SGIND3GA_IRIX_CC))) \
|| ((defined(SYSTEME_SGIND408_IRIX_CC))) \
|| ((defined(SYSTEME_SGIND424_IRIX_CC))) \
|| ((defined(SYSTEME_SGIND4GA_IRIX_CC))) \
|| ((defined(SYSTEME_SGIND508_IRIX_CC)) && (nSYSTEM_RELEASE < 602000000)) \
|| ((defined(SYSTEME_SGIND524_IRIX_CC)) && (nSYSTEM_RELEASE < 602000000)) \
|| ((defined(SYSTEME_SGIND5GA_IRIX_CC)) && (nSYSTEM_RELEASE < 602000000)) \
|| ((defined(SYSTEME_SGIND808_IRIX_CC))) \
|| ((defined(SYSTEME_SGIND824_IRIX_CC))) \
|| ((defined(SYSTEME_SGIND8GA_IRIX_CC))) \
|| ((defined(SYSTEME_SGINDA08_IRIX_CC))) \
|| ((defined(SYSTEME_SGINDA24_IRIX_CC))) \
|| ((defined(SYSTEME_SGINDAGA_IRIX_CC))) \
|| ((defined(SYSTEME_SGO200A1_IRIX_CC)) && (nSYSTEM_RELEASE < 602000000)) \
|| ((defined(SYSTEME_SGO200A2_IRIX_CC)) && (nSYSTEM_RELEASE < 602000000)) \
|| ((defined(SYSTEME_SGO200A4_IRIX_CC)) && (nSYSTEM_RELEASE < 602000000)) \
|| ((defined(SYSTEME_SGO25224_IRIX_CC)) && (nSYSTEM_RELEASE < 602000000)) \
|| ((defined(SYSTEME_SGO252VA_IRIX_CC)) && (nSYSTEM_RELEASE < 602000000)) \
|| ((defined(SYSTEME_SGO252VN_IRIX_CC)) && (nSYSTEM_RELEASE < 602000000)) \
|| ((defined(SYSTEME_SGPCM801_IRIX_CC))) \
|| ((defined(SYSTEME_SGPCMA01_IRIX_CC))) \
|| ((defined(SYSTEME_VAX9000_ULTRIX_CC))) \
)
# TestADef BUG_SYSTEME_C_blockV \
/* Cas ou le compilateur associe ne supporte pas assez de blocs de Validation imbriques... */ \
/* */ \
/* 1-cas 'SYSTEME_NWS3000_NEWSOS' : */ \
/* */ \
/* le compilateur 'cc' ne supporte pas assez de blocs imbriques. Ainsi, on evite le message */ \
/* */ \
/* yacc stack overflow */ \
/* */ \
/* auquel on ne peut rien (il faudrait pouvoir recompiler 'yacc'...). */ \
/* */ \
/* 2-cas 'SYSTEME_SG...' : */ \
/* */ \
/* le compilateur 'cc' (via 'yacc') ne supporte pas assez de blocs imbriques ; d'apres un */ \
/* un rapport venant de Silicon Graphics, la version actuelle aurait ete compilee avec un */ \
/* parametre ("non user expandable") fixant a 150 "entrees" la taille de la pile : reste a */ \
/* savoir ce que contient une "entree"... */
#Aif ( ((defined(SYSTEME_CRAY2_UNICOS_CC))) \
|| ((defined(SYSTEME_CRAY2_UNICOS_SCC))) \
|| ((defined(SYSTEME_CRAYC98_UNICOS_CC))) \
|| ((defined(SYSTEME_CRAYC98_UNICOS_SCC))) \
|| ((defined(SYSTEME_CRAYC916_UNICOS_CC))) \
|| ((defined(SYSTEME_CRAYC916_UNICOS_SCC))) \
|| ((defined(SYSTEME_CRAYYMP1_UNICOS_CC))) \
|| ((defined(SYSTEME_CRAYYMP1_UNICOS_SCC))) \
|| ((defined(SYSTEME_CRAYYMP2_UNICOS_CC))) \
|| ((defined(SYSTEME_CRAYYMP2_UNICOS_SCC))) \
|| ((defined(SYSTEME_CRAYYMP4_UNICOS_CC))) \
|| ((defined(SYSTEME_CRAYYMP4_UNICOS_SCC))) \
|| ((defined(SYSTEME_NWS3000_NEWSOS_CC))) \
|| ((defined(SYSTEME_NWS3000_NEWSOS_2CC))) \
|| ((defined(SYSTEME_SG4D20G_IRIX_CC))) \
|| ((defined(SYSTEME_SG4D25TG_IRIX_CC))) \
|| ((defined(SYSTEME_SG4D310VGX_IRIX_CC))) \
|| ((defined(SYSTEME_SG4D35TG_IRIX_CC))) \
|| ((defined(SYSTEME_SG4D85GT_IRIX_CC))) \
|| ((defined(SYSTEME_SGIND308_IRIX_CC))) \
|| ((defined(SYSTEME_SGIND324_IRIX_CC))) \
|| ((defined(SYSTEME_SGIND3GA_IRIX_CC))) \
|| ((defined(SYSTEME_SGIND408_IRIX_CC))) \
|| ((defined(SYSTEME_SGIND424_IRIX_CC))) \
|| ((defined(SYSTEME_SGIND4GA_IRIX_CC))) \
|| ((defined(SYSTEME_SGIND508_IRIX_CC)) && (nSYSTEM_RELEASE < 602000000)) \
|| ((defined(SYSTEME_SGIND524_IRIX_CC)) && (nSYSTEM_RELEASE < 602000000)) \
|| ((defined(SYSTEME_SGIND5GA_IRIX_CC)) && (nSYSTEM_RELEASE < 602000000)) \
|| ((defined(SYSTEME_SGIND808_IRIX_CC))) \
|| ((defined(SYSTEME_SGIND824_IRIX_CC))) \
|| ((defined(SYSTEME_SGIND8GA_IRIX_CC))) \
|| ((defined(SYSTEME_SGINDA08_IRIX_CC))) \
|| ((defined(SYSTEME_SGINDA24_IRIX_CC))) \
|| ((defined(SYSTEME_SGINDAGA_IRIX_CC))) \
|| ((defined(SYSTEME_SGO200A1_IRIX_CC)) && (nSYSTEM_RELEASE < 602000000)) \
|| ((defined(SYSTEME_SGO200A2_IRIX_CC)) && (nSYSTEM_RELEASE < 602000000)) \
|| ((defined(SYSTEME_SGO200A4_IRIX_CC)) && (nSYSTEM_RELEASE < 602000000)) \
|| ((defined(SYSTEME_SGO25224_IRIX_CC)) && (nSYSTEM_RELEASE < 602000000)) \
|| ((defined(SYSTEME_SGO252VA_IRIX_CC)) && (nSYSTEM_RELEASE < 602000000)) \
|| ((defined(SYSTEME_SGO252VN_IRIX_CC)) && (nSYSTEM_RELEASE < 602000000)) \
|| ((defined(SYSTEME_SGPCM801_IRIX_CC))) \
|| ((defined(SYSTEME_SGPCMA01_IRIX_CC))) \
|| ((defined(SYSTEME_VAX9000_ULTRIX_CC))) \
)
#Eif ( ((defined(SYSTEME_CRAY2_UNICOS_CC))) \
|| ((defined(SYSTEME_CRAY2_UNICOS_SCC))) \
|| ((defined(SYSTEME_CRAYC98_UNICOS_CC))) \
|| ((defined(SYSTEME_CRAYC98_UNICOS_SCC))) \
|| ((defined(SYSTEME_CRAYC916_UNICOS_CC))) \
|| ((defined(SYSTEME_CRAYC916_UNICOS_SCC))) \
|| ((defined(SYSTEME_CRAYYMP1_UNICOS_CC))) \
|| ((defined(SYSTEME_CRAYYMP1_UNICOS_SCC))) \
|| ((defined(SYSTEME_CRAYYMP2_UNICOS_CC))) \
|| ((defined(SYSTEME_CRAYYMP2_UNICOS_SCC))) \
|| ((defined(SYSTEME_CRAYYMP4_UNICOS_CC))) \
|| ((defined(SYSTEME_CRAYYMP4_UNICOS_SCC))) \
|| ((defined(SYSTEME_NWS3000_NEWSOS_CC))) \
|| ((defined(SYSTEME_NWS3000_NEWSOS_2CC))) \
|| ((defined(SYSTEME_SG4D20G_IRIX_CC))) \
|| ((defined(SYSTEME_SG4D25TG_IRIX_CC))) \
|| ((defined(SYSTEME_SG4D310VGX_IRIX_CC))) \
|| ((defined(SYSTEME_SG4D35TG_IRIX_CC))) \
|| ((defined(SYSTEME_SG4D85GT_IRIX_CC))) \
|| ((defined(SYSTEME_SGIND308_IRIX_CC))) \
|| ((defined(SYSTEME_SGIND324_IRIX_CC))) \
|| ((defined(SYSTEME_SGIND3GA_IRIX_CC))) \
|| ((defined(SYSTEME_SGIND408_IRIX_CC))) \
|| ((defined(SYSTEME_SGIND424_IRIX_CC))) \
|| ((defined(SYSTEME_SGIND4GA_IRIX_CC))) \
|| ((defined(SYSTEME_SGIND508_IRIX_CC)) && (nSYSTEM_RELEASE < 602000000)) \
|| ((defined(SYSTEME_SGIND524_IRIX_CC)) && (nSYSTEM_RELEASE < 602000000)) \
|| ((defined(SYSTEME_SGIND5GA_IRIX_CC)) && (nSYSTEM_RELEASE < 602000000)) \
|| ((defined(SYSTEME_SGIND808_IRIX_CC))) \
|| ((defined(SYSTEME_SGIND824_IRIX_CC))) \
|| ((defined(SYSTEME_SGIND8GA_IRIX_CC))) \
|| ((defined(SYSTEME_SGINDA08_IRIX_CC))) \
|| ((defined(SYSTEME_SGINDA24_IRIX_CC))) \
|| ((defined(SYSTEME_SGINDAGA_IRIX_CC))) \
|| ((defined(SYSTEME_SGO200A1_IRIX_CC)) && (nSYSTEM_RELEASE < 602000000)) \
|| ((defined(SYSTEME_SGO200A2_IRIX_CC)) && (nSYSTEM_RELEASE < 602000000)) \
|| ((defined(SYSTEME_SGO200A4_IRIX_CC)) && (nSYSTEM_RELEASE < 602000000)) \
|| ((defined(SYSTEME_SGO25224_IRIX_CC)) && (nSYSTEM_RELEASE < 602000000)) \
|| ((defined(SYSTEME_SGO252VA_IRIX_CC)) && (nSYSTEM_RELEASE < 602000000)) \
|| ((defined(SYSTEME_SGO252VN_IRIX_CC)) && (nSYSTEM_RELEASE < 602000000)) \
|| ((defined(SYSTEME_SGPCM801_IRIX_CC))) \
|| ((defined(SYSTEME_SGPCMA01_IRIX_CC))) \
|| ((defined(SYSTEME_VAX9000_ULTRIX_CC))) \
)
#define BblockV \
BEGIN
#define EblockV \
END
#if ( (defined(BUG_SYSTEME_C_blockV)) \
)
# undef BblockV
# define BblockV \
VIDE \
/* Cas ou le compilateur associe ne supporte pas assez de blocs de Validation imbriques... */
# undef EblockV
# define EblockV \
VIDE \
/* Cas ou le compilateur associe ne supporte pas assez de blocs de Validation imbriques... */
#Aif ( (defined(BUG_SYSTEME_C_blockV)) \
)
#Eif ( (defined(BUG_SYSTEME_C_blockV)) \
)
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* S E L E C T E U R S : */
/* */
/*************************************************************************************************************************************/
/* ATTENTION : la fonction 'SE11(...)' est definie dans 'v $xil/defi_K1$vv$DEF SE11', et ce */
/* a cause de la definition de 'NEUT(...)'. */
#define gSE12(x1,x2) \
x1
#define SE12(x1,x2) \
PARE(gSE12(x1,x2))
/* Selection du premier element d'une liste de 2, */
#define gSE22(x1,x2) \
x2
#define SE22(x1,x2) \
PARE(gSE22(x1,x2))
/* Selection du deuxieme element d'une liste de 2. */
#define gSE13(x1,x2,x3) \
x1
#define SE13(x1,x2,x3) \
PARE(gSE13(x1,x2,x3))
/* Selection du premier element d'une liste de 3, */
#define gSE23(x1,x2,x3) \
x2
#define SE23(x1,x2,x3) \
PARE(gSE23(x1,x2,x3))
/* Selection du deuxieme element d'une liste de 3, */
#define gSE33(x1,x2,x3) \
x3
#define SE33(x1,x2,x3) \
PARE(gSE33(x1,x2,x3))
/* Selection du troisieme element d'une liste de 3. */
#define gSE14(x1,x2,x3,x4) \
x1
#define SE14(x1,x2,x3,x4) \
PARE(gSE14(x1,x2,x3,x4))
/* Selection du premier element d'une liste de 4, */
#define gSE24(x1,x2,x3,x4) \
x2
#define SE24(x1,x2,x3,x4) \
PARE(gSE24(x1,x2,x3,x4))
/* Selection du deuxieme element d'une liste de 4, */
#define gSE34(x1,x2,x3,x4) \
x3
#define SE34(x1,x2,x3,x4) \
PARE(gSE34(x1,x2,x3,x4))
/* Selection du troisieme element d'une liste de 4, */
#define gSE44(x1,x2,x3,x4) \
x4
#define SE44(x1,x2,x3,x4) \
PARE(gSE44(x1,x2,x3,x4))
/* Selection du quatrieme element d'une liste de 4. */
#define gSE15(x1,x2,x3,x4,x5) \
x1
#define SE15(x1,x2,x3,x4,x5) \
PARE(gSE15(x1,x2,x3,x4,x5))
/* Selection du premier element d'une liste de 5 (introduit le 20100210103412), */
#define gSE25(x1,x2,x3,x4,x5) \
x2
#define SE25(x1,x2,x3,x4,x5) \
PARE(gSE25(x1,x2,x3,x4,x5))
/* Selection du deuxieme element d'une liste de 5 (introduit le 20100210103412), */
#define gSE35(x1,x2,x3,x4,x5) \
x3
#define SE35(x1,x2,x3,x4,x5) \
PARE(gSE35(x1,x2,x3,x4,x5))
/* Selection du troisieme element d'une liste de 5 (introduit le 20100210103412), */
#define gSE45(x1,x2,x3,x4,x5) \
x4
#define SE45(x1,x2,x3,x4,x5) \
PARE(gSE45(x1,x2,x3,x4,x5))
/* Selection du quatrieme element d'une liste de 5 (introduit le 20100210103412), */
#define gSE55(x1,x2,x3,x4,x5) \
x5
#define SE55(x1,x2,x3,x4,x5) \
PARE(gSE55(x1,x2,x3,x4,x5))
/* Selection du cinquieme element d'une liste de 5 (introduit le 20100210103412). */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E R I V E E S D E S O P E R A T E U R S D E S E L E C T I O N : */
/* */
/*************************************************************************************************************************************/
#define d_SE12(x1,x2) \
SE12(d#x1,d#x2)
#define d_SE22(x1,x2) \
SE22(d#x1,d#x2)
/* Derivee des operateurs de selection : */
/* */
/* d(selection(x1,x2,...)) = selection(d(x1),d(x2),...) */
/* */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* P E R M U T A T I O N S : */
/* */
/*************************************************************************************************************************************/
#define PERMUTATION_12(x1,x2) \
x1 \
x2 \
/* Permutation (1,2). */
#define PERMUTATION_21(x1,x2) \
x2 \
x1 \
/* Permutation (2,1). */
#define PERMUTATION_123(x1,x2,x3) \
x1 \
x2 \
x3 \
/* Permutation (1,2,3). */
#define PERMUTATION_132(x1,x2,x3) \
x1 \
x3 \
x2 \
/* Permutation (1,3,2). */
#define PERMUTATION_231(x1,x2,x3) \
x2 \
x3 \
x1 \
/* Permutation (2,3,1). */
#define PERMUTATION_213(x1,x2,x3) \
x2 \
x1 \
x3 \
/* Permutation (2,1,3). */
#define PERMUTATION_312(x1,x2,x3) \
x3 \
x1 \
x2 \
/* Permutation (3,1,2). */
#define PERMUTATION_321(x1,x2,x3) \
x3 \
x2 \
x1 \
/* Permutation (3,2,1). */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N D E L I S T E S A ' N ' E L E M E N T S : */
/* */
/*************************************************************************************************************************************/
#define LIS1(element1) \
element1 \
/* Liste a 1 element. */
#define LIS2(element1,element2) \
element1,element2 \
/* Liste a 2 elements. */
#define LIS3(element1,element2,element3) \
element1,element2,element3 \
/* Liste a 3 elements. */
#define LIS4(element1,element2,element3,element4) \
element1,element2,element3,element4 \
/* Liste a 4 elements. */
#define LIS5(element1,element2,element3,element4,element5) \
element1,element2,element3,element4,element5 \
/* Liste a 5 elements. */
#define LIS6(element1,element2,element3,element4,element5,element6) \
element1,element2,element3,element4,element5,element6 \
/* Liste a 6 elements. */
#define LIS7(element1,element2,element3,element4,element5,element6,element7) \
element1,element2,element3,element4,element5,element6,element7 \
/* Liste a 7 elements. */
#define LIS8(element1,element2,element3,element4,element5,element6,element7,element8) \
element1,element2,element3,element4,element5,element6,element7,element8 \
/* Liste a 8 elements. */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* E N U M E R A T I O N S T Y P E E S : */
/* */
/* */
/* ATTENTION : */
/* */
/* Pour des raisons evidentes liees au */
/* pre-processing, il est impossible d'appeler */
/* ces procedures en forcant des valeurs */
/* initiales pour certains arguments par */
/* 'INIS(...)' ; le '=define..." engendrerait */
/* une definition contenant le 'INIS(...)'. */
/* */
/* */
/* Nota : */
/* */
/* Les caracteres '$'s sont remplaces par */
/* des '_'s lors de la '$PASSE_1' de 'v $xcc/cpp$Z DenumeTx' */
/* (via un '$xcp/underscore$X'), */
/* ceci etant du aux '=define's qui definissent */
/* des symboles 'elementIJ' a partir donc de */
/* '_elementIJ'... */
/* */
/*************************************************************************************************************************************/
#define DenumeT01(element01,nom) \
Denumer01($element01 \
,nom \
); \
=define element01 ENUM($element01)
#define DenumeT02(element01,element02,nom) \
Denumer02($element01 \
,$element02 \
,nom \
); \
=define element01 ENUM($element01) \
=define element02 ENUM($element02)
#define DenumeT03(element01,element02,element03,nom) \
Denumer03($element01 \
,$element02 \
,$element03 \
,nom \
); \
=define element01 ENUM($element01) \
=define element02 ENUM($element02) \
=define element03 ENUM($element03)
#define DenumeT04(element01,element02,element03,element04,nom) \
Denumer04($element01 \
,$element02 \
,$element03 \
,$element04 \
,nom \
); \
=define element01 ENUM($element01) \
=define element02 ENUM($element02) \
=define element03 ENUM($element03) \
=define element04 ENUM($element04)
#define DenumeT05(element01,element02,element03,element04,element05,nom) \
Denumer05($element01 \
,$element02 \
,$element03 \
,$element04 \
,$element05 \
,nom \
); \
=define element01 ENUM($element01) \
=define element02 ENUM($element02) \
=define element03 ENUM($element03) \
=define element04 ENUM($element04) \
=define element05 ENUM($element05)
#define DenumeT06(element01,element02,element03,element04,element05,element06,nom) \
Denumer06($element01 \
,$element02 \
,$element03 \
,$element04 \
,$element05 \
,$element06 \
,nom \
); \
=define element01 ENUM($element01) \
=define element02 ENUM($element02) \
=define element03 ENUM($element03) \
=define element04 ENUM($element04) \
=define element05 ENUM($element05) \
=define element06 ENUM($element06)
#define DenumeT07(element01,element02,element03,element04,element05,element06,element07,nom) \
Denumer07($element01 \
,$element02 \
,$element03 \
,$element04 \
,$element05 \
,$element06 \
,$element07 \
,nom \
); \
=define element01 ENUM($element01) \
=define element02 ENUM($element02) \
=define element03 ENUM($element03) \
=define element04 ENUM($element04) \
=define element05 ENUM($element05) \
=define element06 ENUM($element06) \
=define element07 ENUM($element07)
#define DenumeT08(element01,element02,element03,element04,element05,element06,element07,element08,nom) \
Denumer08($element01 \
,$element02 \
,$element03 \
,$element04 \
,$element05 \
,$element06 \
,$element07 \
,$element08 \
,nom \
); \
=define element01 ENUM($element01) \
=define element02 ENUM($element02) \
=define element03 ENUM($element03) \
=define element04 ENUM($element04) \
=define element05 ENUM($element05) \
=define element06 ENUM($element06) \
=define element07 ENUM($element07) \
=define element08 ENUM($element08)
#define DenumeT09(element01,element02,element03,element04,element05,element06,element07,element08,element09,nom) \
Denumer09($element01 \
,$element02 \
,$element03 \
,$element04 \
,$element05 \
,$element06 \
,$element07 \
,$element08 \
,$element09 \
,nom \
); \
=define element01 ENUM($element01) \
=define element02 ENUM($element02) \
=define element03 ENUM($element03) \
=define element04 ENUM($element04) \
=define element05 ENUM($element05) \
=define element06 ENUM($element06) \
=define element07 ENUM($element07) \
=define element08 ENUM($element08) \
=define element09 ENUM($element09)
#define DenumeT10(el01,el02,el03,el04,el05,el06,el07,el08,el09,el10,nom) \
Denumer10($el01 \
,$el02 \
,$el03 \
,$el04 \
,$el05 \
,$el06 \
,$el07 \
,$el08 \
,$el09 \
,$el10 \
,nom \
); \
=define el01 ENUM($el01) \
=define el02 ENUM($el02) \
=define el03 ENUM($el03) \
=define el04 ENUM($el04) \
=define el05 ENUM($el05) \
=define el06 ENUM($el06) \
=define el07 ENUM($el07) \
=define el08 ENUM($el08) \
=define el09 ENUM($el09) \
=define el10 ENUM($el10)
#define DenumeT13(el01,el02,el03,el04,el05,el06,el07,el08,el09,el10,el11,el12,el13,nom) \
Denumer13($el01 \
,$el02 \
,$el03 \
,$el04 \
,$el05 \
,$el06 \
,$el07 \
,$el08 \
,$el09 \
,$el10 \
,$el11 \
,$el12 \
,$el13 \
,nom \
); \
=define el01 ENUM($el01) \
=define el02 ENUM($el02) \
=define el03 ENUM($el03) \
=define el04 ENUM($el04) \
=define el05 ENUM($el05) \
=define el06 ENUM($el06) \
=define el07 ENUM($el07) \
=define el08 ENUM($el08) \
=define el09 ENUM($el09) \
=define el10 ENUM($el10) \
=define el11 ENUM($el11) \
=define el12 ENUM($el12) \
=define el13 ENUM($el13)
#define DenumeT16(el01,el02,el03,el04,el05,el06,el07,el08,el09,el10,el11,el12,el13,el14,el15,el16,nom) \
Denumer16($el01 \
,$el02 \
,$el03 \
,$el04 \
,$el05 \
,$el06 \
,$el07 \
,$el08 \
,$el09 \
,$el10 \
,$el11 \
,$el12 \
,$el13 \
,$el14 \
,$el15 \
,$el16 \
,nom \
); \
=define el01 ENUM($el01) \
=define el02 ENUM($el02) \
=define el03 ENUM($el03) \
=define el04 ENUM($el04) \
=define el05 ENUM($el05) \
=define el06 ENUM($el06) \
=define el07 ENUM($el07) \
=define el08 ENUM($el08) \
=define el09 ENUM($el09) \
=define el10 ENUM($el10) \
=define el11 ENUM($el11) \
=define el12 ENUM($el12) \
=define el13 ENUM($el13) \
=define el14 ENUM($el14) \
=define el15 ENUM($el15) \
=define el16 ENUM($el16)
#define DenumeT17(el01,el02,el03,el04,el05,el06,el07,el08,el09,el10,el11,el12,el13,el14,el15,el16,el17,nom) \
Denumer17($el01 \
,$el02 \
,$el03 \
,$el04 \
,$el05 \
,$el06 \
,$el07 \
,$el08 \
,$el09 \
,$el10 \
,$el11 \
,$el12 \
,$el13 \
,$el14 \
,$el15 \
,$el16 \
,$el17 \
,nom \
); \
=define el01 ENUM($el01) \
=define el02 ENUM($el02) \
=define el03 ENUM($el03) \
=define el04 ENUM($el04) \
=define el05 ENUM($el05) \
=define el06 ENUM($el06) \
=define el07 ENUM($el07) \
=define el08 ENUM($el08) \
=define el09 ENUM($el09) \
=define el10 ENUM($el10) \
=define el11 ENUM($el11) \
=define el12 ENUM($el12) \
=define el13 ENUM($el13) \
=define el14 ENUM($el14) \
=define el15 ENUM($el15) \
=define el16 ENUM($el16) \
=define el17 ENUM($el17)
#define DenumeT18(el01,el02,el03,el04,el05,el06,el07,el08,el09,el10,el11,el12,el13,el14,el15,el16,el17,el18,nom) \
Denumer18($el01 \
,$el02 \
,$el03 \
,$el04 \
,$el05 \
,$el06 \
,$el07 \
,$el08 \
,$el09 \
,$el10 \
,$el11 \
,$el12 \
,$el13 \
,$el14 \
,$el15 \
,$el16 \
,$el17 \
,$el18 \
,nom \
); \
=define el01 ENUM($el01) \
=define el02 ENUM($el02) \
=define el03 ENUM($el03) \
=define el04 ENUM($el04) \
=define el05 ENUM($el05) \
=define el06 ENUM($el06) \
=define el07 ENUM($el07) \
=define el08 ENUM($el08) \
=define el09 ENUM($el09) \
=define el10 ENUM($el10) \
=define el11 ENUM($el11) \
=define el12 ENUM($el12) \
=define el13 ENUM($el13) \
=define el14 ENUM($el14) \
=define el15 ENUM($el15) \
=define el16 ENUM($el16) \
=define el17 ENUM($el17) \
=define el18 ENUM($el18)
#define DenumeT19(el01,el02,el03,el04,el05,el06,el07,el08,el09,el10,el11,el12,el13,el14,el15,el16,el17,el18,el19,nom) \
Denumer19($el01 \
,$el02 \
,$el03 \
,$el04 \
,$el05 \
,$el06 \
,$el07 \
,$el08 \
,$el09 \
,$el10 \
,$el11 \
,$el12 \
,$el13 \
,$el14 \
,$el15 \
,$el16 \
,$el17 \
,$el18 \
,$el19 \
,nom \
); \
=define el01 ENUM($el01) \
=define el02 ENUM($el02) \
=define el03 ENUM($el03) \
=define el04 ENUM($el04) \
=define el05 ENUM($el05) \
=define el06 ENUM($el06) \
=define el07 ENUM($el07) \
=define el08 ENUM($el08) \
=define el09 ENUM($el09) \
=define el10 ENUM($el10) \
=define el11 ENUM($el11) \
=define el12 ENUM($el12) \
=define el13 ENUM($el13) \
=define el14 ENUM($el14) \
=define el15 ENUM($el15) \
=define el16 ENUM($el16) \
=define el17 ENUM($el17) \
=define el18 ENUM($el18) \
=define el19 ENUM($el19)
#define DenumeT20(el01,el02,el03,el04,el05,el06,el07,el08,el09,el10,el11,el12,el13,el14,el15,el16,el17,el18,el19,el20,nom) \
Denumer20($el01 \
,$el02 \
,$el03 \
,$el04 \
,$el05 \
,$el06 \
,$el07 \
,$el08 \
,$el09 \
,$el10 \
,$el11 \
,$el12 \
,$el13 \
,$el14 \
,$el15 \
,$el16 \
,$el17 \
,$el18 \
,$el19 \
,$el20 \
,nom \
); \
=define el01 ENUM($el01) \
=define el02 ENUM($el02) \
=define el03 ENUM($el03) \
=define el04 ENUM($el04) \
=define el05 ENUM($el05) \
=define el06 ENUM($el06) \
=define el07 ENUM($el07) \
=define el08 ENUM($el08) \
=define el09 ENUM($el09) \
=define el10 ENUM($el10) \
=define el11 ENUM($el11) \
=define el12 ENUM($el12) \
=define el13 ENUM($el13) \
=define el14 ENUM($el14) \
=define el15 ENUM($el15) \
=define el16 ENUM($el16) \
=define el17 ENUM($el17) \
=define el18 ENUM($el18) \
=define el19 ENUM($el19) \
=define el20 ENUM($el20)
#define DenumeT22(el01,el02,el03,el04,el05,el06,el07,el08,el09,el10,el11,el12,el13,el14,el15,el16,el17,el18,el19,el20,el21,el22,nom) \
Denumer22($el01 \
,$el02 \
,$el03 \
,$el04 \
,$el05 \
,$el06 \
,$el07 \
,$el08 \
,$el09 \
,$el10 \
,$el11 \
,$el12 \
,$el13 \
,$el14 \
,$el15 \
,$el16 \
,$el17 \
,$el18 \
,$el19 \
,$el20 \
,$el21 \
,$el22 \
,nom \
); \
=define el01 ENUM($el01) \
=define el02 ENUM($el02) \
=define el03 ENUM($el03) \
=define el04 ENUM($el04) \
=define el05 ENUM($el05) \
=define el06 ENUM($el06) \
=define el07 ENUM($el07) \
=define el08 ENUM($el08) \
=define el09 ENUM($el09) \
=define el10 ENUM($el10) \
=define el11 ENUM($el11) \
=define el12 ENUM($el12) \
=define el13 ENUM($el13) \
=define el14 ENUM($el14) \
=define el15 ENUM($el15) \
=define el16 ENUM($el16) \
=define el17 ENUM($el17) \
=define el18 ENUM($el18) \
=define el19 ENUM($el19) \
=define el20 ENUM($el20) \
=define el21 ENUM($el21) \
=define el22 ENUM($el22)
#define DeT27(e1,e2,e3,e4,e5,e6,e7,e8,e9,eA,eB,eC,eD,eE,eF,eG,eH,eI,eJ,eK,eL,eM,eN,eO,eP,eQ,eR,nom) \
Den27($e1 \
,$e2 \
,$e3 \
,$e4 \
,$e5 \
,$e6 \
,$e7 \
,$e8 \
,$e9 \
,$eA \
,$eB \
,$eC \
,$eD \
,$eE \
,$eF \
,$eG \
,$eH \
,$eI \
,$eJ \
,$eK \
,$eL \
,$eM \
,$eN \
,$eO \
,$eP \
,$eQ \
,$eR \
,nom \
); \
=define e1 ENUM($e1) \
=define e2 ENUM($e2) \
=define e3 ENUM($e3) \
=define e4 ENUM($e4) \
=define e5 ENUM($e5) \
=define e6 ENUM($e6) \
=define e7 ENUM($e7) \
=define e8 ENUM($e8) \
=define e9 ENUM($e9) \
=define eA ENUM($eA) \
=define eB ENUM($eB) \
=define eC ENUM($eC) \
=define eD ENUM($eD) \
=define eE ENUM($eE) \
=define eF ENUM($eF) \
=define eG ENUM($eG) \
=define eH ENUM($eH) \
=define eI ENUM($eI) \
=define eJ ENUM($eJ) \
=define eK ENUM($eK) \
=define eL ENUM($eL) \
=define eM ENUM($eM) \
=define eN ENUM($eN) \
=define eO ENUM($eO) \
=define eP ENUM($eP) \
=define eQ ENUM($eQ) \
=define eR ENUM($eR)
#define DeT36(e1,e2,e3,e4,e5,e6,e7,e8,e9,eA,eB,eC,eD,eE,eF,eG,eH,eI,eJ,eK,eL,eM,eN,eO,eP,eQ,eR,eS,eT,eU,eV,eW,eX,eY,eZ,ea,nom) \
Den36($e1 \
,$e2 \
,$e3 \
,$e4 \
,$e5 \
,$e6 \
,$e7 \
,$e8 \
,$e9 \
,$eA \
,$eB \
,$eC \
,$eD \
,$eE \
,$eF \
,$eG \
,$eH \
,$eI \
,$eJ \
,$eK \
,$eL \
,$eM \
,$eN \
,$eO \
,$eP \
,$eQ \
,$eR \
,$eS \
,$eT \
,$eU \
,$eV \
,$eW \
,$eX \
,$eY \
,$eZ \
,$ea \
,nom \
); \
=define e1 ENUM($e1) \
=define e2 ENUM($e2) \
=define e3 ENUM($e3) \
=define e4 ENUM($e4) \
=define e5 ENUM($e5) \
=define e6 ENUM($e6) \
=define e7 ENUM($e7) \
=define e8 ENUM($e8) \
=define e9 ENUM($e9) \
=define eA ENUM($eA) \
=define eB ENUM($eB) \
=define eC ENUM($eC) \
=define eD ENUM($eD) \
=define eE ENUM($eE) \
=define eF ENUM($eF) \
=define eG ENUM($eG) \
=define eH ENUM($eH) \
=define eI ENUM($eI) \
=define eJ ENUM($eJ) \
=define eK ENUM($eK) \
=define eL ENUM($eL) \
=define eM ENUM($eM) \
=define eN ENUM($eN) \
=define eO ENUM($eO) \
=define eP ENUM($eP) \
=define eQ ENUM($eQ) \
=define eR ENUM($eR) \
=define eS ENUM($eS) \
=define eT ENUM($eT) \
=define eU ENUM($eU) \
=define eV ENUM($eV) \
=define eW ENUM($eW) \
=define eX ENUM($eX) \
=define eY ENUM($eY) \
=define eZ ENUM($eZ) \
=define ea ENUM($ea) \
/* Introduit le 20170622130733... */
#define DeT38(e1,e2,e3,e4,e5,e6,e7,e8,e9,eA,eB,eC,eD,eE,eF,eG,eH,eI,eJ,eK,eL,eM,eN,eO,eP,eQ,eR,eS,eT,eU,eV,eW,eX,eY,eZ,ea,eb,ec,nom) \
Den38($e1 \
,$e2 \
,$e3 \
,$e4 \
,$e5 \
,$e6 \
,$e7 \
,$e8 \
,$e9 \
,$eA \
,$eB \
,$eC \
,$eD \
,$eE \
,$eF \
,$eG \
,$eH \
,$eI \
,$eJ \
,$eK \
,$eL \
,$eM \
,$eN \
,$eO \
,$eP \
,$eQ \
,$eR \
,$eS \
,$eT \
,$eU \
,$eV \
,$eW \
,$eX \
,$eY \
,$eZ \
,$ea \
,$eb \
,$ec \
,nom \
); \
=define e1 ENUM($e1) \
=define e2 ENUM($e2) \
=define e3 ENUM($e3) \
=define e4 ENUM($e4) \
=define e5 ENUM($e5) \
=define e6 ENUM($e6) \
=define e7 ENUM($e7) \
=define e8 ENUM($e8) \
=define e9 ENUM($e9) \
=define eA ENUM($eA) \
=define eB ENUM($eB) \
=define eC ENUM($eC) \
=define eD ENUM($eD) \
=define eE ENUM($eE) \
=define eF ENUM($eF) \
=define eG ENUM($eG) \
=define eH ENUM($eH) \
=define eI ENUM($eI) \
=define eJ ENUM($eJ) \
=define eK ENUM($eK) \
=define eL ENUM($eL) \
=define eM ENUM($eM) \
=define eN ENUM($eN) \
=define eO ENUM($eO) \
=define eP ENUM($eP) \
=define eQ ENUM($eQ) \
=define eR ENUM($eR) \
=define eS ENUM($eS) \
=define eT ENUM($eT) \
=define eU ENUM($eU) \
=define eV ENUM($eV) \
=define eW ENUM($eW) \
=define eX ENUM($eX) \
=define eY ENUM($eY) \
=define eZ ENUM($eZ) \
=define ea ENUM($ea) \
=define eb ENUM($eb) \
=define ec ENUM($ec)
#define DeT39(e1,e2,e3,e4,e5,e6,e7,e8,e9,eA,eB,eC,eD,eE,eF,eG,eH,eI,eJ,eK,eL,eM,eN,eO,eP,eQ,eR,eS,eT,eU,eV,eW,eX,eY,eZ,ea,eb,ec,ed,n) \
Den39($e1 \
,$e2 \
,$e3 \
,$e4 \
,$e5 \
,$e6 \
,$e7 \
,$e8 \
,$e9 \
,$eA \
,$eB \
,$eC \
,$eD \
,$eE \
,$eF \
,$eG \
,$eH \
,$eI \
,$eJ \
,$eK \
,$eL \
,$eM \
,$eN \
,$eO \
,$eP \
,$eQ \
,$eR \
,$eS \
,$eT \
,$eU \
,$eV \
,$eW \
,$eX \
,$eY \
,$eZ \
,$ea \
,$eb \
,$ec \
,$ed \
,nom \
); \
=define e1 ENUM($e1) \
=define e2 ENUM($e2) \
=define e3 ENUM($e3) \
=define e4 ENUM($e4) \
=define e5 ENUM($e5) \
=define e6 ENUM($e6) \
=define e7 ENUM($e7) \
=define e8 ENUM($e8) \
=define e9 ENUM($e9) \
=define eA ENUM($eA) \
=define eB ENUM($eB) \
=define eC ENUM($eC) \
=define eD ENUM($eD) \
=define eE ENUM($eE) \
=define eF ENUM($eF) \
=define eG ENUM($eG) \
=define eH ENUM($eH) \
=define eI ENUM($eI) \
=define eJ ENUM($eJ) \
=define eK ENUM($eK) \
=define eL ENUM($eL) \
=define eM ENUM($eM) \
=define eN ENUM($eN) \
=define eO ENUM($eO) \
=define eP ENUM($eP) \
=define eQ ENUM($eQ) \
=define eR ENUM($eR) \
=define eS ENUM($eS) \
=define eT ENUM($eT) \
=define eU ENUM($eU) \
=define eV ENUM($eV) \
=define eW ENUM($eW) \
=define eX ENUM($eX) \
=define eY ENUM($eY) \
=define eZ ENUM($eZ) \
=define ea ENUM($ea) \
=define eb ENUM($eb) \
=define ec ENUM($ec) \
=define ed ENUM($ed)
#define DeT48(A,eB,eC,D,E,eF,G,H,eI,J,K,L,M,N,O,eP,Q,R,S,T,eU,V,eW,X,Y,Z,a,b,c,d,e,f,g,h,i,j,k,l,m,o,p,q,r,s,t,u,v,w,n) \
Den48($A \
,$eB \
,$eC \
,$D \
,$E \
,$eF \
,$G \
,$H \
,$eI \
,$J \
,$K \
,$L \
,$M \
,$N \
,$O \
,$eP \
,$Q \
,$R \
,$S \
,$T \
,$eU \
,$V \
,$eW \
,$X \
,$Y \
,$Z \
,$a \
,$b \
,$c \
,$d \
,$e \
,$f \
,$g \
,$h \
,$i \
,$j \
,$k \
,$l \
,$m \
,$o \
,$p \
,$q \
,$r \
,$s \
,$t \
,$u \
,$v \
,$w \
,n \
); \
=define A ENUM($A) \
=define eB ENUM($eB) \
=define eC ENUM($eC) \
=define D ENUM($D) \
=define E ENUM($E) \
=define eF ENUM($eF) \
=define G ENUM($G) \
=define H ENUM($H) \
=define eI ENUM($eI) \
=define J ENUM($J) \
=define K ENUM($K) \
=define L ENUM($L) \
=define M ENUM($M) \
=define N ENUM($N) \
=define O ENUM($O) \
=define eP ENUM($eP) \
=define Q ENUM($Q) \
=define R ENUM($R) \
=define S ENUM($S) \
=define T ENUM($T) \
=define eU ENUM($eU) \
=define V ENUM($V) \
=define eW ENUM($eW) \
=define X ENUM($X) \
=define Y ENUM($Y) \
=define Z ENUM($Z) \
=define a ENUM($a) \
=define b ENUM($b) \
=define c ENUM($c) \
=define d ENUM($d) \
=define e ENUM($e) \
=define f ENUM($f) \
=define g ENUM($g) \
=define h ENUM($h) \
=define i ENUM($i) \
=define j ENUM($j) \
=define k ENUM($k) \
=define l ENUM($l) \
=define m ENUM($m) \
=define o ENUM($o) \
=define p ENUM($p) \
=define q ENUM($q) \
=define r ENUM($r) \
=define s ENUM($s) \
=define t ENUM($t) \
=define u ENUM($u) \
=define v ENUM($v) \
=define w ENUM($w) \
/* Introduit le 20170622130733... */ \
/* */ \
/* On notera qu'il n'y a pas d'arguments {A,D,E,G,H,J,K,L,M,N,O,Q,R,S,T,V,X,Y,Z} car, en */ \
/* effet, ces symboles sur une seule lettre existent en tant que '#define' et je souhaite */ \
/* evidemment eviter d'hypothetiques "collisions". En ce qui concerne les autres lettres */ \
/* de l'alphabet majuscule elles peuvent servir d'arguments et cela est tres utile afin */ \
/* reduire la longueur de la ligne '#define'... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* M U L T I P L E S U T I L E S D E S E N T I E R S N A T U R E L S : */
/* */
/*************************************************************************************************************************************/
#define TRENTE \
bMUL(TROIS,DIX)
#define TRENTE_DEUX \
DOUB(SEIZE)
#define QUARANTE \
bMUL(QUATRE,DIX)
#define CINQUANTE \
bMUL(CINQ,DIX)
#define SOIXANTE \
bMUL(SIX,DIX)
#define SOIXANTE_QUATRE \
EXP2(HUIT)
#define SOIXANTE_DIX \
bMUL(SEPT,DIX)
#define QUATRE_VINGT \
bMUL(HUIT,DIX)
#define QUATRE_VINGT_DIX \
bMUL(NEUF,DIX)
#define CENT_VINGT_HUIT \
DOUB(SOIXANTE_QUATRE)
#define DEUX_CENT_CINQUANTE_SIX \
DOUB(CENT_VINGT_HUIT)
#define CINQ_CENT_DOUZE \
DOUB(DEUX_CENT_CINQUANTE_SIX)
#define k___CENT \
EXP2(DIX)
#define k___MILLE \
EXP3(DIX)
#define k___DIX_MILLE \
EXP4(DIX)
#define k___CENT_MILLE \
EXP5(DIX)
#define k___MILLION \
EXP6(DIX)
#define k___MILLIARD \
EXP9(DIX)
#TestADef CENT \
k___CENT
#TestADef MILLE \
k___MILLE
#TestADef DIX_MILLE \
k___DIX_MILLE
#TestADef CENT_MILLE \
k___CENT_MILLE
#TestADef MILLION \
k___MILLION
#TestADef MILLIARD \
k___MILLIARD
/* La pre-generation des puissances de 10 a ete introduite le 20071204112015... */
#define KILO(x) \
bMUL(x,MILLE)
#define MEGA(x) \
bMUL(x,MILLION)
#define GIGA(x) \
bMUL(x,MILLIARD)
#define KIL2(x) \
bMUL(x,EXP1(DEUXp10))
#define MEG2(x) \
bMUL(x,EXP2(DEUXp10))
#define GIG2(x) \
bMUL(x,EXP3(DEUXp10))
/* Introduit le 20031111170158 pour 'v $xcg/CheckMem$vv$K MEG2'. */
#define aKILO(x) \
bDIV(x,MILLE)
#define aMEGA(x) \
bDIV(x,MILLION)
#define aGIGA(x) \
bDIV(x,MILLIARD)
#define aKIL2(x) \
bDIV(x,EXP1(DEUXp10))
#define aMEG2(x) \
bDIV(x,EXP2(DEUXp10))
#define aGIG2(x) \
bDIV(x,EXP3(DEUXp10))
/* Ces "AntiOperateurs" ont ete introduits le 20120131163252... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* C O N S T A N T E S I N D E F I N E S : */
/* */
/*************************************************************************************************************************************/
#define FLOT__UNDEF \
FLOT(UNDEF) \
/* Pour ce qui n'est pas defini en flottant (on notera que 'FLOT__UNDEF' et 'FLOT(UNDEF)' */ \
/* ont le meme nombre de caracteres, et ce afin de simplifier les mises a jour...). Enfin, */ \
/* on notera a titre d'information que sa valeur decimale est 444719 ; cela peut etre utile */ \
/* a cause de l'option : */ \
/* */ \
/* Parametres=VRAI */ \
/* */ \
/* qui a ete introduite dans toutes les commandes via les procedures 'GET_ARGUMENTS_(...)' */ \
/* et 'GET_ARGUMENTSi(...)' dans '$xig/fonct$vv$DEF' : ainsi on peut voir, par exemple, */ \
/* celles qui sont inutiles... */
#define LUNDEF \
CHOI(VRAI,FAUX) \
/* Pour ce qui n'est pas defini en matiere de logique... */ \
/* */ \
/* Le 20080303094255, je note qu'il serait preferable de donner a 'LUNDEF' une valeur */ \
/* qui soit a la fois differente de 'VRAI' et de 'FAUX' de facon a pouvoir la prendre */ \
/* en compte dans 'EST_VRAI(...)' et dans 'EST_FAUX(...)', Mais malheureusement, il */ \
/* s'agit ici de logiques booleennes et il n'est pas prevu de traiter {VRAI,FAUX,LUNDEF}, */ \
/* mais uniquement {VRAI,FAUX}... */
#define QUELCONQUE \
UNDEF \
/* Pour definir un nombre entier dont la valeur importe peu... */
#define FLOT__QUELCONQUE \
FLOT__UNDEF \
/* Pour definir un nombre flottant dont la valeur importe peu... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* O P E R A T I O N " N E U T R E " : */
/* */
/*************************************************************************************************************************************/
/* ATTENTION : depuis qu'a ete introduite la '$PASSE_D', il est imperatif que certaines */
/* definitions soient faites avant d'autres ; en particulier 'NEUT(...)' doit etre definie */
/* avant tout '-define ...', et donc 'SE11(...)' doit etre definie encore avant... */
/* ATTENTION : la fonction 'NEUT(...)' est definie dans '$xil/defi_K1$vv$DEF' dorenavant... */
#define RIEN(x) \
x \
/* Operation "encore" plus neutre destinee par exemple a transmettre le nom d'une */ \
/* fonction qui est de temps en temps un pointeur 'fPOINTEUR' (on verra avec interet */ \
/* l'exemple de 'ACCES_A_UN_CHAMP()'). */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* A F F E C T A T I O N S : */
/* */
/*************************************************************************************************************************************/
#define CLIR(x) \
EGAL(x,ZERO) \
/* Pour remettre a zero... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* O P E R A T E U R D E S E L E C T I O N C O N D I T I O N N E L L E D ' O P E R A T E U R S : */
/* */
/*************************************************************************************************************************************/
/* Les OPerateurs Conditionnels ont ete introduits le 20070519162237... */
/* ATTENTION : on notera le 20110821102426 que les operateurs 'OPC?(...)' ne peuvent pas */
/* figurer directement au niveau d'un '$K', mais doivent etre necessairement a un niveau */
/* superieur (par exemple celui d'un '$I' : voir 'v $xcg/SegReduct.01$I OPC1' par exemple). */
#define OPC1(condition,operateur_si_VRAI,operateur_si_FAUX,a) \
COND(condition,operateur_si_VRAI(a),operateur_si_FAUX(a)) \
/* Cas des operateurs a une operande... */
#define OPC2(condition,operateur_si_VRAI,operateur_si_FAUX,a,b) \
COND(condition,operateur_si_VRAI(a,b),operateur_si_FAUX(a,b)) \
/* Cas des operateurs a deux operandes. Ceci fut introduit pour 'v $xrv/densite.01$K OPC2'. */
#define OPC3(condition,operateur_si_VRAI,operateur_si_FAUX,a,b,c) \
COND(condition,operateur_si_VRAI(a,b,c),operateur_si_FAUX(a,b,c)) \
/* Cas des operateurs a trois operandes... */
#define OPC4(condition,operateur_si_VRAI,operateur_si_FAUX,a,b,c,d) \
COND(condition,operateur_si_VRAI(a,b,c,d),operateur_si_FAUX(a,b,c,d)) \
/* Cas des operateurs a quatre operandes... */
#define OPC5(condition,operateur_si_VRAI,operateur_si_FAUX,a,b,c,d,e) \
COND(condition,operateur_si_VRAI(a,b,c,d,e),operateur_si_FAUX(a,b,c,d,e)) \
/* Cas des operateurs a cinq operandes (introduit le 20100210103412)... */
#define OPC6(condition,operateur_si_VRAI,operateur_si_FAUX,a,b,c,d,e,f) \
COND(condition,operateur_si_VRAI(a,b,c,d,e,f),operateur_si_FAUX(a,b,c,d,e,f)) \
/* Cas des operateurs a six operandes (introduit le 20101128150711)... */
#define OPC7(condition,operateur_si_VRAI,operateur_si_FAUX,a,b,c,d,e,f,g) \
COND(condition,operateur_si_VRAI(a,b,c,d,e,f,g),operateur_si_FAUX(a,b,c,d,e,f,g)) \
/* Cas des operateurs a sept operandes (introduit le 20101128150711)... */
#define OPC8(condition,operateur_si_VRAI,operateur_si_FAUX,a,b,c,d,e,f,g,h) \
COND(condition,operateur_si_VRAI(a,b,c,d,e,f,g,h),operateur_si_FAUX(a,b,c,d,e,f,g,h)) \
/* Cas des operateurs a huit operandes (introduit le 20101128150711)... */
#define OPC9(condition,operateur_si_VRAI,operateur_si_FAUX,a,b,c,d,e,f,g,h,i) \
COND(condition,operateur_si_VRAI(a,b,c,d,e,f,g,h,i),operateur_si_FAUX(a,b,c,d,e,f,g,h,i)) \
/* Cas des operateurs a neuf operandes (introduit le 20101128150711)... */
#define OPC10(condition,operateur_si_VRAI,operateur_si_FAUX,a,b,c,d,e,f,g,h,i,j) \
COND(condition,operateur_si_VRAI(a,b,c,d,e,f,g,h,i,j),operateur_si_FAUX(a,b,c,d,e,f,g,h,i,j)) \
/* Cas des operateurs a dix operandes (introduit le 20101128150711)... */
#define OPC11(condition,operateur_si_VRAI,operateur_si_FAUX,a,b,c,d,e,f,g,h,i,j,k) \
COND(condition,operateur_si_VRAI(a,b,c,d,e,f,g,h,i,j,k),operateur_si_FAUX(a,b,c,d,e,f,g,h,i,j,k)) \
/* Cas des operateurs a onze operandes (introduit le 20101128150711)... */
#define OPC12(condition,operateur_si_VRAI,operateur_si_FAUX,a,b,c,d,e,f,g,h,i,j,k,l) \
COND(condition,operateur_si_VRAI(a,b,c,d,e,f,g,h,i,j,k,l),operateur_si_FAUX(a,b,c,d,e,f,g,h,i,j,k,l)) \
/* Cas des operateurs a douze operandes (introduit le 20101128150711)... */
#define OPC13(condition,operateur_si_VRAI,operateur_si_FAUX,a,b,c,d,e,f,g,h,i,j,k,l,m) \
COND(condition,operateur_si_VRAI(a,b,c,d,e,f,g,h,i,j,k,l,m),operateur_si_FAUX(a,b,c,d,e,f,g,h,i,j,k,l,m)) \
/* Cas des operateurs a treize operandes (introduit le 20101128150711)... */
#define OPC14(condition,operateur_si_VRAI,operateur_si_FAUX,a,b,c,d,e,f,g,h,i,j,k,l,m,n) \
COND(condition,operateur_si_VRAI(a,b,c,d,e,f,g,h,i,j,k,l,m,n),operateur_si_FAUX(a,b,c,d,e,f,g,h,i,j,k,l,m,n)) \
/* Cas des operateurs a quatorze operandes (introduit le 20101128150711)... */
/* ATTENTION : on notera le 20110821102426 que les operateurs 'OPC?(...)' ne peuvent pas */
/* figurer directement au niveau d'un '$K', mais doivent etre necessairement a un niveau */
/* superieur (par exemple celui d'un '$I' : voir 'v $xcg/SegReduct.01$I OPC1' par exemple). */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* I T E R A T I O N R E C U R S I V E D ' O P E R A T E U R S : */
/* */
/*************************************************************************************************************************************/
#define OPIR02(oper,variable,profondeur,ValeurDefautInferieure,ValeurDefautSuperieure) \
CON04(IFLT(profondeur,ZERO) ,NEUT(ValeurDefautInferieure) \
,IFEQ(profondeur,ZERO) ,NEUT(variable) \
,IFEQ(profondeur,UN) ,oper(variable) \
,IFEQ(profondeur,DEUX) ,oper(oper(variable)) \
,NEUT(ValeurDefautSuperieure) \
)
#define OPIR03(oper,variable,profondeur,ValeurDefautInferieure,ValeurDefautSuperieure) \
CON05(IFLT(profondeur,ZERO) ,NEUT(ValeurDefautInferieure) \
,IFEQ(profondeur,ZERO) ,NEUT(variable) \
,IFEQ(profondeur,UN) ,oper(variable) \
,IFEQ(profondeur,DEUX) ,oper(oper(variable)) \
,IFEQ(profondeur,TROIS) ,oper(oper(oper(variable))) \
,NEUT(ValeurDefautSuperieure) \
)
#define OPIR04(oper,variable,profondeur,ValeurDefautInferieure,ValeurDefautSuperieure) \
CON06(IFLT(profondeur,ZERO) ,NEUT(ValeurDefautInferieure) \
,IFEQ(profondeur,ZERO) ,NEUT(variable) \
,IFEQ(profondeur,UN) ,oper(variable) \
,IFEQ(profondeur,DEUX) ,oper(oper(variable)) \
,IFEQ(profondeur,TROIS) ,oper(oper(oper(variable))) \
,IFEQ(profondeur,QUATRE) ,oper(oper(oper(oper(variable)))) \
,NEUT(ValeurDefautSuperieure) \
)
#define OPIR05(oper,variable,profondeur,ValeurDefautInferieure,ValeurDefautSuperieure) \
CON07(IFLT(profondeur,ZERO) ,NEUT(ValeurDefautInferieure) \
,IFEQ(profondeur,ZERO) ,NEUT(variable) \
,IFEQ(profondeur,UN) ,oper(variable) \
,IFEQ(profondeur,DEUX) ,oper(oper(variable)) \
,IFEQ(profondeur,TROIS) ,oper(oper(oper(variable))) \
,IFEQ(profondeur,QUATRE) ,oper(oper(oper(oper(variable)))) \
,IFEQ(profondeur,CINQ) ,oper(oper(oper(oper(oper(variable))))) \
,NEUT(ValeurDefautSuperieure) \
)
#define OPIR08(oper,variable,profondeur,ValeurDefautInferieure,ValeurDefautSuperieure) \
CON10(IFLT(profondeur,ZERO) ,NEUT(ValeurDefautInferieure) \
,IFEQ(profondeur,ZERO) ,NEUT(variable) \
,IFEQ(profondeur,UN) ,oper(variable) \
,IFEQ(profondeur,DEUX) ,oper(oper(variable)) \
,IFEQ(profondeur,TROIS) ,oper(oper(oper(variable))) \
,IFEQ(profondeur,QUATRE) ,oper(oper(oper(oper(variable)))) \
,IFEQ(profondeur,CINQ) ,oper(oper(oper(oper(oper(variable))))) \
,IFEQ(profondeur,SIX) ,oper(oper(oper(oper(oper(oper(variable)))))) \
,IFEQ(profondeur,SEPT) ,oper(oper(oper(oper(oper(oper(oper(variable))))))) \
,IFEQ(profondeur,HUIT) ,oper(oper(oper(oper(oper(oper(oper(oper(variable)))))))) \
,NEUT(ValeurDefautSuperieure) \
)
/* Iteration Recursive d'un OPerateur (introduite le 20160615094603). Au passage, je n'ai */
/* rien trouve de plus simple et de plus elegant de facon a ce que cela puisse s'appliquer */
/* a un operateur quelconque ('v $xrv/SLOGX.01$K OPIR03'). */
/* */
/* Le 20160615101338, j'ai introduit 'OPIR03(...)', tout en conservant 'OPIR08(...)', */
/* sachant que ce dernier pose des problemes de temps d'execution de 'v $xcc/cpp$Z'... */
/* Au passage, j'ai essaye de passer de 'TROIS' a 'QUATRE', mais ce n'est pas raisonnable... */
/* A titre d'information l'instruction 'v $xrv/SLOGX.01$K ,OPIR03.SLOGX', une fois traduite */
/* en '$c' passe de 818 a 8168 lignes. Je note le 20160617141551 que c'est fort probablement */
/* le 'ABSO(...)' contenu dans la definition de 'SLOGX(...)' via 'fSOPER(....)' qui en est */
/* responsable... */
/* */
/* Le 20160617153646, grace a l'utilisation de 'fABSO(...)' dans la definition de */
/* 'SLOGX(...)', 'OPIR04(...)' et 'OPIR05(...)' ont pu etre introduits raisonnablement... */
/* */
/* En fait, a la date du 20160617161945, seul 'OPIR05(...)' est utile, tous les autres */
/* pourraient etre supprimes... */
/* */
/* Suite a l'introduction de 'OPIR0n(...)' le 20160618094352, les 'OPIR0?(...)' ont */
/* perdu toute utilite, mais pour le plaisir je les conserve (privisoirement ?). */
#define gOPIR0n(valeur_courante_de_l_operateur,variable,profondeur,ValeurDefautInferieure,Type,ValeurUndef) \
/* Dans cette version generale, 'ValeurDefautSuperieure' n'a plus de sens... */ \
PARE( \
Bblock \
DEFV(Type,INIT(gOPIR0n_____VariableTemporaire,ValeurUndef)); \
/* On notera que l'on pourrait ecrire : */ \
/* */ \
/* DEFV(Type,INIT(gOPIR0n_____VariableTemporaire,NEUT(variable))); */ \
/* */ \
/* pour optimiser d'une part en simplifiant le cas ou 'IFEQ(profondeur,ZERO)' et d'autre */ \
/* part en supprimant l'initialisation de 'gOPIR0n_____VariableTemporaire' avant le */ \
/* 'Repe(...)', mais la valeur initiale de 'gOPIR0n_____VariableTemporaire' pourrait etre */ \
/* differente dans ces deux cas en toute generalite... */ \
\
Test(IFLE(profondeur,ZERO)) \
Bblock \
EGAL(gOPIR0n_____VariableTemporaire,COND(IFLT(profondeur,ZERO),ValeurDefautInferieure,NEUT(variable))); \
Eblock \
ATes \
Bblock \
EGAL(gOPIR0n_____VariableTemporaire,NEUT(variable)); \
\
Repe(profondeur) \
Bblock \
EGAL(gOPIR0n_____VariableTemporaire,valeur_courante_de_l_operateur); \
/* Iteration de 'operateur(...)'... */ \
/* */ \
/* Jusqu'au 20160620134325, il y avait ci-dessus : */ \
/* */ \
/* EGAL(gOPIR0n_____VariableTemporaire,operateur(gOPIR0n_____VariableTemporaire)); */ \
/* */ \
/* L'inconvenient etait alors que l'on se limitait a des operateurs unaires. Or de nombreux */ \
/* operateurs ne le sont pas (par exemple 'SPUIX(...)'). D'ou cette nouvelle formulation */ \
/* qui renvoie le calcul dans l'appel a 'gOPIR0n(...)'. */ \
Eblock \
ERep \
Eblock \
ETes \
\
NEUT(gOPIR0n_____VariableTemporaire); \
/* Renvoi de la valeur de 'variable' iteree 'profondeur' fois par 'operateur(...)'... */ \
Eblock \
) \
/* Version generale de l'Iteration Recursive d'un OPerateur (introduite le 20160618094352). */
#define fOPIR0n(valeur_courante_de_l_operateur,variable,profondeur,ValeurDefautInferieure) \
gOPIR0n(valeur_courante_de_l_operateur \
,variable \
,profondeur \
,ValeurDefautInferieure \
,Float \
,FLOT__UNDEF \
)
#define fOPIR1n(operateur,variable,profondeur,ValeurDefautInferieure) \
fOPIR0n(operateur(gOPIR0n_____VariableTemporaire) \
,variable \
,profondeur \
,ValeurDefautInferieure \
)
/* Versions flottantes de l'Iteration Recursive d'un OPerateur (introduite le */
/* 20160618111504). L'operateur 'fOPIR0n(...)' et la version generale flottante. */
/* */
/* Le 20160620134325 a ete introduite 'fOPIR1n(...)' qui est la version operateur unaire (1) */
/* de 'fOPIR0n(...)'. On notera que pour operateurs N-aires et par exemple 'SPUIX(...)', on */
/* ecrira : */
/* */
/* fOPIR0n(SPUIX(gOPIR0n_____VariableTemporaire,exposant) */
/* ,variable */
/* ,profondeur */
/* ,ValeurDefautInferieure */
/* ) */
/* */
/* Voir par exemple 'v $xrv/SPUIX.01$K fOPIR0n.SPUIX.' a ce propos... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* O P E R A T I O N S A R I T H M E T I Q U E S D ' A D D I T I O N : */
/* */
/*************************************************************************************************************************************/
-define ADD1(a) \
-_-_-_- NEUT(a)
/* La fonction 'ADD1' est introduite afin de "symetriser" les sommes a 1 terme... */
_____define(GenOperator_PASSE_D_____ADDn,++D++-define $1($3,$4) \
-_-_-_- ADD2($2($3),$4)++F++
)
/* Generateur des 'ADD?(....)'s introduit le 20070914092847... */
/* */
/* Definition des arguments de 'GenOperator.PASSE.D.....ADDn(...)' (on notera la presence */
/* des "."s au lieu des "_"s dans les commentaires relatifs a cet operateur : cela est */
/* destine a bloquer l'action de '$m4' dans ces commentaires...) : */
/* */
/* $1 : nom de l'operateur 'ADD?' a definir (de rang 'n'), */
/* $2 : nom de l'operateur 'ADD?' a utiliser (de rang 'n-1'), */
/* $3 : premiere liste d'arguments (nombre variables d'elements), */
/* $4 : deuxieme liste d'arguments (toujours un seul element). */
/* */
/* ATTENTION : l'absence de "," en bout de ligne (derriere 'GenOperator.PASSE.D.....ADDn') */
/* donne a priori a 'GenOperator.PASSE.D.....ADDn' une valeur vide. Or cela fait partie de */
/* mon modele de programmation. La modification 'v $xcc/cpp$Z 20070912133816' est destinee */
/* justement a deplacer la "," de debut de ligne pour la mettre a la fin de la ligne */
/* precedente et ainsi donner a 'GenOperator.PASSE.D.....ADDn' la bonne definition... */
/* */
/* Le 20070913153802 le nom 'GenOperator_____ADDn(...)' fut change en */
/* 'GenOperator_P_D_____ADDn(...)' afin de contenir la passe '$PASSE_D' de generation, */
/* ce qui est utile dans 'v $xi/DICO$D/GenOperator$vv$sub GenOperator_P_._____'. */
/* */
/* Le 20071003152838 le nom 'GenOperator_P_D_____ADDn(...)' a ete change en */
/* 'GenOperator.PASSE.D.....ADDn(...)' pour une meilleure lisibilite... */
GenOperator_PASSE_D_____ADDn(ADD3 ,ADD2 ,++D++a,b++F++,++D++c++F++)
GenOperator_PASSE_D_____ADDn(ADD4 ,ADD3 ,++D++a,b,c++F++,++D++d++F++)
GenOperator_PASSE_D_____ADDn(ADD5 ,ADD4 ,++D++a,b,c,d++F++,++D++e++F++)
GenOperator_PASSE_D_____ADDn(ADD6 ,ADD5 ,++D++a,b,c,d,e++F++,++D++f++F++)
GenOperator_PASSE_D_____ADDn(ADD7 ,ADD6 ,++D++a,b,c,d,e,f++F++,++D++g++F++)
GenOperator_PASSE_D_____ADDn(ADD8 ,ADD7 ,++D++a,b,c,d,e,f,g++F++,++D++h++F++)
GenOperator_PASSE_D_____ADDn(ADD9 ,ADD8 ,++D++a,b,c,d,e,f,g,h++F++,++D++i++F++)
GenOperator_PASSE_D_____ADDn(ADD10,ADD9 ,++D++a,b,c,d,e,f,g,h,i++F++,++D++j++F++)
GenOperator_PASSE_D_____ADDn(ADD11,ADD10,++D++a,b,c,d,e,f,g,h,i,j++F++,++D++k++F++)
GenOperator_PASSE_D_____ADDn(ADD12,ADD11,++D++a,b,c,d,e,f,g,h,i,j,k++F++,++D++l++F++)
GenOperator_PASSE_D_____ADDn(ADD13,ADD12,++D++a,b,c,d,e,f,g,h,i,j,k,l++F++,++D++m++F++)
GenOperator_PASSE_D_____ADDn(ADD14,ADD13,++D++a,b,c,d,e,f,g,h,i,j,k,l,m++F++,++D++n++F++)
GenOperator_PASSE_D_____ADDn(ADD15,ADD14,++D++a,b,c,d,e,f,g,h,i,j,k,l,m,n++F++,++D++o++F++)
GenOperator_PASSE_D_____ADDn(ADD16,ADD15,++D++a,b,c,d,e,f,g,h,i,j,k,l,m,n,o++F++,++D++p++F++)
/* Le 20080102130008, furent introduites 'ADD15(...)' et 'ADD16(...)'. */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N D E L A D E R I V E E D ' U N E S O M M E : */
/* */
/*************************************************************************************************************************************/
#define d_ADD2(u,v) \
ADD2(d#u,d#v)
#define d_bADD(u,v) \
bADD(d#u,d#v)
/* Derivee de la somme de deux termes : */
/* */
/* d(u+v) = d(u) + d(v) */
/* */
/* Le 20101210184750 la derivee de 'd_bADD(...)' a ete introduite a cause des modifications */
/* faites aux environs du 20101120092003... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* O P E R A T I O N V A L E U R A B S O L U E : */
/* */
/*************************************************************************************************************************************/
-define ABSO(x) \
-_-_-_- COND(IZGE(x),NEUT(x),NEGA(x))
/* Recherche de la valeur absolue du nombre 'x'. */
/* */
/* Le 20080104145324, la procedure 'NEUT(...)' fut introduite par symetrie avec 'NEGA(...)'. */
-define OSBA(x) \
-_-_-_- NEGA(ABSO(x))
/* La "Anti Valeur Absolue" a ete introduite le 20070820130154, pour le plaisir... */
#define fABSO(x) \
PARE( \
Bblock \
DEFV(Float,INIT(fABSO_____VariableTemporaire,NEUT(x))); \
ABSO(fABSO_____VariableTemporaire); \
Eblock \
) \
/* Version flottante optimisee introduite le 20160617153646 pour alleger la compilation */ \
/* de 'v $xrv/SLOGX.01$K .OPIR03.SLOGX'... Elle permet de ne calculer qu'une seule fois */ \
/* la valeur de 'x'... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* O P E R A T I O N S A R I T H M E T I Q U E S D E S O U S T R A C T I O N : */
/* */
/*************************************************************************************************************************************/
#define SOUA(a,b) \
ABSO(SOUS(a,b)) \
/* Soustraction en valeur absolue des deux nombres 'a' et 'b'. */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N D E L A D E R I V E E D ' U N E D I F F E R E N C E : */
/* */
/*************************************************************************************************************************************/
#define d_SOUS(u,v) \
SOUS(d#u,d#v)
#define d_bSOU(u,v) \
bSOU(d#u,d#v)
/* Derivee de la difference de deux termes : */
/* */
/* d(u-v) = d(u) - d(v) */
/* */
/* Le 20101210184750 la derivee de 'd_bADD(...)' a ete introduite a cause des modifications */
/* faites aux environs du 20101120092003... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* O P E R A T I O N S A R I T H M E T I Q U E S D E M U L T I P L I C A T I O N : */
/* */
/*************************************************************************************************************************************/
-define MUL0(a) \
-_-_-_- UN
/* La fonction 'MUL0' est introduite afin de "symetriser" les produits a 0 facteur et ce */
/* de facon compatible avec la fonction factorielle pour laquelle : */
/* */
/* 0! = 1 */
/* */
-define MUL1(a) \
-_-_-_- NEUT(a)
/* La fonction 'MUL1' est introduite afin de "symetriser" les produits a 1 facteur... */
_____define(GenOperator_PASSE_D_____MULn,++D++-define $1($3,$4) \
-_-_-_- MUL2($2($3),$4)++F++
)
/* Generateur des 'MUL?(....)'s introduit le 20070914092847... */
/* */
/* ATTENTION : On consultera avec profit les commentaires de 'v $xil/re_definit$DEF', la */
/* definition precedente pouvant, par exemple, se reformuler : */
/* */
/* MUL2($4,$2($3)) */
/* */
/* Definition des arguments de 'GenOperator.PASSE_D.....MULn(...)' (on notera la presence */
/* des "."s au lieu des "_"s dans les commentaires relatifs a cet operateur : cela est */
/* destine a bloquer l'action de '$m4' dans ces commentaires...) : */
/* */
/* $1 : nom de l'operateur 'MUL?' a definir (de rang 'n'), */
/* $2 : nom de l'operateur 'MUL?' a utiliser (de rang 'n-1'), */
/* $3 : premiere liste d'arguments (nombre variables d'elements), */
/* $4 : deuxieme liste d'arguments (toujours un seul element). */
/* */
/* ATTENTION : l'absence de "," en bout de ligne (derriere 'GenOperator.PASSE_D.....MULn') */
/* donne a priori a 'GenOperator.PASSE_D.....MULn' une valeur vide. Or cela fait partie de */
/* mon modele de programmation. La modification 'v $xcc/cpp$Z 20070912133816' est destinee */
/* justement a deplacer la "," de debut de ligne pour la mettre a la fin de la ligne */
/* precedente et ainsi donner a 'GenOperator.PASSE_D.....MULn' la bonne definition... */
/* */
/* Le 20070913153802 le nom 'GenOperator_____MULn(...)' fut change en */
/* 'GenOperator_P_D_____MULn(...)' afin de contenir la passe '$PASSE_D' de generation, */
/* ce qui est utile dans 'v $xi/DICO$D/GenOperator$vv$sub GenOperator_P_._____'. */
/* */
/* Le 20071003152838 le nom 'GenOperator_P_D_____MULn(...)' a ete change en */
/* 'GenOperator.PASSE_D.....MULn(...)' pour une meilleure lisibilite... */
GenOperator_PASSE_D_____MULn(MUL3,MUL2,++D++a,b++F++,++D++c++F++)
GenOperator_PASSE_D_____MULn(MUL4,MUL3,++D++a,b,c++F++,++D++d++F++)
GenOperator_PASSE_D_____MULn(MUL5,MUL4,++D++a,b,c,d++F++,++D++e++F++)
GenOperator_PASSE_D_____MULn(MUL6,MUL5,++D++a,b,c,d,e++F++,++D++f++F++)
GenOperator_PASSE_D_____MULn(MUL7,MUL6,++D++a,b,c,d,e,f++F++,++D++g++F++)
GenOperator_PASSE_D_____MULn(MUL8,MUL7,++D++a,b,c,d,e,f,g++F++,++D++h++F++)
GenOperator_PASSE_D_____MULn(MUL9,MUL8,++D++a,b,c,d,e,f,g,h++F++,++D++i++F++)
GenOperator_PASSE_D_____MULn(MUL10,MUL9,++D++a,b,c,d,e,f,g,h,i++F++,++D++j++F++)
/* Le 20181104103702 'MUL6(...)', 'MUL7(...)', 'MUL8(...)' et 'MUL9(...)' ont ete */
/* introduits "pour le plaisir" (inutiles a cette date...). */
/* */
/* Le 20190203101754, 'MUL10(...)' a ete introduit (bien qu'il ne serve a rien a cette */
/* date) afin de rappeler qu'a compter du 20190201124644, ce type d'operateur est numerote */
/* sur deux chiffres apres le numero "9"... */
#define MULH24(a,b) \
FfHORNER_2_04(FLOT(a),FLOT(b)) \
/* Fonction 'FfHORNER_2_04(...)' introduite le 20181203155632... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N D E L A D E R I V E E D ' U N P R O D U I T : */
/* */
/*************************************************************************************************************************************/
#define d_MUL2(u,v) \
ADD2(MUL2(d#u,v),MUL2(u,d#v))
#define d_bMUL(u,v) \
bADD(bMUL(d#u,v),bMUL(u,d#v))
/* Derivee du produit de deux termes : */
/* */
/* d(u.v) = [d(u).v] + [u.d(v)] */
/* */
/* Le 20101210184750 la derivee de 'd_bADD(...)' a ete introduite a cause des modifications */
/* faites aux environs du 20101120092003... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* O P E R A T I O N S A R I T H M E T I Q U E S D E D I V I S I O N : */
/* */
/*************************************************************************************************************************************/
-define DIV0(a,b,c,d) \
-_-_-_- COND(IFET(IZEQ(a),IZEQ(b)) \
-_-_-_- ,d \
-_-_-_- ,COND(IZEQ(b) \
-_-_-_- ,c \
-_-_-_- ,DIVI(a,b) \
-_-_-_- ) \
-_-_-_- )
/* Division de 'a' par 'b' avec traitement de la division par 0 (avec renvoi d'une valeur */
/* donnee par l'argument 'c') et du cas 0/0 (avec renvoi d'une valeur donnee par l'argument */
/* 'd'). */
-define DIVZ(a,b) \
-_-_-_- DIV0(a,b,MEME_SIGNE_QUE(a,INFINI),UN)
/* Division de 'a' par 'b' avec traitement de la division par 0, et renvoi eventuel */
/* de l'infini ou de 1 dans le cas des divisions par 0... */
-define DIVZI(a,b,valeur_en_cas_d_Indetermination) \
-_-_-_- DIV0(a,b,MEME_SIGNE_QUE(a,INFINI),valeur_en_cas_d_Indetermination)
/* Division de 'a' par 'b' avec traitement de la division par 0, et renvoi eventuel */
/* de l'infini dans le cas a/0 et une valeur donnee dans le cas "Indetermine" 0/0. Ceci */
/* a ete introduit le 20021120172628 pour 'v $xrs/bKlein.41$I DIVZI'. */
-define fDIVZ(a,b) \
-_-_-_- DIV0(a,b,MEME_SIGNE_QUE(a,F_INFINI),FU)
/* Division de 'a' par 'b' avec traitement de la division par 0, et renvoi eventuel */
/* de l'infini ou de 1 dans le cas des divisions par 0... Le 20001223232351, le 'UN' */
/* fut remplace par 'FU'. */
-define fDIVZI(a,b,valeur_en_cas_d_Indetermination) \
-_-_-_- DIV0(a,b,MEME_SIGNE_QUE(a,F_INFINI),valeur_en_cas_d_Indetermination)
/* Division de 'a' par 'b' avec traitement de la division par 0, et renvoi eventuel */
/* de l'infini dans le cas a/0 et une valeur donnee dans le cas "Indetermine" 0/0. Ceci */
/* a ete introduit le 20021120172628 par symetrie avec 'DIVZI(...)'. */
#define RESZ(a,b) \
COND(IZNE(b),REST(a,b),a) \
/* Reste de la division entiere de 'a' par 'b' avec traitement special du cas b=0. Ceci a */ \
/* ete introduit le 20010531103929 pour 'v $xrs/CalabiYau.21$K RESZ' par exemple. */ \
/* */ \
/* Jusqu'au 20140307093749, la definition etait : */ \
/* */ \
/* COND(IZNE(b),REST(a,b),b) */ \
/* */ \
/* Or la definition de la division euclidienne est : */ \
/* */ \
/* a = b.q + r */ \
/* */ \
/* ce qui donne : */ \
/* */ \
/* a = r */ \
/* */ \
/* si 'b' est nul, d'ou la nouvelle definition... */
#define DIV0_a_peu_pres(a,b,c,d,epsilon) \
COND(IFET(IZEQ_a_peu_pres(a,epsilon),IZEQ_a_peu_pres(b,epsilon)) \
,d \
,COND(IZEQ_a_peu_pres(b,epsilon) \
,c \
,DIVI(a,b) \
) \
) \
/* Division de 'a' par 'b' avec traitement de la division par 0 (avec renvoi d'une valeur */ \
/* donnee par l'argument 'c') et du cas 0/0 (avec renvoi d'une valeur donnee par l'argument */ \
/* 'd'), les tests de nullite etant faits a "epsilon pres"... */
#define DIVZ_a_peu_pres(a,b,epsilon) \
DIV0_a_peu_pres(a,b,MEME_SIGNE_QUE(a,INFINI),UN,epsilon) \
/* Division de 'a' par 'b' avec traitement de la division par 0, et renvoi eventuel */ \
/* de l'infini ou de un dans le cas des divisions par 0 a "epsilon pres"... */
#define fDIVZ_a_peu_pres(a,b,epsilon) \
DIV0_a_peu_pres(a,b,MEME_SIGNE_QUE(a,F_INFINI),UN,epsilon) \
/* Division de 'a' par 'b' avec traitement de la division par 0, et renvoi eventuel */ \
/* de l'infini ou de un dans le cas des divisions par 0 a "epsilon pres"... */
#define QUOD(a,b) \
INTE(bDIV(INTE(a),INTE(b))) \
/* Quotient par defaut des deux nombres 'a' et 'b' ; le quotient et le */ \
/* reste sont du signe du dividende 'a'. */
#define QUOE(a,b) \
COND(IZEQ(REST(a,b)) \
,QUOD(a,b) \
,COND(IFEQ(SIGN(bMUL(a,b)),SIGNE_PLUS) \
,SUCC(QUOD(a,b)) \
,PRED(QUOD(a,b)) \
) \
) \
/* Quotient par exces des deux nombres 'a' et 'b' ; le quotient a le signe */ \
/* du produit 'a*b'. ATTENTION, il y avait autrefois : */ \
/* */ \
/* IFEQ(SIGN(QUOD(a,b)),SIGNE_PLUS) */ \
/* */ \
/* ce qui n'est pas compatible avec le commentaire precedent... */ \
/* */ \
/* Le 20101120091431, 'bMUL(...)' a remplace 'MUL2(...)'. */
#define MULD(a,b) \
bMUL(QUOD(a,b),INTE(b)) \
/* Donne le multiple de 'b' qui soit le plus proche de 'a' par defaut. */ \
/* */ \
/* Le 20090319113909, je me demande quelle est la difference avec 'iMULTIPLE(...)' ? A */ \
/* priori, il n'y en a pas mais on ne sait jamais... */
#define MULE(a,b) \
bMUL(QUOE(a,b),INTE(b)) \
/* Donne le multiple de 'b' qui soit le plus proche de 'a' par exces. */
#nodefine fMULD_VERSION_01(a,b) \
SOUS(a,MODF(a,FZERO,b)) \
/* Donne le multiple de 'b' qui soit le plus proche de 'a' par defaut en flottant (premiere */ \
/* version)... */ \
/* */ \
/* Le 20030222102112, 'fMULD_VERSION_01(...)' est passe de 'define' a 'nodefine' afin de */ \
/* ne pas etre recupere par le processus 'v $xcc/cpp$Z _VERSION_'. */
#define fMULD_VERSION_02(a,b) \
SOUS(a,COND(IZGE(fREST(a,b)),fREST(a,b),NEGA(fREST(a,b)))) \
/* Donne le multiple de 'b' qui soit le plus proche de 'a' par defaut en flottant (deuxieme */ \
/* version). ATTENTION, il y a eu pendant un temps : */ \
/* */ \
/* SOUS(a,COND(IZGE(fREST(a,b)),fREST(a,b),ADD2(fREST(a,b),b))) */ \
/* */ \
/* mais cela semble faux... */
#nodefine fMULD_VERSION_03(a,b) \
ffMULD(a,b) \
/* Donne le multiple de 'b' qui soit le plus proche de 'a' par defaut en flottant (troisieme */ \
/* version)... */ \
/* */ \
/* Le 20030222102112, 'fMULD_VERSION_03(...)' est passe de 'define' a 'nodefine' afin de */ \
/* ne pas etre recupere par le processus 'v $xcc/cpp$Z _VERSION_'. */
#define fMULD(a,b) \
fMULD_VERSION_02(a,b) \
/* Donne le multiple de 'b' qui soit le plus proche de 'a' par defaut en flottant (version */ \
/* courante)... */
#nodefine fMULE_VERSION_01(a,b) \
ADD2(a,SOUS(b,MODF(a,FZERO,b))) \
/* Donne le multiple de 'b' qui soit le plus proche de 'a' par exces en flottant (premiere */ \
/* version)... */ \
/* */ \
/* Le 20030222102112, 'fMULE_VERSION_01(...)' est passe de 'define' a 'nodefine' afin de */ \
/* ne pas etre recupere par le processus 'v $xcc/cpp$Z _VERSION_'. */
#define fMULE_VERSION_02(a,b) \
ADD2(fMULD_VERSION_02(a,b),b) \
/* Donne le multiple de 'b' qui soit le plus proche de 'a' par exces en flottant (deuxieme */ \
/* version)... */
#nodefine fMULE_VERSION_03(a,b) \
ADD2(fMULD_VERSION_02(a,b),b) \
/* Donne le multiple de 'b' qui soit le plus proche de 'a' par exces en flottant (troisieme */ \
/* version)... */ \
/* */ \
/* Le 20030222102112, 'fMULE_VERSION_03(...)' est passe de 'define' a 'nodefine' afin de */ \
/* ne pas etre recupere par le processus 'v $xcc/cpp$Z _VERSION_'. */
#define fMULE(a,b) \
fMULE_VERSION_02(a,b) \
/* Donne le multiple de 'b' qui soit le plus proche de 'a' par exces en flottant (version */ \
/* courante)... */
#define MULF(x,h) \
bDIV(AINT(bMUL(x,h)),h) \
/* Ramene le nombre 'x' a une valeur inferieure ou egale 'y' tel que le produit 'y.h' soit */ \
/* entier. Par exemple : */ \
/* */ \
/* MULF(3.1415,100) = 3.14 */ \
/* */ \
/* ATTENTION, jusqu'au 1995111900, il y avait ici : */ \
/* */ \
/* #define MULF(x,h) \ */ \
/* DIVI(ARRO(MUL2(x,h)),h) */ \
/* */ \
/* mais le 'ARRO(...)' travaille aussi bien par defaut que par exces... */ \
/* */ \
/* ATTENTION, jusqu'au 1995120400, il y avait ici : */ \
/* */ \
/* #define MULF(x,h) \ */ \
/* DIVI(fENTE(MUL2(x,h)),h) */ \
/* */ \
/* mais pour de petits epsilon, la fonction 'INTE(...)' qui etait alors appelee creait un */ \
/* defaut de conversion "flottant vers entier" (debordement...). */ \
/* */ \
/* Le 20101120081525, 'bDIV(...)' et 'bMUL(...)' ont remplace 'DIVI(...)' et 'MUL2(...)'. */
#define iMULTIPLE(x,m) \
bMUL(INTE(bDIV(x,m)),m) \
/* Construction d'un nombre entier voisin de 'x' et multiple de 'm' (introduit le */ \
/* 20031111175851 pour 'v $xcg/CheckMem$vv$K iMULTIPLE'). */ \
/* */ \
/* Le 20090319113909, je me demande quelle est la difference avec 'MULD(...)' ? A priori, */ \
/* il n'y en a pas mais on ne sait jamais... */
#define MULTIPLE(x,m) \
FLOT(iMULTIPLE(x,m)) \
/* Construction d'un nombre flottant voisin de 'x' et multiple de 'm'. */
#define MULTIPLE1(x,m) \
COND(IFEQ(m,FU),x,MULTIPLE(x,m)) \
/* Construction d'un nombre flottant voisin de 'x' et multiple de 'm' en garantissant */ \
/* de conserver la valeur de 'x' si 'm' est egal a l'unite (introduit le 20231010095702...). */
#define DIVISIBLE(a,b) \
COND(IZEQ(REST(a,b)),VRAI,FAUX) \
/* Test de la divisibilite de 'a' par 'b'. */
#define NON_DIVISIBLE(a,b) \
NOTL(DIVISIBLE(a,b)) \
/* Test de la non divisibilite de 'a' par 'b'. */
#define fDIVISIBLE(a,b) \
COND(IFEQ(fMULD(a,b),a),VRAI,FAUX) \
/* Test de la divisibilite de 'a' par 'b' pour des nombres flottants. */
#define fNON_DIVISIBLE(a,b) \
NOTL(fDIVISIBLE(a,b)) \
/* Test de la non divisibilite de 'a' par 'b' pour des nombres flottants. */
#define fDIVISIBLE_a_peu_pres_absolu(a,b,epsilon) \
COND(IFEQ_a_peu_pres_absolu(fMULD(a,b),a,epsilon),VRAI,FAUX) \
/* Test de la divisibilite de 'a' par 'b' pour des nombres flottants a 'epsilon' pres. */
#define fNON_DIVISIBLE_a_peu_pres_absolu(a,b,epsilon) \
NOTL(fDIVISIBLE_a_peu_pres_absolu(a,b,epsilon)) \
/* Test de la non divisibilite de 'a' par 'b' pour des nombres flottants a 'epsilon' pres. */
#define EST_ENTIER(x) \
IFEQ(x,INTE(x)) \
/* Test de la nature entiere de 'x' pour des petits nombres (c'est-a-dire inferieurs ou */ \
/* egaux en valeur absolue a 'INFINI'). */
#define N_EST_PAS_ENTIER(x) \
NOTL(EST_ENTIER(x)) \
/* Test de la nature non entiere de 'x' pour des petits nombres (c'est-a-dire inferieurs ou */ \
/* egaux en valeur absolue a 'INFINI'). */
#define fEST_ENTIER(x) \
IFEQ(x,AINT(x)) \
/* Test de la nature entiere de 'x' pour des nombres quelconques (de toute grandeur...). */
#define fN_EST_PAS_ENTIER(x) \
NOTL(fEST_ENTIER(x)) \
/* Test de la nature non entiere de 'x' pour des nombres quelconques (de toute grandeur...). */
#define fiEST_ENTIER(x) \
IFEQ(FLOT(VINTE(x)),x) \
/* Test de la nature entiere de 'x' pour des nombres quelconques avec test des Infinis (ceci */ \
/* fut introduit le 20210307182306 pour 'v $xig/defin_2$vv$DEF fiEST_ENTIER'). */
#define fiN_EST_PAS_ENTIER(x) \
NOTL(fiEST_ENTIER(x)) \
/* Test de la nature non entiere de 'x' pour des nombres quelconques avec test des Infinis */
/* (ceci fut introduit le 20210307182306). */
#define AINT_a_peu_pres(x,epsilon) \
AINT(bADD(x,epsilon)) \
/* Afin d'eviter les problemes d'arrondi ('v $xci/valeurs.02$I AINT_a_peu_pres'). */ \
/* */ \
/* Le 20101120092003, 'bADD(...)' plus logique a remplace 'ADD2(...)'. */
#define PGCD(a,b) \
PlusGrandCommunDiviseur(INTE(a),INTE(b))
#define PPCM(a,b) \
PlusPetitCommunMultiple(INTE(a),INTE(b))
/* "PGCD" et "PPCM" de deux nombres (procedures introduites le 20081116094531). */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N D E L A D E R I V E E D ' U N Q U O T I E N T : */
/* */
/*************************************************************************************************************************************/
#define d_DIVI(u,v) \
DIVI(SOUS(MUL2(d#u,v),MUL2(u,d#v)),EXP2(v))
#define d_bDIV(u,v) \
bDIV(bSOU(bMUL(d#u,v),bMUL(u,d#v)),EXP2(v))
/* Derivee du produit de deux termes : */
/* */
/* [d(u).v] - [u.d(v)] */
/* d(u.v) = --------------------- */
/* 2 */
/* v */
/* */
/* Le 20101210184750 la derivee de 'd_bADD(...)' a ete introduite a cause des modifications */
/* faites aux environs du 20101120092003... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* O P E R A T I O N S A R I T H M E T I Q U E S D ' A R R O N D I : */
/* */
/*************************************************************************************************************************************/
#define gFLIN(x,translation,entier) \
entier(bADD(COND(IZGE(x),x,bSOU(x,FU)),translation)) \
/* Passage general FLottant vers INteger avec translation quelconque lorsque l'argument 'x' */ \
/* est negatif et une conversion arbitraire. */ \
/* */ \
/* Le 20101120092003, 'bADD(...)' et 'bSOU(...)' ont remplace 'ADD2(...)' et 'SOUS(...)'. */
#define fFLIN(x,translation) \
gFLIN(x,translation,NEUT) \
/* Translation quelconque en restant en Flottant (introduit le 20040910142802 pour etre */ \
/* etre utilise dans 'v $xiiD/definit.2$DEF 20040910141428'). */
#define FLIN(x,translation) \
gFLIN(x,translation,INTE) \
/* Passage general FLottant vers INteger avec translation quelconque lorsque l'argument 'x' */ \
/* est negatif et une conversion standard. */
#define VFLIN(x,translation) \
gFLIN(x,translation,VINTE) \
/* Passage general FLottant vers INteger avec translation quelconque lorsque l'argument 'x' */ \
/* est negatif et une conversion avec validation de non debordement. */
#define TRANSLATION_D_ARRONDI_AU_PLUS_PROCHE_ENTIER \
FDU
#define ARRI(x) \
FLIN(x,TRANSLATION_D_ARRONDI_AU_PLUS_PROCHE_ENTIER)
/* Arrondi du nombre 'x' a la plus proche valeur entiere. */
#define ARRX(x) \
FLIN(x,UN_MOINS_EPSILON) \
/* Arrondi du nombre 'x' par exces, c'est-a-dire a l'entier suivant si 'x' n'est pas */ \
/* lui-meme un nombre entier. */
#define ARRO(x) \
FLOT(ARRI(x)) \
/* Version flottante de 'ARRI(...)'. */
#define ENTE(x) \
FLIN(x,FZERO) \
/* Arrondi du nombre 'x' a la plus proche valeur entiere, telle que : */ \
/* */ \
/* INTE(+0.75) = 0, */ \
/* INTE(+0.25) = 0, */ \
/* INTE(-0.25) = 0, */ \
/* INTE(-0.75) = 0, */ \
/* */ \
/* ENTE(+0.75) = 0, */ \
/* ENTE(+0.25) = 0, */ \
/* ENTE(-0.25) = -1, */ \
/* ENTE(-0.75) = -1. */ \
/* */ \
/* et au passage : */ \
/* */ \
/* INTE(+1.75) = +1, */ \
/* ENTE(+1.75) = +1, */ \
/* */ \
/* INTE(+2.00) = +2, */ \
/* ENTE(+2.00) = +2 (=INTE(+2.00)), */ \
/* */ \
/* INTE(-2.00) = -2, */ \
/* ENTE(-2.00) = -3 (=INTE(+2.00)-1). */ \
/* */
#define ENTO(x) \
FLOT(ENTE(x)) \
/* Version flottante de 'ENTE(...)' (introduite le 20120619084023). */
#define ANTE(x) \
FLIN(x,mgEPSILON) \
/* Arrondi du nombre 'x' a la plus proche valeur entiere destine a compenser les */ \
/* approximations (introduit le 20090225130838 pour 'v $xiii/di_image$DEF 20090225114137'. */
#define fINTE(x) \
FLOT(INTE(x)) \
/* Version flottante de 'INTE(...)'. */
#define fENTE(x) \
FLOT(ENTE(x)) \
/* Version flottante de 'ENTE(...)'. */
/* ATTENTION, avant la nouvelle definition de 'MOINS_L_INFINI' (le 30/03/94), il y avait */
/* ici : */
/* */
/* #define INFINI_M1 \ */
/* SOUS(INFINI,UN) */
/* #define MOINS_L_INFINI_P1 \ */
/* ADD2(MOINS_L_INFINI,UN) */
/* */
/* ces deux constantes sont definies car en effet, si l'on utilise directement plus ou moins */
/* l'infini, un probleme tres delicat apparaitrait. Celui-ci a ete mis en evidence dans le */
/* fichier 'v $xrq/nucleon.LS.1$I' lors de l'appel des procedures 'begin_colonneQ(...)' */
/* et 'begin_ligneQ(...)', lorsque les bornes des coordonnees etaient a l'infini. On pourra */
/* a ce propos voir le programme 'v $xtc/infini.01$c'... */
/* */
/* #define VINTE(x) \ */
/* INTE(COND(IFINff(x,FLOT(MOINS_L_INFINI_P1),FLOT(INFINI_M1)) \ */
/* ,x \ */
/* ,MEME_SIGNE_QUE(x,INFINI_M1) \ */
/* ) \ */
/* ) */
/* mais tout ceci est devenu inutile... */
#define VINTE(x) \
INTE(COND(IFINff(x,FLOT(MOINS_L_INFINI),FLOT(INFINI)) \
,x \
,MEME_SIGNE_QUE(x,INFINI) \
) \
) \
/* Partie entiere d'un nombre avec test de debordement possible lors de la conversion... */ \
/* ATTENTION, l'ecriture : */ \
/* */ \
/* VINTE(DEUXp31M1) */ \
/* */ \
/* est fausse car 'DEUXp31M1' est vu alors comme un nombre entier negatif, et la valeur */ \
/* renvoyee est egale a 'DEUXp31M1 - 2'... */
#nodefine fARRI_VERSION_01(x,epsilon) \
MULF(ADD2(x,MOIT(epsilon)),INVE(epsilon)) \
/* Arrondi du nombre 'x' a la plus proche valeur multiple de 'epsilon' (premiere version). */ \
/* On notera que (aux types pres), on a l'equivalence entre : */ \
/* */ \
/* ARRI(x) */ \
/* */ \
/* et : */ \
/* */ \
/* fARRI(x,UN) */ \
/* */ \
/* la nouveaute etant ici que cette notion peut etre etendue a des 'epsilon' non entiers... */ \
/* */ \
/* ATTENTION, jusqu'au 1995120500, il y avait ici : */ \
/* */ \
/* MULF(ADD2(x,MOIT(epsilon)),INVE(epsilon)) */ \
/* */ \
/* mais cela a cree des problemes dans '$xiii/aleat.2$vv$FON' lors de l'introduction des */ \
/* reductions lineaires ; malheureusement, la correction apportee : */ \
/* */ \
/* MULF(ADD2(x,MUL2(COMP(epsilon),epsilon)),INVE(epsilon)) */ \
/* */ \
/* a ete nefaste dans le cas des reductions non lineaires, d'ou un retour en arriere le */ \
/* meme jour... */ \
/* */ \
/* Le 20030222102112, 'fARRI_VERSION_01(...)' est passe de 'define' a 'nodefine' afin de */ \
/* ne pas etre recupere par le processus 'v $xcc/cpp$Z _VERSION_'. */
#define fARRI_VERSION_02(x,epsilon) \
fMULD_VERSION_02(x,epsilon) \
/* Arrondi du nombre 'x' a la plus proche valeur multiple de 'epsilon' (deuxieme version). */
#nodefine fARRI_VERSION_03(x,epsilon) \
fMULD_VERSION_02(x,epsilon) \
/* Arrondi du nombre 'x' a la plus proche valeur multiple de 'epsilon' (troisieme version). */ \
/* */ \
/* Le 20030222102112, 'fARRI_VERSION_03(...)' est passe de 'define' a 'nodefine' afin de */ \
/* ne pas etre recupere par le processus 'v $xcc/cpp$Z _VERSION_'. */
#define fARRI(x,epsilon) \
fARRI_VERSION_02(x,epsilon) \
/* Arrondi du nombre 'x' a la plus proche valeur multiple de 'epsilon' (version "active"). */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* O P E R A T I O N S A R I T H M E T I Q U E S D ' I N V E R S I O N S D I V E R S E S : */
/* */
/*************************************************************************************************************************************/
/* ATTENTION : depuis qu'a ete introduite la '$PASSE_D', il est imperatif que certaines */
/* definitions soient faites avant d'autres ; en particulier 'SOUS(...)' et 'DIVI(...)' */
/* doivent etre definies avant tout '-define ...' qui les utilisent... */
-define NEGA(x) \
-_-_-_- bSOU(ZERO,x)
/* Inversion du signe du nombre 'x'. */
/* */
/* Le 20101119173715, 'bSOU(...)' plus logique a remplace 'SOUS(...)'. */
#define COMP(x) \
SOUS(UN,x) \
/* Complementation a un du nombre 'x'. */ \
/* */ \
/* On notera que par symetrie avec 'INVE(...)' qui utilise 'DIVI(...)' (et non pas */ \
/* 'bDIV(...)'), 'COMP(...)' utilise 'SOUS(...)' (et non pas 'bSOU(...)'). */
#define gCOMP(x,a,b) \
SOUS(x,DOUB(SOUS(x,MOYE(a,b)))) \
/* Complementation generalisee du nombre 'x' dans le segment [a,b], ce qui revient a faire */ \
/* une symetrie de 'x' par rapport au milieu de [a,b]. On notera que l'on pourrait */ \
/* simplifier l'ecriture precedente en : */ \
/* */ \
/* #define gCOMP(x,a,b) \ */ \
/* SOUS(ADD2(a,b),x) */ \
/* */ \
/* mais il s'agit, encore une fois, de privilegier la comprehension (en fait ces deux */ \
/* possibilites ont ete permutees le 20071024164122...). */
#define aCOMP(x) \
NEGA(COMP(x)) \
/* Anti-complementation du nombre 'x' (introduit le 20240328154623)... */ \
/* */ \
/* ATTENTION : on notera l'enorme difference avec 'TRMU(...)' qui reference 'INDX(...)' */ \
/* qui lui-meme utilise 'INTE(...)'. Et ainsi, 'TRMU(...)' prend la partie entiere si */ \
/* l'argument est flottant... */
#define SYME(x,a,b) \
COND(IFLE(x,MOYE(a,b)),x,gCOMP(x,a,b)) \
/* Symetrisation de 'x' par rapport au milieu de [a,b] : */ \
/* */ \
/* */ \
/* SYME(x,a,b) ^ */ \
/* | */ \
/* | */ \
/* b +. . . . */ \
/* | .. . */ \
/* | . . . */ \
/* | . . . */ \
/* | . . . */ \
/* | . . . */ \
/* | . . . */ \
/* | . . . */ \
/* | . . . */ \
/* | . ^ */ \
/* | . /.\ */ \
/* | . y=+x / . \ y=-x+(a+b) */ \
/* | . / . \ */ \
/* | . / . \ */ \
/* | . / . \ */ \
/* | . / . \ */ \
/* | . / . \ */ \
/* | ./ . \ */ \
/* a +. . *. . . . . . . . .* */ \
/* | .. . .. */ \
/* | . . . . . */ \
/* | . . . . . */ \
/* |. . . . . */ \
/* ------------------------------O----+--------+--------+---------------> */ \
/* | a a+b b x */ \
/* ----- */ \
/* 2 */ \
/* */ \
/* Ceci fut introduit le 20071024161235 pour 'v $xiii/mono_image$FON Fpolynome_polaire'... */
-define INVE(x) \
-_-_-_- DIVI(FU,x)
/* Inversion par rapport a un du nombre 'x', mais ATTENTION : 'FU' et non pas 'UN'... */
-define INVZ(x) \
-_-_-_- DIVZ(UN,x)
/* Inversion par rapport a un du nombre 'x' avec test de division par zero... */
-define fINVZ(x) \
-_-_-_- fDIVZ(FU,x)
/* Inversion par rapport a un du nombre 'x' avec test de division par zero. Ceci fut */
/* introduit le 20070727103657 par symetrie (tardive...) avec 'fDIVZ(...)'... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* O P E R A T I O N S A R I T H M E T I Q U E S D ' E X T R A C T I O N D ' E X T R E M A : */
/* */
/*************************************************************************************************************************************/
#define MIN1(a) \
NEUT(a) \
/* Par symetrie avec 'MIN2(...)', 'MIN3(...)',... */
#define gMIN2(a1,b1,a2,b2) \
COND(IFLT(a1,b1),a2,b2) \
/* Recherche generale du minimum des deux nombres 'a' et 'b' (introduit le 20091204130256). */
#define MIN2(a,b) \
COND(IFLT(a,b),a,b) \
/* Recherche du minimum des deux nombres {a,b}. */ \
/* ATTENTION : on notera dans '$xig/fonct$vv$FON' l'introduction, pour des questions de */ \
/* performance a la compilation, des fonctions 'iMIN2(...)' et 'fMIN2(...)'. */
#define MIN3(a,b,c) \
MIN2(MIN2(a,b),c) \
/* Recherche du minimum des trois nombres {a,b,c}. */ \
/* ATTENTION : on notera dans '$xig/fonct$vv$FON' l'introduction, pour des questions de */ \
/* performance a la compilation, des fonctions 'iMIN3(...)' et 'fMIN3(...)'. */
#define MIN4(a,b,c,d) \
MIN2(MIN3(a,b,c),d) \
/* Recherche du minimum des quatre nombres {a,b,c,d}. */ \
/* ATTENTION : on notera dans '$xig/fonct$vv$FON' l'introduction, pour des questions de */ \
/* performance a la compilation, des fonctions 'iMIN4(...)' et 'fMIN4(...)'. */
#define MIN5(a,b,c,d,e) \
MIN2(MIN4(a,b,c,d),e) \
/* Recherche du minimum des cinq nombres {a,b,c,d,e}. */ \
/* ATTENTION : on notera dans '$xig/fonct$vv$FON' l'introduction, pour des questions de */ \
/* performance a la compilation, des fonctions 'iMIN5(...)' et 'fMIN5(...)'. Ceci fut */ \
/* introduit le 20111118180131... */
#define MIN6(a,b,c,d,e,f) \
MIN2(MIN5(a,b,c,d,e),f) \
/* Recherche du minimum des six nombres {a,b,c,d,e,f}. */ \
/* ATTENTION : on notera dans '$xig/fonct$vv$FON' l'introduction, pour des questions de */ \
/* performance a la compilation, des fonctions 'iMIN6(...)' et 'fMIN6(...)'. Ceci fut */ \
/* introduit le 20111118180131... */
#define MAX1(a) \
NEUT(a) \
/* Par symetrie avec 'MAX2(...)', 'MAX3(...)',... */
#define gMAX2(a1,b1,a2,b2) \
COND(IFGT(a1,b1),a2,b2) \
/* Recherche generale du maximum des deux nombres 'a' et 'b' (introduit le 20091204130256). */
#define MAX2(a,b) \
COND(IFGT(a,b),a,b) \
/* Recherche du maximum des deux nombres {a,b}. */ \
/* ATTENTION : on notera dans '$xig/fonct$vv$FON' l'introduction, pour des questions de */ \
/* performance a la compilation, des fonctions 'iMAX2(...)' et 'fMAX2(...)'. */
#define MAX3(a,b,c) \
MAX2(MAX2(a,b),c) \
/* Recherche du maximum des trois nombres {a,b,c}. */ \
/* ATTENTION : on notera dans '$xig/fonct$vv$FON' l'introduction, pour des questions de */ \
/* performance a la compilation, des fonctions 'iMAX3(...)' et 'fMAX3(...)'. */
#define MAX4(a,b,c,d) \
MAX2(MAX3(a,b,c),d) \
/* Recherche du maximum des quatre nombres {a,b,c,d}. */ \
/* ATTENTION : on notera dans '$xig/fonct$vv$FON' l'introduction, pour des questions de */ \
/* performance a la compilation, des fonctions 'iMAX4(...)' et 'fMAX4(...)'. */
#define MAX5(a,b,c,d,e) \
MAX2(MAX4(a,b,c,d),e) \
/* Recherche du maximum des cinq nombres {a,b,c,d,e}. */ \
/* ATTENTION : on notera dans '$xig/fonct$vv$FON' l'introduction, pour des questions de */ \
/* performance a la compilation, des fonctions 'iMAX5(...)' et 'fMAX5(...)'. Ceci fut */ \
/* introduit le 20111118180131... */
#define MAX6(a,b,c,d,e,f) \
MAX2(MAX5(a,b,c,d,e),f) \
/* Recherche du maximum des six nombres {a,b,c,d,e,f}. */ \
/* ATTENTION : on notera dans '$xig/fonct$vv$FON' l'introduction, pour des questions de */ \
/* performance a la compilation, des fonctions 'iMAX6(...)' et 'fMAX6(...)'. Ceci fut */ \
/* introduit le 20111118180131... */
#define MINA2(a,b) \
gMIN2(ABSO(a),ABSO(b),a,b) \
/* Recherche du minimum des deux nombres 'a' et 'b', mais en testant les valeurs absolues */ \
/* des deux nombres (introduit le 20091204125114 pour 'v $xiii/di_album$FON MINA2'). */
#define MAXA2(a,b) \
gMAX2(ABSO(a),ABSO(b),a,b) \
/* Recherche du maximum des deux nombres 'a' et 'b', mais en testant les valeurs absolues */ \
/* des deux nombres (introduit le 20091204125114 pour 'v $xiii/di_album$FON MAXA2'). */
#define MINMAX(x,y) \
MAX2(MIN2(x,COMP(y)),MIN2(COMP(x),y)) \
/* En quelque sorte, le 'ou exclusif' de la logique floue (introduit le 20000724102041 lors */ \
/* de l'introduction de 'v $xrv/MINMAX.11$K'). */
#define gMINMAX(x,y,a,b) \
MAX2(MIN2(x,gCOMP(y,a,b)),MIN2(gCOMP(x,a,b),y)) \
/* Generalisation dans [a,b] de 'MINMAX(x,y)' (ce dernier etant dans [0,1]). */
#define MAXMIN(x,y) \
MIN2(MAX2(x,COMP(y)),MAX2(COMP(x),y)) \
/* Introduit le 20061023091349 par "symetrie" avec 'MINMAX(...)'... */
#define gMAXMIN(x,y,a,b) \
MIN2(MAX2(x,gCOMP(y,a,b)),MAX2(gCOMP(x,a,b),y)) \
/* Generalisation dans [a,b] de 'MAXMIN(x,y)' (ce dernier etant dans [0,1]) (introduit le */ \
/* 20061023091349). */
#define IMINMAX(x,y) \
MAX2(MIN2(x,INVZ(y)),MIN2(INVZ(x),y)) \
/* Par symetrie avec 'MINMAX(...)' en passant de l'addition a la multiplication (introduit */ \
/* le 20080102130008) et dite "Inverse" de 'MINMAX(...)' (par abus de langage...). */
#define IMAXMIN(x,y) \
MIN2(MAX2(x,INVZ(y)),MAX2(INVZ(x),y)) \
/* Par symetrie avec 'MAXMIN(...)' en passant de l'addition a la multiplication (introduit */ \
/* le 20080102130008) et dite "Inverse" de 'MAXMIN(...)' (par abus de langage...). */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* O P E R A T I O N S A R I T H M E T I Q U E S D I V E R S E S : */
/* */
/*************************************************************************************************************************************/
-define DIVn(x,n) \
-_-_-_- DIVI(x,n)
/* Division du nombre 'x' par le nombre 'n' (suppose entier...). ATTENTION, le passage par */
/* la definition intermediaire 'DIVn(...)' en '$PASSE_1' est liee au fait que la definition */
/* 'FRAn(...)' est conditionnelle alors qu'elle appartient a '$PASSE_D'. */
/* */
/* Le 20050821155430, la definition precedente est passee de '$PASSE_1' a '$PASSE_D' ' */
/* a cause de 'v $xrs/Mobius2D.11$I MOIT'... */
#if ( (defined(BUG_SYSTEME_SGIND_C_divisions_entieres)) \
)
# undef DIVn
# define DIVn(x,n) \
bMUL(bMUL(SIGN(x),SIGN(n)) \
,DIVI(ABSO(x),ABSO(n)) \
) \
/* Division du nombre 'x' par le nombre 'n' (suppose entier...). ATTENTION, le passage par */ \
/* la definition intermediaire 'DIVn(...)' en '$PASSE_1' est liee au fait que la definition */ \
/* 'FRAn(...)' est conditionnelle alors qu'elle appartient a '$PASSE_D'. */ \
/* */ \
/* ATTENTION, pendant quelque temps, il y a eu : */ \
/* */ \
/* # define DIVn(x,n) \ */ \
/* DIVI(x,FLOT(n)) */ \
/* */ \
/* mais cette solution a un inconvenient majeur ; en effet, si la primitive 'DIVn(...)' */ \
/* apparait dans la definition d'une constante entiere, elle-meme utilisee comme argument */ \
/* entier lors de l'appel d'une fonction, cet argument entier prend le type 'Float' a */ \
/* cause du 'FLOT(...)' de la definition de 'DIVn(...)'. A l'entree de la fonction, */ \
/* l'argument entier correspondant a donc une valeur enorme et fausse... Ce cas s'est */ \
/* en particulier rencontre avec les definitions 'MOITIE_DU_NOMBRE_DE_POINTS_DE_LA_FONCTION' */ \
/* et 'MOITIE_DU_NOMBRE_DE_POINTS_DE_LA_TRANSFORMEE' de 'v $ximt/fourier$FON'. La nouvelle */ \
/* solution consiste donc a ajouter a 'n' une variable entiere toujours nulle ; le type */ \
/* entier de cette derniere permet d'utiliser 'DIVn(...)' avec des arguments de tout type */ \
/* ('Int' et/ou 'Float'). */ \
/* */ \
/* Puis j'ai tente : */ \
/* */ \
/* # define DIVn(x,n) \ */ \
/* DIVI(x,ADD2(n,pour_faire_correctement_...)) */ \
/* */ \
/* ou 'pour_faire_correctement_...' etait un 'Int' implantee dans '$xig/common$STR'. Cela */ \
/* ne pouvait pas fonctionner car, en effet, certaines constantes calculees a l'aide de */ \
/* 'DIVn(...)' servent a initialiser des variables globales (par exemple 'Zmin' dans */ \
/* '$xiii/Images$STR'), or on ne peut utiliser pour cela que des constantes "pures" et */ \
/* donc initialisables des le chargement du programme, ce qui n'est pas possible ici... */ \
/* */ \
/* On notera actuellement l'ecriture : */ \
/* */ \
/* # define DIVn(x,n) \ */ \
/* MUL2(MUL2(SIGN(x),SIGN(n)),DIVI(ABSO(x),ABSO(n))) */ \
/* */ \
/* et non pas : */ \
/* */ \
/* # define DIVn(x,n) \ */ \
/* MEME_SIGNE_QUE(MUL2(x,n),DIVI(ABSO(x),ABSO(n))) */ \
/* */ \
/* afin d'alleger le travail du compilateur... */ \
/* */ \
/* Le 20101120091431, 'bMUL(...)' a remplace 'MUL2(...)'. */
#Aif ( (defined(BUG_SYSTEME_SGIND_C_divisions_entieres)) \
)
#Eif ( (defined(BUG_SYSTEME_SGIND_C_divisions_entieres)) \
)
-define FRAn(x,n) \
-_-_-_- DIVn(x,n)
/* Division du nombre 'x' par le nombre 'n' (suppose entier...). ATTENTION, le passage par */
/* la definition intermediaire 'DIVn(...)' en '$PASSE_1' est liee au fait que la definition */
/* 'FRAn(...)' est conditionnelle alors qu'elle appartient a '$PASSE_D'. */
-define fFRAn(x,n) \
-_-_-_- DIVI(x,FLOT(n))
/* Division du nombre 'x' par le nombre 'n' (suppose flottant). */
#define MOYG(a,b) \
RACX(MUL2(a,b)) \
/* Moyenne Geometrique des deux nombres 'a' et 'b'. Elle est definie par : */ \
/* */ \
/* a x */ \
/* --- = --- */ \
/* x b */ \
/* */ \
/* soit : */ \
/* */ \
/* 2 */ \
/* x = a.b */ \
/* */ \
/* avec donc un probleme si le produit 'a.b' est negatif, d'ou 'MOYZ(...)' ci-apres... */
#define MOYZ(a,b) \
MOYG(ABSO(a),ABSO(b)) \
/* Moyenne geometrique des deux nombres 'a' et 'b' en tenant compte des signes respectifs. */ \
/* */ \
/* Jusqu'au 20061023132307, la definition precedente etait : */ \
/* */ \
/* #define MOYZ(a,b) \ */ \
/* COND(IZGE(MUL2(a,b)),MOYG(a,b),FZERO) */ \
/* */ \
/* Mais, pour des raisons de "continuite", il est preferable de systematiquement renvoyer */ \
/* quelque chose (plutot que 'FZERO'), d'ou les 'ABSO(...)'s... */
#define MOYZSI(a,b) \
MEME_SIGNE_QUE(bMUL(a,b),MOYZ(a,b)) \
/* Moyenne geometrique "signee" des deux nombres 'a' et 'b' en tenant compte des signes */ \
/* respectifs. Meme si cela a peu de sens mathematiquement parlant, cela fut introduit le */ \
/* 20061025131829... */ \
/* */ \
/* Le 20101120092003, 'bMUL(...)' a remplace 'MUL2(...)'. */
#define MOYH(a,b) \
DIVZ(DOUB(MUL2(a,b)),ADD2(a,b)) \
/* Moyenne Harmonique des deux nombres 'a' et 'b'. Elle est definie par : */ \
/* */ \
/* a x - a */ \
/* --- = ------- */ \
/* b b - x */ \
/* */ \
/* soit : */ \
/* */ \
/* 2.a.b */ \
/* x = ------- */ \
/* a + b */ \
/* */ \
/* ou encore : */ \
/* */ \
/* 2 */ \
/* x = ----------- */ \
/* 1 1 */ \
/* --- + --- */ \
/* a b */ \
/* */ \
/* */ \
/* ou encore (ce qui est l'inverse de la moyenne des inverses...) : */ \
/* */ \
/* 1 */ \
/* x = ------------- */ \
/* 1 1 */ \
/* --- + --- */ \
/* a b */ \
/* ----------- */ \
/* 2 */ \
/* */ \
/* ce qui (je le note le 20090401100200) permet de calculer la vitesse moyenne V (=x) de */ \
/* deux trajets successifs dont les vitesses moyennes respectives V1 (=a) et V2 (=b) sont */ \
/* connues... */ \
/* */ \
/* */ \
/* Le 20180823094512, 'DIVI(...)' a ete remplace par 'DIVZ(...)' qui est plus logique */ \
/* suite a l'introduction de 'v $xig/fonct$vv$DEF ponderation_de_MOYH'... */
#define MOYQ(a,b) \
RACX(MOYE(EXP2(a),EXP2(b))) \
/* Moyenne Quadratique des deux nombres 'a' et 'b'. Elle est definie par : */ \
/* */ \
/* 2 2 */ \
/* 2 a + b */ \
/* x = --------- */ \
/* 2 */ \
/* */
#define MOYQSI(a,b) \
MEME_SIGNE_QUE(bMUL(a,b),MOYQ(a,b)) \
/* Moyenne Quadratique "signee" des deux nombres 'a' et 'b' en tenant compte des signes */ \
/* respectifs. Meme si cela a peu de sens mathematiquement parlant, cela fut introduit le */ \
/* 20061025131829... */ \
/* */ \
/* Le 20101120092003, 'bMUL(...)' a remplace 'MUL2(...)'. */
#define MOYE(a,b) \
FRAn(ADD2(a,b),CONSTANTE_DE_MOYENNE) \
/* Moyenne arithmetique des deux nombres 'a' et 'b'. On notera que 'MOYE(a,b)' n'est pas */ \
/* definie par : */ \
/* */ \
/* FRA2(ADD2(a,b)) */ \
/* */ \
/* pour des raisons de symetrie avec 'MOYD(a,b)' et 'MOYX(a,b)'. Elle est definie par : */ \
/* */ \
/* x-a = b-x */ \
/* */ \
/* soit : */ \
/* */ \
/* a + b */ \
/* x = ------- */ \
/* 2 */ \
/* */
#define MOYS(a,b) \
FRAn(SOUS(a,b),CONSTANTE_DE_MOYENNE) \
/* Sorte d'anti-moyenne "soustractive" de deux nombres 'a' et 'b' (cela fut introduit le */ \
/* 20230123112942...), soit : */ \
/* */ \
/* a - b */ \
/* x = ------- */ \
/* 2 */ \
/* */
#define AMOY(m,a) \
AXPB(CONSTANTE_DE_MOYENNE,m,NEGA(a)) \
/* Anti-MOYenne arithmetique donnant 'b' connaissant 'm' (la moyenne) et 'a' : */ \
/* */ \
/* a + b */ \
/* m = ------- */ \
/* 2 */ \
/* */ \
/* d'ou : */ \
/* */ \
/* b=2.m-a */ \
/* */ \
/* Ceci fut introduit le 20160726092210 (pour 'v $xrv/ReflexionTriangle.01$K AMOY' et */ \
/* pour 'v $xrv/ReflexionTetraedre.01$K AMOY'). */
#define NOYE(a,b) \
FRAn(SOUS(a,b),CONSTANTE_DE_MOYENNE) \
/* Moyenne arithmetique "Negative" des deux nombres 'a' et 'b'. Ceci fut introduit le */ \
/* 20071012102307 pour pouvoir eventuellement formuler de facon symetrique le probleme */ \
/* suivant lie a l'ondelette de Haar. Soient deux nombres {a,b} ; leur Somme et leur */ \
/* Difference sont : */ \
/* */ \
/* S = a + b */ \
/* D = a - b */ \
/* */ \
/* A partir de {S,D}, il est possible de reconstituer {a,b} suivant : */ \
/* */ \
/* S + D */ \
/* a = ------- = MOYE(S,D) */ \
/* 2 */ \
/* */ \
/* S - D */ \
/* b = ------- = NOYE(S,D) */ \
/* 2 */ \
/* */ \
/* d'ou la necessite de 'NOYE(...)' a cote de 'MOYE(...)'. */ \
/* */ \
/* Au passage, on notera que l'ondelette de Haar consiste, pour un vecteur de N nombres */ \
/* {A(j)}, a memoriser les N/2 differences [A(2i+1)-A(2i)] et a generer un nouveau vecteur */ \
/* contenant les N/2 sommes {[A(2i+1)+A(2i)]} (en supposant evidemment que le cardinal N */ \
/* du vecteur initial est une puissance de 2 et que l'indexation se fait a partir de 0), */ \
/* puis en iterant recursivement ce processus sur ce vecteur des N/2 sommes... */
#define MOYD(a,b) \
QUOD(ADD2(a,b),CONSTANTE_DE_MOYENNE) \
/* Moyenne arithmetique par Defaut des deux nombres {a,b}. */
#define MOYX(a,b) \
QUOE(ADD2(a,b),CONSTANTE_DE_MOYENNE) \
/* Moyenne arithmetique par eXces des deux nombres {a,b}. */
#define MOY3(a,b,c) \
FRA3(ADD3(a,b,c)) \
/* Moyenne arithmetique des trois nombres {a,b,c}. */
#define MOY4(a,b,c,d) \
FRA4(ADD4(a,b,c,d)) \
/* Moyenne arithmetique des quatre nombres {a,b,c,d}. */
#define MOY5(a,b,c,d,e) \
FRA5(ADD5(a,b,c,d,e)) \
/* Moyenne arithmetique des cinq nombres {a,b,c,d,e}. */
#define MOY6(a,b,c,d,e,f) \
FRA6(ADD6(a,b,c,d,e,f)) \
/* Moyenne arithmetique des six nombres {a,b,c,d,e,f}. */
#define MOY7(a,b,c,d,e,f,g) \
FRA7(ADD7(a,b,c,d,e,f,g)) \
/* Moyenne arithmetique des sept nombres {a,b,c,d,e,f,g}. */
#define MOY8(a,b,c,d,e,f,g,h) \
FRA8(ADD8(a,b,c,d,e,f,g,h)) \
/* Moyenne arithmetique des huit nombres {a,b,c,d,e,f,g,h}. */
#define SOYE(a,b) \
FRAn(SOUS(a,b),CONSTANTE_DE_MOYENNE) \
/* "Symetrique" de 'MOYE(a,b)' utilisant la soustraction (introduit le 20030324111828 */ \
/* pour 'v $ximt/ondelettes$FON 20030324115446'). */
#define INTM(a,b) \
MOYE(a,b) \
/* Interpolation "Mediane" entre deux nombres 'a' et 'b'. */
#define EXTG(a,b) \
SOUS(DOUB(a),b) \
/* Extrapolation a "Gauche" de {a,b} dans cet ordre. */
#define EXTD(a,b) \
SOUS(DOUB(b),a) \
/* Extrapolation a "Droite" de {a,b} dans cet ordre. */
#define PAR0(x) \
ETLO(x,COMK(BIT)) \
/* Plus proche nombre pair (0) par defaut du nombre 'x'. */
#define PAR1(x) \
OUIN(x,BIT) \
/* Plus proche nombre impair (1) par exces du nombre 'x'. */
#define MEME_PARITE(a,b) \
IFEQ(REST(a,DEUX),REST(b,DEUX)) \
/* Indique si les deux nombres 'a' et 'b' ont la meme parite... */
#define CHOI(x,y) \
SE12(x,y) \
/* Selectionne l'un des deux nombres 'x' ou 'y' ; en fait, cette macro est */ \
/* introduite pour ne pas privilegier l'un des deux en apparence. En general */ \
/* elle est appelee alors que les deux elements 'x' et 'y' sont egaux. */
#define CHOY(x,y,z) \
SE13(x,y,z) \
/* Selectionne l'un des trois nombres 'x' ou 'y' ou 'z' ; en fait, cette macro est */ \
/* introduite pour ne pas privilegier l'un des trois en apparence. En general */ \
/* elle est appelee alors que les trois elements 'x', 'y' et 'z' sont egaux. */
#define CHOZ(x,y,z,t) \
SE14(x,y,z,t) \
/* Selectionne l'un des quatre nombres 'x' ou 'y' ou 'z' ou 't' ; en fait, cette macro est */ \
/* introduite pour ne pas privilegier l'un des quatre en apparence. En general */ \
/* elle est appelee alors que les quatre elements 'x', 'y', 'z' et 't' sont egaux. */ \
/* Cette definition a ete introduite pour 'v $xrv/PointsVoisins_3D.01$K CHOZ' le */ \
/* 20150810101052... */
#define FRACTION(nombre_rationnel,denominateur) \
INTE(bMUL(nombre_rationnel,denominateur)) \
/* Conversion d'un nombre flottant suppose rationnel en une fraction (de nombres entiers...) */ \
/* dont on se fixe a priori le denominateur... */ \
/* */ \
/* Le 20101120092003, 'bMUL(...)' a remplace 'MUL2(...)'. */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* F O R M E S L I N E A I R E S : */
/* */
/*************************************************************************************************************************************/
-define DIS2(x,a,b) \
-_-_-_- MUL2(x,ADD2(a,b))
/* Distributivite de la multiplication sur l'addition a 2 termes. */
/* */
/* ATTENTION : On consultera avec profit les commentaires de 'v $xil/re_definit$DEF', la */
/* definition de 'DIS2(x,a,b)' pouvant, par exemple, se reformuler : */
/* */
/* #redefine DIS2(x,a,b) \ */
/* ADD2(MUL2(x,a) \ */
/* ,MUL2(x,b) \ */
/* ) */
/* */
-define DIS3(x,a,b,c) \
-_-_-_- MUL2(x,ADD3(a,b,c))
/* Distributivite de la multiplication sur l'addition a 3 termes. */
/* */
/* ATTENTION : On consultera avec profit les commentaires de 'v $xil/re_definit$DEF', la */
/* definition de 'DIS3(x,a,b,c)' pouvant, par exemple, se reformuler : */
/* */
/* #redefine DIS3(x,a,b,c) \ */
/* ADD3(MUL2(x,a) \ */
/* ,MUL2(x,b) \ */
/* ,MUL2(x,c) \ */
/* ) */
/* */
-define DIS4(x,a,b,c,d) \
-_-_-_- MUL2(x,ADD4(a,b,c,d))
/* Distributivite de la multiplication sur l'addition a 4 termes. */
/* */
/* ATTENTION : On consultera avec profit les commentaires de 'v $xil/re_definit$DEF', la */
/* definition de 'DIS4(x,a,b,c,d)' pouvant, par exemple, se reformuler : */
/* */
/* #redefine DIS4(x,a,b,c,d) \ */
/* ADD4(MUL2(x,a) \ */
/* ,MUL2(x,b) \ */
/* ,MUL2(x,c) \ */
/* ,MUL2(x,d) \ */
/* ) */
/* */
-define DIS5(x,a,b,c,d,e) \
-_-_-_- MUL2(x,ADD5(a,b,c,d,e))
/* Distributivite de la multiplication sur l'addition a 5 termes. */
/* */
/* ATTENTION : On consultera avec profit les commentaires de 'v $xil/re_definit$DEF', la */
/* definition de 'DIS5(x,a,b,c,d,e)' pouvant, par exemple, se reformuler : */
/* */
/* #redefine DIS5(x,a,b,c,d,e) \ */
/* ADD5(MUL2(x,a) \ */
/* ,MUL2(x,b) \ */
/* ,MUL2(x,c) \ */
/* ,MUL2(x,d) \ */
/* ,MUL2(x,e) \ */
/* ) */
/* */
-define DIT2(x,a,b,c,d) \
-_-_-_- MUL3(x,ADD2(a,b),ADD2(c,d))
/* Generalisation de 'DIS2(...)' destinee a 'BAR4(...)' introduite le 20060207101914. En */
/* apres la nouvelle definition de 'BAR4(...)' le 20060207121926, 'DIT2(...)' est devenue */
/* inutile, mais je la garde car on ne sait jamais... */
-define AXPB(a,x,b) \
-_-_-_- ADD2(MUL2(a,x),b)
/* Calcul de la formule : */
/* */
/* a.x + b */
/* */
-define XPBA(a,x,b) \
-_-_-_- MUL2(ADD2(x,b),a)
/* Calcul de la formule : */
/* */
/* a.(x + b) */
/* */
/* On notera le 20070910144615 que j'ai essaye : */
/* */
/* -define GenereOperateur_____LINn(LINn,LINn_1,Liste_n_1,Liste_n) \ */
/* -define LINn(Liste_n_1,Liste_n,b) \ */
/* -_-_-_- LINn_1(Liste_n_1,LIN1(Liste_n,b)) */
/* */
/* -_-_-_- GenereOperateur_____LINn(LIN2,LIN1,a0/-/x0,a1/-/x1) */
/* -_-_-_- GenereOperateur_____LINn(LIN3,LIN2,a0/-/x0/-/a1/-/x1,a2/-/x2) */
/* (...) */
/* */
/* sur le modele de 'v $ximd/operator.1$FON GenereOperateur_____HORNER_NN'. Malheureusement, */
/* c'est ici beaucoup trop complique au niveau de 'v $xcc/cpp$Z 20070910144831' a cause du */
/* 'GooF' et de la derivation formelle... */
/* */
/* Le 20070911100016, j'ai essaye : */
/* */
/* -_-_-_- define(Nom_____LINn,LIN) */
/* -_-_-_- define(GenereOperateur_____LINn, */
/* -_-_-_- `-define Nom_____LINn`'`'$1($3,$4,b) \ */
/* -_-_-_- Nom_____LINn`'`'$2($3 \ */
/* -_-_-_- ,Nom_____LINn`'`'1($4,b) \ */
/* -_-_-_- )' */
/* -_-_-_- ) */
/* */
/* -_-_-_- GenereOperateur_____LINn(2,1,`a0,x0',`a1,x1') */
/* -_-_-_- GenereOperateur_____LINn(3,2,`a0,x0,a1,x1',`a2,x2') */
/* -_-_-_- GenereOperateur_____LINn(4,3,`a0,x0,a1,x1,a2,x2',`a3,x3') */
/* (...) */
/* */
/* qui est interprete par des sequences : */
/* */
/* | $M4 $Parametres_M4 $xccp/GarOrdre$vv$m4 - */
/* | $SE -e "s/^ *\($PASSE_D\)/\1/" */
/* -e 's/^ *$//' */
/* */
/* bien placees dans 'v $xcc/cpp$Z', par exemple en fin de la "PASSE D1". Mais, */
/* malheureusement, cela cree de graves problemes a cause des arguments {$1,$2,$3,$4} */
/* de 'GenereOperateur_____LINn(...)' car, en effet, les "$"s sont transformes en "_" a */
/* cause de 'v $xcc/cpp$Z .xcp.underscore.X'... */
_____define(GenOperator_PASSE_D_____LINn,++D++-define $1($3,$4,b) \
-_-_-_- $2($3,LIN1($4,b))++F++
)
/* Generateur des 'LIN?(....)'s introduit le 20070912125718... */
/* */
/* Definition des arguments de 'GenOperator.PASSE.D.....LINn(...)' (on notera la presence */
/* des "."s au lieu des "_"s dans les commentaires relatifs a cet operateur : cela est */
/* destine a bloquer l'action de '$m4' dans ces commentaires...) : */
/* */
/* $1 : nom de l'operateur 'LIN?' a definir (de rang 'n'), */
/* $2 : nom de l'operateur 'LIN?' a utiliser (de rang 'n-1'), */
/* $3 : premiere liste d'arguments (nombre variables d'elements), */
/* $4 : deuxieme liste d'arguments (toujours deux elements). */
/* */
/* ATTENTION : l'absence de "," en bout de ligne (derriere 'GenOperator.PASSE.D.....LINn') */
/* donne a priori a 'GenOperator.PASSE.D.....LINn' une valeur vide. Or cela fait partie de */
/* mon modele de programmation. La modification 'v $xcc/cpp$Z 20070912133816' est destinee */
/* justement a deplacer la "," de debut de ligne pour la mettre a la fin de la ligne */
/* precedente et ainsi donner a 'GenOperator.PASSE.D.....LINn' la bonne definition... */
/* */
/* Le 20070913153802 le nom 'GenOperator_____LINn(...)' fut change en */
/* 'GenOperator_P_D_____LINn(...)' afin de contenir la passe '$PASSE_D' de generation, */
/* ce qui est utile dans 'v $xi/DICO$D/GenOperator$vv$sub GenOperator_P_._____'. */
/* */
/* Le 20071003152838 le nom 'GenOperator_P_D_____LINn(...)' a ete change en */
/* 'GenOperator.PASSE.D.....LINn(...)' pour une meilleure lisibilite... */
-define LIN1(a0,x0,b) \
-_-_-_- AXPB(a0,x0,b)
GenOperator_PASSE_D_____LINn(LIN2 ,LIN1 ,++D++a0,x0++F++,++D++a1,x1++F++)
GenOperator_PASSE_D_____LINn(LIN3 ,LIN2 ,++D++a0,x0,a1,x1++F++,++D++a2,x2++F++)
GenOperator_PASSE_D_____LINn(LIN4 ,LIN3 ,++D++a0,x0,a1,x1,a2,x2++F++,++D++a3,x3++F++)
GenOperator_PASSE_D_____LINn(LIN5 ,LIN4 ,++D++a0,x0,a1,x1,a2,x2,a3,x3++F++,++D++a4,x4++F++)
GenOperator_PASSE_D_____LINn(LIN6 ,LIN5 ,++D++a0,x0,a1,x1,a2,x2,a3,x3,a4,x4++F++,++D++a5,x5++F++)
GenOperator_PASSE_D_____LINn(LIN7 ,LIN6 ,++D++a0,x0,a1,x1,a2,x2,a3,x3,a4,x4,a5,x5++F++,++D++a6,x6++F++)
GenOperator_PASSE_D_____LINn(LIN8 ,LIN7 ,++D++a0,x0,a1,x1,a2,x2,a3,x3,a4,x4,a5,x5,a6,x6++F++,++D++a7,x7++F++)
GenOperator_PASSE_D_____LINn(LIN9 ,LIN8 ,++D++a0,x0,a1,x1,a2,x2,a3,x3,a4,x4,a5,x5,a6,x6,a7,x7++F++,++D++a8,x8++F++)
GenOperator_PASSE_D_____LINn(LIN10,LIN9 ,++D++a0,x0,a1,x1,a2,x2,a3,x3,a4,x4,a5,x5,a6,x6,a7,x7,a8,x8++F++,++D++a9,x9++F++)
GenOperator_PASSE_D_____LINn(LIN11,LIN10,++D++a0,x0,a1,x1,a2,x2,a3,x3,a4,x4,a5,x5,a6,x6,a7,x7,a8,x8,a9,x9++F++,++D++aA,xA++F++)
GenOperator_PASSE_D_____LINn(LIN12,LIN11,++D++a0,x0,a1,x1,a2,x2,a3,x3,a4,x4,a5,x5,a6,x6,a7,x7,a8,x8,a9,x9,aA,xA++F++,++D++aB,xB++F++)
GenOperator_PASSE_D_____LINn(LIN13
,LIN12
,++D++
a0,x0,a1,x1,a2,x2,a3,x3,a4,x4,a5,x5,a6,x6,a7,x7,a8,x8,a9,x9
,aA,xA,aB,xB
++F++
,++D++aC,xC++F++
)
GenOperator_PASSE_D_____LINn(LIN14
,LIN13
,++D++
a0,x0,a1,x1,a2,x2,a3,x3,a4,x4,a5,x5,a6,x6,a7,x7,a8,x8,a9,x9
,aA,xA,aB,xB,aC,xC
++F++
,++D++aD,xD++F++
)
GenOperator_PASSE_D_____LINn(LIN15
,LIN14
,++D++
a0,x0,a1,x1,a2,x2,a3,x3,a4,x4,a5,x5,a6,x6,a7,x7,a8,x8,a9,x9
,aA,xA,aB,xB,aC,xC,aD,xD
++F++
,++D++aE,xE++F++
)
GenOperator_PASSE_D_____LINn(LIN16
,LIN15
,++D++
a0,x0,a1,x1,a2,x2,a3,x3,a4,x4,a5,x5,a6,x6,a7,x7,a8,x8,a9,x9
,aA,xA,aB,xB,aC,xC,aD,xD,aE,xE
++F++
,++D++aF,xF++F++
)
GenOperator_PASSE_D_____LINn(LIN17
,LIN16
,++D++
a0,x0,a1,x1,a2,x2,a3,x3,a4,x4,a5,x5,a6,x6,a7,x7,a8,x8,a9,x9
,aA,xA,aB,xB,aC,xC,aD,xD,aE,xE,aF,xF
++F++
,++D++aG,xG++F++
)
GenOperator_PASSE_D_____LINn(LIN18
,LIN17
,++D++
a0,x0,a1,x1,a2,x2,a3,x3,a4,x4,a5,x5,a6,x6,a7,x7,a8,x8,a9,x9
,aA,xA,aB,xB,aC,xC,aD,xD,aE,xE,aF,xF,aG,xG
++F++
,++D++aH,xH++F++
)
GenOperator_PASSE_D_____LINn(LIN19
,LIN18
,++D++
a0,x0,a1,x1,a2,x2,a3,x3,a4,x4,a5,x5,a6,x6,a7,x7,a8,x8,a9,x9
,aA,xA,aB,xB,aC,xC,aD,xD,aE,xE,aF,xF,aG,xG,aH,xH
++F++
,++D++aI,xI++F++
)
GenOperator_PASSE_D_____LINn(LIN20
,LIN19
,++D++
a0,x0,a1,x1,a2,x2,a3,x3,a4,x4,a5,x5,a6,x6,a7,x7,a8,x8,a9,x9
,aA,xA,aB,xB,aC,xC,aD,xD,aE,xE,aF,xF,aG,xG,aH,xH,aI,xI
++F++
,++D++aJ,xJ++F++
)
GenOperator_PASSE_D_____LINn(LIN21
,LIN20
,++D++
a0,x0,a1,x1,a2,x2,a3,x3,a4,x4,a5,x5,a6,x6,a7,x7,a8,x8,a9,x9
,aA,xA,aB,xB,aC,xC,aD,xD,aE,xE,aF,xF,aG,xG,aH,xH,aI,xI,aJ,xJ
++F++
,++D++aK,xK++F++
)
GenOperator_PASSE_D_____LINn(LIN22
,LIN21
,++D++
a0,x0,a1,x1,a2,x2,a3,x3,a4,x4,a5,x5,a6,x6,a7,x7,a8,x8,a9,x9
,aA,xA,aB,xB,aC,xC,aD,xD,aE,xE,aF,xF,aG,xG,aH,xH,aI,xI,aJ,xJ
,aK,xK
++F++
,++D++aL,xL++F++
)
GenOperator_PASSE_D_____LINn(LIN23
,LIN22
,++D++
a0,x0,a1,x1,a2,x2,a3,x3,a4,x4,a5,x5,a6,x6,a7,x7,a8,x8,a9,x9
,aA,xA,aB,xB,aC,xC,aD,xD,aE,xE,aF,xF,aG,xG,aH,xH,aI,xI,aJ,xJ
,aK,xK,aL,xL
++F++
,++D++aM,xM++F++
)
GenOperator_PASSE_D_____LINn(LIN24
,LIN23
,++D++
a0,x0,a1,x1,a2,x2,a3,x3,a4,x4,a5,x5,a6,x6,a7,x7,a8,x8,a9,x9
,aA,xA,aB,xB,aC,xC,aD,xD,aE,xE,aF,xF,aG,xG,aH,xH,aI,xI,aJ,xJ
,aK,xK,aL,xL,aM,xM
++F++
,++D++aN,xN++F++
)
GenOperator_PASSE_D_____LINn(LIN25
,LIN24
,++D++
a0,x0,a1,x1,a2,x2,a3,x3,a4,x4,a5,x5,a6,x6,a7,x7,a8,x8,a9,x9
,aA,xA,aB,xB,aC,xC,aD,xD,aE,xE,aF,xF,aG,xG,aH,xH,aI,xI,aJ,xJ
,aK,xK,aL,xL,aM,xM,aN,xN
++F++
,++D++aO,xO++F++
)
GenOperator_PASSE_D_____LINn(LIN26
,LIN25
,++D++
a0,x0,a1,x1,a2,x2,a3,x3,a4,x4,a5,x5,a6,x6,a7,x7,a8,x8,a9,x9
,aA,xA,aB,xB,aC,xC,aD,xD,aE,xE,aF,xF,aG,xG,aH,xH,aI,xI,aJ,xJ
,aK,xK,aL,xL,aM,xM,aN,xN,aO,xO
++F++
,++D++aP,xP++F++
)
GenOperator_PASSE_D_____LINn(LIN27
,LIN26
,++D++
a0,x0,a1,x1,a2,x2,a3,x3,a4,x4,a5,x5,a6,x6,a7,x7,a8,x8,a9,x9
,aA,xA,aB,xB,aC,xC,aD,xD,aE,xE,aF,xF,aG,xG,aH,xH,aI,xI,aJ,xJ
,aK,xK,aL,xL,aM,xM,aN,xN,aO,xO,aP,xP
++F++
,++D++aQ,xQ++F++
)
/* Calcul des formes lineaires N-dimensionnelles 'LIN?(....)' : */
/* */
/* Sigma(A .X ) + B */
/* i i */
/* */
/* On notera que les calculs sont systematiques contrairement a 'LIO?(....)' ou les calculs */
/* ne sont effectues que pour les 'A(i)' non nuls... */
/* */
/* Le 20080102130008, furent introduites 'LIN14(...)' et 'LIN15(...)'. */
/* */
/* Le 20080104152848, fut introduite 'LIN16(...)'. */
/* */
/* Le 20080325155353, fut introduite 'LIN17(...)'. */
/* */
/* Le 20201004173108, furent introduites 'LIN18(...)' a 'LIN27(...)'. */
_____define(GenOperator_PASSE_D_____LIZn,++D++-define $1($3) \
-_-_-_- $2($3,ZERO)++F++
)
/* Generateur des 'LIZ?(....)'s introduit le 20200323165808 pour simplifier les */
/* 'LIN?(...,[F]ZERO)', d'ou le nom 'LIZ?' pour "Zero"... */
/* */
/* Definition des arguments de 'GenOperator.PASSE.D.....LIZn(...)' (on notera la presence */
/* des "."s au lieu des "_"s dans les commentaires relatifs a cet operateur : cela est */
/* destine a bloquer l'action de '$m4' dans ces commentaires...) : */
/* */
/* $1 : nom de l'operateur 'LIZ?' a definir (de rang 'n'), */
/* $2 : nom de l'operateur 'LIN?' a utiliser (de rang 'n'), */
/* $3 : liste d'arguments. */
/* */
/* ATTENTION : l'absence de "," en bout de ligne (derriere 'GenOperator_PASSE_D.....LIZn') */
/* donne a priori a 'GenOperator_PASSE_D.....LIZn' une valeur vide. Or cela fait partie de */
/* mon modele de programmation. La modification 'v $xcc/cpp$Z 20070912133816' est destinee */
/* justement a deplacer la "," de debut de ligne pour la mettre a la fin de la ligne */
/* precedente et ainsi donner a 'GenOperator.PASSE.D.....LIZn' la bonne definition... */
GenOperator_PASSE_D_____LIZn(LIZ1 ,LIN1 ,++D++a0,x0++F++)
GenOperator_PASSE_D_____LIZn(LIZ2 ,LIN2 ,++D++a0,x0,a1,x1++F++)
GenOperator_PASSE_D_____LIZn(LIZ3 ,LIN3 ,++D++a0,x0,a1,x1,a2,x2++F++)
GenOperator_PASSE_D_____LIZn(LIZ4 ,LIN4 ,++D++a0,x0,a1,x1,a2,x2,a3,x3++F++)
GenOperator_PASSE_D_____LIZn(LIZ5 ,LIN5 ,++D++a0,x0,a1,x1,a2,x2,a3,x3,a4,x4++F++)
GenOperator_PASSE_D_____LIZn(LIZ6 ,LIN6 ,++D++a0,x0,a1,x1,a2,x2,a3,x3,a4,x4,a5,x5++F++)
GenOperator_PASSE_D_____LIZn(LIZ7 ,LIN7 ,++D++a0,x0,a1,x1,a2,x2,a3,x3,a4,x4,a5,x5,a6,x6++F++)
GenOperator_PASSE_D_____LIZn(LIZ8 ,LIN8 ,++D++a0,x0,a1,x1,a2,x2,a3,x3,a4,x4,a5,x5,a6,x6,a7,x7++F++)
GenOperator_PASSE_D_____LIZn(LIZ9 ,LIN9 ,++D++a0,x0,a1,x1,a2,x2,a3,x3,a4,x4,a5,x5,a6,x6,a7,x7,a8,x8++F++)
GenOperator_PASSE_D_____LIZn(LIZ10,LIN10,++D++a0,x0,a1,x1,a2,x2,a3,x3,a4,x4,a5,x5,a6,x6,a7,x7,a8,x8,a9,x9++F++)
GenOperator_PASSE_D_____LIZn(LIZ11,LIN11,++D++a0,x0,a1,x1,a2,x2,a3,x3,a4,x4,a5,x5,a6,x6,a7,x7,a8,x8,a9,x9,aA,xA++F++)
GenOperator_PASSE_D_____LIZn(LIZ12,LIN12,++D++a0,x0,a1,x1,a2,x2,a3,x3,a4,x4,a5,x5,a6,x6,a7,x7,a8,x8,a9,x9,aA,xA,aB,xB++F++)
GenOperator_PASSE_D_____LIZn(LIZ13
,LIN13
,++D++a0,x0,a1,x1,a2,x2,a3,x3,a4,x4,a5,x5,a6,x6,a7,x7,a8,x8,a9,x9,aA,xA,aB,xB,aC,xC++F++
)
GenOperator_PASSE_D_____LIZn(LIZ14
,LIN14
,++D++a0,x0,a1,x1,a2,x2,a3,x3,a4,x4,a5,x5,a6,x6,a7,x7,a8,x8,a9,x9,aA,xA,aB,xB,aC,xC,aD,xD++F++
)
GenOperator_PASSE_D_____LIZn(LIZ15
,LIN15
,++D++a0,x0,a1,x1,a2,x2,a3,x3,a4,x4,a5,x5,a6,x6,a7,x7,a8,x8,a9,x9,aA,xA,aB,xB,aC,xC,aD,xD,aE,xE++F++
)
GenOperator_PASSE_D_____LIZn(LIZ16
,LIN16
,++D++a0,x0,a1,x1,a2,x2,a3,x3,a4,x4,a5,x5,a6,x6,a7,x7,a8,x8,a9,x9,aA,xA,aB,xB,aC,xC,aD,xD,aE,xE,aF,xF++F++
)
/* Calcul des formes lineaires N-dimensionnelles 'LIZ?(....)' : */
/* */
/* Sigma(A .X ) */
/* i i */
/* */
/* Cela fut introduit le 20200323165808 pour simplifier les 'LIN?(...,[F]ZERO)'... */
-define oAXPB(a,x,b) \
-_-_-_- COND(IZNE(a),AXPB(a,x,b),b)
/* Calcul optimise de la formule : */
/* */
/* a.x + b si : x # 0 */
/* b si : x = 0 */
/* */
/* Cela peut etre d'une grande utilite dans le cas ou, par exemple, l'argument 'x' designe */
/* en fait une fonction. Ceci a ete introduit le 20041118134103... */
_____define(GenOperator_PASSE_D_____LIOn,++D++-define $1($3,$4,b) \
-_-_-_- ADD2($2($3,ZERO),LIO1($4,b))++F++
)
/* Generateur des 'LIO?(....)'s introduit le 20070912125718... */
/* */
/* Definition des arguments de 'GenOperator.PASSE.D.....LIOn(...)' (on notera la presence */
/* des "."s au lieu des "_"s dans les commentaires relatifs a cet operateur : cela est */
/* destine a bloquer l'action de '$m4' dans ces commentaires...) : */
/* */
/* $1 : nom de l'operateur 'LIO?' a definir (de rang 'n'), */
/* $2 : nom de l'operateur 'LIO?' a utiliser (de rang 'n-1'), */
/* $3 : premiere liste d'arguments (nombre variables d'elements), */
/* $4 : deuxieme liste d'arguments (toujours deux elements). */
/* */
/* ATTENTION : l'absence de "," en bout de ligne (derriere 'GenOperator.PASSE.D.....LIOn') */
/* donne a priori a 'GenOperator.PASSE.D.....LIOn' une valeur vide. Or cela fait partie de */
/* mon modele de programmation. La modification 'v $xcc/cpp$Z 20070912133816' est destinee */
/* justement a deplacer la "," de debut de ligne pour la mettre a la fin de la ligne */
/* precedente et ainsi donner a 'GenOperator.PASSE.D.....LIOn' la bonne definition... */
/* */
/* Le 20070913153802 le nom 'GenOperator_____LIOn(...)' fut change en */
/* 'GenOperator_P_D_____LIOn(...)' afin de contenir la passe '$PASSE_D' de generation, */
/* ce qui est utile dans 'v $xi/DICO$D/GenOperator$vv$sub GenOperator_P_._____'. */
/* */
/* Le 20071003152838 le nom 'GenOperator_P_D_____LIOn(...)' a ete change en */
/* 'GenOperator.PASSE.D.....LIOn(...)' pour une meilleure lisibilite... */
/* */
/* Jusqu'au 20080111142631, la definition precedente etait plus elegante (parce n'utilisant */
/* que des operateurs 'LIO?(...)'s) et definie par : */
/* */
/* _____define(GenOperator.PASSE.D.....LIOn \ */
/* ,++D++-define $1($3,$4,b) */
/* -_-_-_- $2($3,LIO1($4,b))++F++ */
/* ) */
/* */
/* mais, les formules generees explosaient litteralement (en particulier 'LIO16(...)'). */
/* Cette nouvelle version croit lineairement en complexite). On notera que cette nouvelle */
/* definition utilise la constante 'ZERO' (on ne fait pas d'hypotheses sur les utilisations */
/* des procedures 'LIO?(...)' et donc cela exclut l'usage de 'FZERO'...). */
-define LIO1(a0,x0,b) \
-_-_-_- oAXPB(a0,x0,b)
GenOperator_PASSE_D_____LIOn(LIO2
,LIO1
,++D++a0,x0++F++
,++D++a1,x1++F++
)
GenOperator_PASSE_D_____LIOn(LIO3
,LIO2
,++D++a0,x0,a1,x1++F++
,++D++a2,x2++F++
)
GenOperator_PASSE_D_____LIOn(LIO4
,LIO3
,++D++a0,x0,a1,x1,a2,x2++F++
,++D++a3,x3++F++
)
GenOperator_PASSE_D_____LIOn(LIO5
,LIO4
,++D++a0,x0,a1,x1,a2,x2,a3,x3++F++
,++D++a4,x4++F++
)
GenOperator_PASSE_D_____LIOn(LIO6
,LIO5
,++D++a0,x0,a1,x1,a2,x2,a3,x3,a4,x4++F++
,++D++a5,x5++F++
)
GenOperator_PASSE_D_____LIOn(LIO7
,LIO6
,++D++a0,x0,a1,x1,a2,x2,a3,x3,a4,x4,a5,x5++F++
,++D++a6,x6++F++
)
GenOperator_PASSE_D_____LIOn(LIO8
,LIO7
,++D++a0,x0,a1,x1,a2,x2,a3,x3,a4,x4,a5,x5,a6,x6++F++
,++D++a7,x7++F++
)
GenOperator_PASSE_D_____LIOn(LIO9
,LIO8
,++D++a0,x0,a1,x1,a2,x2,a3,x3,a4,x4,a5,x5,a6,x6,a7,x7++F++
,++D++a8,x8++F++
)
GenOperator_PASSE_D_____LIOn(LIO10
,LIO9
,++D++a0,x0,a1,x1,a2,x2,a3,x3,a4,x4,a5,x5,a6,x6,a7,x7,a8,x8++F++
,++D++a9,x9++F++
)
GenOperator_PASSE_D_____LIOn(LIO11
,LIO10
,++D++
a0,x0,a1,x1,a2,x2,a3,x3,a4,x4,a5,x5,a6,x6,a7,x7,a8,x8,a9,x9
++F++
,++D++aA,xA++F++
)
GenOperator_PASSE_D_____LIOn(LIO12
,LIO11
,++D++
a0,x0,a1,x1,a2,x2,a3,x3,a4,x4,a5,x5,a6,x6,a7,x7,a8,x8,a9,x9
,aA,xA
++F++
,++D++aB,xB++F++
)
GenOperator_PASSE_D_____LIOn(LIO13
,LIO12
,++D++
a0,x0,a1,x1,a2,x2,a3,x3,a4,x4,a5,x5,a6,x6,a7,x7,a8,x8,a9,x9
,aA,xA,aB,xB
++F++
,++D++aC,xC++F++
)
GenOperator_PASSE_D_____LIOn(LIO14
,LIO13
,++D++
a0,x0,a1,x1,a2,x2,a3,x3,a4,x4,a5,x5,a6,x6,a7,x7,a8,x8,a9,x9
,aA,xA,aB,xB,aC,xC
++F++
,++D++aD,xD++F++
)
GenOperator_PASSE_D_____LIOn(LIO15
,LIO14
,++D++
a0,x0,a1,x1,a2,x2,a3,x3,a4,x4,a5,x5,a6,x6,a7,x7,a8,x8,a9,x9
,aA,xA,aB,xB,aC,xC,aD,xD
++F++
,++D++aE,xE++F++
)
GenOperator_PASSE_D_____LIOn(LIO16
,LIO15
,++D++
a0,x0,a1,x1,a2,x2,a3,x3,a4,x4,a5,x5,a6,x6,a7,x7,a8,x8,a9,x9
,aA,xA,aB,xB,aC,xC,aD,xD,aE,xE
++F++
,++D++aF,xF++F++
)
GenOperator_PASSE_D_____LIOn(LIO17
,LIO16
,++D++
a0,x0,a1,x1,a2,x2,a3,x3,a4,x4,a5,x5,a6,x6,a7,x7,a8,x8,a9,x9
,aA,xA,aB,xB,aC,xC,aD,xD,aE,xE,aF,xF
++F++
,++D++aG,xG++F++
)
GenOperator_PASSE_D_____LIOn(LIO18
,LIO17
,++D++
a0,x0,a1,x1,a2,x2,a3,x3,a4,x4,a5,x5,a6,x6,a7,x7,a8,x8,a9,x9
,aA,xA,aB,xB,aC,xC,aD,xD,aE,xE,aF,xF,aG,xG
++F++
,++D++aH,xH++F++
)
GenOperator_PASSE_D_____LIOn(LIO19
,LIO18
,++D++
a0,x0,a1,x1,a2,x2,a3,x3,a4,x4,a5,x5,a6,x6,a7,x7,a8,x8,a9,x9
,aA,xA,aB,xB,aC,xC,aD,xD,aE,xE,aF,xF,aG,xG,aH,xH
++F++
,++D++aI,xI++F++
)
GenOperator_PASSE_D_____LIOn(LIO20
,LIO19
,++D++
a0,x0,a1,x1,a2,x2,a3,x3,a4,x4,a5,x5,a6,x6,a7,x7,a8,x8,a9,x9
,aA,xA,aB,xB,aC,xC,aD,xD,aE,xE,aF,xF,aG,xG,aH,xH,aI,xI
++F++
,++D++aJ,xJ++F++
)
GenOperator_PASSE_D_____LIOn(LIO21
,LIO20
,++D++
a0,x0,a1,x1,a2,x2,a3,x3,a4,x4,a5,x5,a6,x6,a7,x7,a8,x8,a9,x9
,aA,xA,aB,xB,aC,xC,aD,xD,aE,xE,aF,xF,aG,xG,aH,xH,aI,xI,aJ,xJ
++F++
,++D++aK,xK++F++
)
GenOperator_PASSE_D_____LIOn(LIO22
,LIO21
,++D++
a0,x0,a1,x1,a2,x2,a3,x3,a4,x4,a5,x5,a6,x6,a7,x7,a8,x8,a9,x9
,aA,xA,aB,xB,aC,xC,aD,xD,aE,xE,aF,xF,aG,xG,aH,xH,aI,xI,aJ,xJ
,aK,xK
++F++
,++D++aL,xL++F++
)
GenOperator_PASSE_D_____LIOn(LIO23
,LIO22
,++D++
a0,x0,a1,x1,a2,x2,a3,x3,a4,x4,a5,x5,a6,x6,a7,x7,a8,x8,a9,x9
,aA,xA,aB,xB,aC,xC,aD,xD,aE,xE,aF,xF,aG,xG,aH,xH,aI,xI,aJ,xJ
,aK,xK,aL,xL
++F++
,++D++aM,xM++F++
)
GenOperator_PASSE_D_____LIOn(LIO24
,LIO23
,++D++
a0,x0,a1,x1,a2,x2,a3,x3,a4,x4,a5,x5,a6,x6,a7,x7,a8,x8,a9,x9
,aA,xA,aB,xB,aC,xC,aD,xD,aE,xE,aF,xF,aG,xG,aH,xH,aI,xI,aJ,xJ
,aK,xK,aL,xL,aM,xM
++F++
,++D++aN,xN++F++
)
GenOperator_PASSE_D_____LIOn(LIO25
,LIO24
,++D++
a0,x0,a1,x1,a2,x2,a3,x3,a4,x4,a5,x5,a6,x6,a7,x7,a8,x8,a9,x9
,aA,xA,aB,xB,aC,xC,aD,xD,aE,xE,aF,xF,aG,xG,aH,xH,aI,xI,aJ,xJ
,aK,xK,aL,xL,aM,xM,aN,xN
++F++
,++D++aO,xO++F++
)
GenOperator_PASSE_D_____LIOn(LIO26
,LIO25
,++D++
a0,x0,a1,x1,a2,x2,a3,x3,a4,x4,a5,x5,a6,x6,a7,x7,a8,x8,a9,x9
,aA,xA,aB,xB,aC,xC,aD,xD,aE,xE,aF,xF,aG,xG,aH,xH,aI,xI,aJ,xJ
,aK,xK,aL,xL,aM,xM,aN,xN,aO,xO
++F++
,++D++aP,xP++F++
)
GenOperator_PASSE_D_____LIOn(LIO27
,LIO26
,++D++
a0,x0,a1,x1,a2,x2,a3,x3,a4,x4,a5,x5,a6,x6,a7,x7,a8,x8,a9,x9
,aA,xA,aB,xB,aC,xC,aD,xD,aE,xE,aF,xF,aG,xG,aH,xH,aI,xI,aJ,xJ
,aK,xK,aL,xL,aM,xM,aN,xN,aO,xO,aP,xP
++F++
,++D++aQ,xQ++F++
)
/* Calcul optimise des formes lineaires N-dimensionnelles 'LIO?(....)' : */
/* */
/* Sigma(A .X ) + B */
/* i i */
/* */
/* en ne calculant les produits que pour les A(i) non nuls contrairement a 'LIN?(....)' */
/* qui calcule tout systematiquement. */
/* */
/* Le 20080102130008, furent introduites 'LIO14(...)' et 'LIO15(...)'. */
/* */
/* Le 20080104152848, fut introduite 'LIO16(...)'. */
/* */
/* Le 20080325155353, fut introduite 'LIO17(...)'. */
/* */
/* Le 20180821092424, furent introduites 'LIO18(...)' et 'LIO19(...)'. On notera leur mise */
/* en page inhabituelle (ainsi que pour 'LIO16(...)' et 'LIO17(...)') qui est destinee a */
/* eviter le message d'erreur : */
/* */
/* Error : (...): illegal macro name */
/* */
/* en '$PASSE_A'... */
/* */
/* Le 20180823181138 pour la commande 'vG' ('v $Falias_vG GenOperator_'), j'ai ramene le */
/* nom de l'operateur (ici 'LIO??') sur la meme ligne que 'GenOperator_PASSE_D_____LIOn'... */
/* */
/* Le 20181009165920, fut introduite 'LIO20(...)'. */
/* */
/* Le 20181203155403, fut introduite 'LIO21(...)'. */
/* */
/* Le 20201004104407, furent introduites 'LIO22(...)' a 'LIO27(...)'. */
_____define(GenOperator_PASSE_D_____LIRn,++D++-define $1($3) \
-_-_-_- DIVZ($2($3),$4($5))++F++
)
/* Generateur des 'LIR?(....)'s introduit le 20070914094954... */
/* */
/* Sigma(A .X ) + b */
/* i i */
/* ------------------ */
/* Sigma(A ) + b */
/* i */
/* */
/* Definition des arguments de 'GenOperator.PASSE.D.....LIRn(...)' (on notera la presence */
/* des "."s au lieu des "_"s dans les commentaires relatifs a cet operateur : cela est */
/* destine a bloquer l'action de '$m4' dans ces commentaires...) : */
/* */
/* $1 : nom de l'operateur 'LIR?' a definir (de rang 'n'), */
/* $2 : nom de l'operateur 'LIR?' a utiliser (de rang 'n-1'), */
/* $3 : premiere liste d'arguments (nombre variables d'elements), */
/* $4 : deuxieme liste d'arguments (toujours deux elements). */
/* */
/* ATTENTION : l'absence de "," en bout de ligne (derriere 'GenOperator.PASSE.D.....LIRn') */
/* donne a priori a 'GenOperator.PASSE.D.....LIRn' une valeur vide. Or cela fait partie de */
/* mon modele de programmation. La modification 'v $xcc/cpp$Z 20070912133816' est destinee */
/* justement a deplacer la "," de debut de ligne pour la mettre a la fin de la ligne */
/* precedente et ainsi donner a 'GenOperator.PASSE.D.....LIRn' la bonne definition... */
/* */
/* Le 20070913153802 le nom 'GenOperator_____LIRn(...)' fut change en */
/* 'GenOperator_P_D_____LIRn(...)' afin de contenir la passe '$PASSE_D' de generation, */
/* ce qui est utile dans 'v $xi/DICO$D/GenOperator$vv$sub GenOperator_P_._____'. */
/* */
/* Le 20071003152838 le nom 'GenOperator_P_D_____LIRn(...)' a ete change en */
/* 'GenOperator.PASSE.D.....LIRn(...)' pour une meilleure lisibilite... */
/* */
/* Avant le 20190724113720, il y avait ici : */
/* */
/* _____define(GenOperator_PASSE_D_____LIRn */
/* ,++D++-define $1($3) \ */
/* -_-_-_- DIVI($2($3),$4($5))++F++ */
/* ) */
/* */
/* Mais a cause de 'v $xiii/pent_image$FON LIR3', le 'DIVI(...)' a ete remplace par un */
/* 'DIVZ(...)' au cas ou la somme des ponderations serait nulle... */
GenOperator_PASSE_D_____LIRn(LIR1
,LIN1,++D++a0,x0,b++F++
,ADD2,++D++a0,b++F++
)
GenOperator_PASSE_D_____LIRn(LIR2
,LIN2,++D++a0,x0,a1,x1,b++F++
,ADD3,++D++a0,a1,b++F++
)
GenOperator_PASSE_D_____LIRn(LIR3
,LIN3,++D++a0,x0,a1,x1,a2,x2,b++F++
,ADD4,++D++a0,a1,a2,b++F++
)
GenOperator_PASSE_D_____LIRn(LIR4
,LIN4,++D++a0,x0,a1,x1,a2,x2,a3,x3,b++F++
,ADD5,++D++a0,a1,a2,a3,b++F++
)
GenOperator_PASSE_D_____LIRn(LIR5
,LIN5,++D++a0,x0,a1,x1,a2,x2,a3,x3,a4,x4,b++F++
,ADD6,++D++a0,a1,a2,a3,a4,b++F++
)
GenOperator_PASSE_D_____LIRn(LIR6
,LIN6,++D++a0,x0,a1,x1,a2,x2,a3,x3,a4,x4,a5,x5,b++F++
,ADD7,++D++a0,a1,a2,a3,a4,a5,b++F++
)
GenOperator_PASSE_D_____LIRn(LIR7
,LIN7,++D++a0,x0,a1,x1,a2,x2,a3,x3,a4,x4,a5,x5,a6,x6,b++F++
,ADD8,++D++a0,a1,a2,a3,a4,a5,a6,b++F++
)
GenOperator_PASSE_D_____LIRn(LIR8
,LIN8,++D++a0,x0,a1,x1,a2,x2,a3,x3,a4,x4,a5,x5,a6,x6,a7,x7,b++F++
,ADD9,++D++a0,a1,a2,a3,a4,a5,a6,a7,b++F++
)
GenOperator_PASSE_D_____LIRn(LIR9
,LIN9,++D++a0,x0,a1,x1,a2,x2,a3,x3,a4,x4,a5,x5,a6,x6,a7,x7,a8,x8,b++F++
,ADD10,++D++a0,a1,a2,a3,a4,a5,a6,a7,a8,b++F++
)
GenOperator_PASSE_D_____LIRn(LIR10
,LIN10,++D++a0,x0,a1,x1,a2,x2,a3,x3,a4,x4,a5,x5,a6,x6,a7,x7,a8,x8,a9,x9,b++F++
,ADD11,++D++a0,a1,a2,a3,a4,a5,a6,a7,a8,a9,b++F++
)
GenOperator_PASSE_D_____LIRn(LIR11
,LIN11,++D++a0,x0,a1,x1,a2,x2,a3,x3,a4,x4,a5,x5,a6,x6,a7,x7,a8,x8,a9,x9,aA,xA,b++F++
,ADD12,++D++a0,a1,a2,a3,a4,a5,a6,a7,a8,a9,aA,b++F++
)
GenOperator_PASSE_D_____LIRn(LIR12
,LIN12,++D++a0,x0,a1,x1,a2,x2,a3,x3,a4,x4,a5,x5,a6,x6,a7,x7,a8,x8,a9,x9,aA,xA,aB,xB,b++F++
,ADD13,++D++a0,a1,a2,a3,a4,a5,a6,a7,a8,a9,aA,aB,b++F++
)
GenOperator_PASSE_D_____LIRn(LIR13
,LIN13,++D++a0,x0,a1,x1,a2,x2,a3,x3,a4,x4,a5,x5,a6,x6,a7,x7,a8,x8,a9,x9,aA,xA,aB,xB,aC,xC,b++F++
,ADD14,++D++a0,a1,a2,a3,a4,a5,a6,a7,a8,a9,aA,aB,aC,b++F++
)
GenOperator_PASSE_D_____LIRn(LIR14
,LIN14,++D++a0,x0,a1,x1,a2,x2,a3,x3,a4,x4,a5,x5,a6,x6,a7,x7,a8,x8,a9,x9,aA,xA,aB,xB,aC,xC,aD,xD,b++F++
,ADD15,++D++a0,a1,a2,a3,a4,a5,a6,a7,a8,a9,aA,aB,aC,aD,b++F++
)
GenOperator_PASSE_D_____LIRn(LIR15
,LIN15,++D++a0,x0,a1,x1,a2,x2,a3,x3,a4,x4,a5,x5,a6,x6,a7,x7,a8,x8,a9,x9,aA,xA,aB,xB,aC,xC,aD,xD,aE,xE,b++F++
,ADD16,++D++a0,a1,a2,a3,a4,a5,a6,a7,a8,a9,aA,aB,aC,aD,aE,b++F++
)
/* Le 20080102130008, furent introduites 'LIR14(...)' et 'LIR15(...)'. */
_____define(GenOperator_PASSE_D_____LRZn,++D++-define $1($3) \
-_-_-_- $2($3,ZERO)++F++
)
/* Generateur des 'LRZ?(....)'s introduit le 20211116175755 pour simplifier les */
/* 'LIR?(...,[F]ZERO)', d'ou le nom 'LRZ?' pour "Zero"... */
/* */
/* Definition des arguments de 'GenOperator.PASSE.D.....LRZn(...)' (on notera la presence */
/* des "."s au lieu des "_"s dans les commentaires relatifs a cet operateur : cela est */
/* destine a bloquer l'action de '$m4' dans ces commentaires...) : */
/* */
/* $1 : nom de l'operateur 'LRZ?' a definir (de rang 'n'), */
/* $2 : nom de l'operateur 'LIR?' a utiliser (de rang 'n'), */
/* $3 : liste d'arguments. */
/* */
/* ATTENTION : l'absence de "," en bout de ligne (derriere 'GenOperator_PASSE_D.....LRZn') */
/* donne a priori a 'GenOperator_PASSE_D.....LRZn' une valeur vide. Or cela fait partie de */
/* mon modele de programmation. La modification 'v $xcc/cpp$Z 20070912133816' est destinee */
/* justement a deplacer la "," de debut de ligne pour la mettre a la fin de la ligne */
/* precedente et ainsi donner a 'GenOperator.PASSE.D.....LRZn' la bonne definition... */
GenOperator_PASSE_D_____LRZn(LRZ1 ,LIR1 ,++D++a0,x0++F++)
GenOperator_PASSE_D_____LRZn(LRZ2 ,LIR2 ,++D++a0,x0,a1,x1++F++)
GenOperator_PASSE_D_____LRZn(LRZ3 ,LIR3 ,++D++a0,x0,a1,x1,a2,x2++F++)
GenOperator_PASSE_D_____LRZn(LRZ4 ,LIR4 ,++D++a0,x0,a1,x1,a2,x2,a3,x3++F++)
GenOperator_PASSE_D_____LRZn(LRZ5 ,LIR5 ,++D++a0,x0,a1,x1,a2,x2,a3,x3,a4,x4++F++)
GenOperator_PASSE_D_____LRZn(LRZ6 ,LIR6 ,++D++a0,x0,a1,x1,a2,x2,a3,x3,a4,x4,a5,x5++F++)
GenOperator_PASSE_D_____LRZn(LRZ7 ,LIR7 ,++D++a0,x0,a1,x1,a2,x2,a3,x3,a4,x4,a5,x5,a6,x6++F++)
GenOperator_PASSE_D_____LRZn(LRZ8 ,LIR8 ,++D++a0,x0,a1,x1,a2,x2,a3,x3,a4,x4,a5,x5,a6,x6,a7,x7++F++)
GenOperator_PASSE_D_____LRZn(LRZ9 ,LIR9 ,++D++a0,x0,a1,x1,a2,x2,a3,x3,a4,x4,a5,x5,a6,x6,a7,x7,a8,x8++F++)
GenOperator_PASSE_D_____LRZn(LRZ10,LIR10,++D++a0,x0,a1,x1,a2,x2,a3,x3,a4,x4,a5,x5,a6,x6,a7,x7,a8,x8,a9,x9++F++)
GenOperator_PASSE_D_____LRZn(LRZ11,LIR11,++D++a0,x0,a1,x1,a2,x2,a3,x3,a4,x4,a5,x5,a6,x6,a7,x7,a8,x8,a9,x9,aA,xA++F++)
GenOperator_PASSE_D_____LRZn(LRZ12,LIR12,++D++a0,x0,a1,x1,a2,x2,a3,x3,a4,x4,a5,x5,a6,x6,a7,x7,a8,x8,a9,x9,aA,xA,aB,xB++F++)
GenOperator_PASSE_D_____LRZn(LRZ13
,LIR13
,++D++a0,x0,a1,x1,a2,x2,a3,x3,a4,x4,a5,x5,a6,x6,a7,x7,a8,x8,a9,x9,aA,xA,aB,xB,aC,xC++F++
)
GenOperator_PASSE_D_____LRZn(LRZ14
,LIR14
,++D++a0,x0,a1,x1,a2,x2,a3,x3,a4,x4,a5,x5,a6,x6,a7,x7,a8,x8,a9,x9,aA,xA,aB,xB,aC,xC,aD,xD++F++
)
GenOperator_PASSE_D_____LRZn(LRZ15
,LIR15
,++D++a0,x0,a1,x1,a2,x2,a3,x3,a4,x4,a5,x5,a6,x6,a7,x7,a8,x8,a9,x9,aA,xA,aB,xB,aC,xC,aD,xD,aE,xE++F++
)
/* Calcul des formes lineaires N-dimensionnelles 'LRZ?(....)' : */
/* */
/* Sigma(A .X ) */
/* i i */
/* -------------- */
/* Sigma(A ) */
/* i */
/* */
/* Cela fut introduit le 20211116175755 pour simplifier les 'LIR?(...,[F]ZERO)'... */
-define BLI1(a11,a1,x1,b) \
-_-_-_- LIN2(a11,EXP2(x1),a1,EXP1(x1),b)
/* Calcul de la forme bilineaire 1-dimensionnelle : */
/* */
/* 2 */
/* a11.x1 + a1.x1 + */
/* b */
/* */
/* (introduit le 20070626140959). */
-define BLI2(a11,a1,x1,a22,a2,x2,a12,b) \
-_-_-_- BLI1(a11,a1,x1 \
-_-_-_- ,BLI1(a22,a2,x2 \
-_-_-_- ,LIN1(a12,MUL2(x1,x2),b) \
-_-_-_- ) \
-_-_-_- )
/* Calcul de la forme bilineaire 2-dimensionnelle : */
/* */
/* 2 */
/* a11.x1 + a1.x1 + */
/* 2 */
/* a22.x2 + a2.x2 + */
/* a12.x1.x2 + */
/* b */
/* */
/* (introduit le 20070626140959). */
-define BLI3(a11,a1,x1,a22,a2,x2,a33,a3,x3,a12,a23,b) \
-_-_-_- BLI2(a11,a1,x1,a22,a2,x2,a12 \
-_-_-_- ,BLI1(a33,a3,x3 \
-_-_-_- ,LIN1(a23,MUL2(x2,x3),b) \
-_-_-_- ) \
-_-_-_- )
/* Calcul de la forme bilineaire 3-dimensionnelle : */
/* */
/* 2 */
/* a11.x1 + a1.x1 + */
/* 2 */
/* a22.x2 + a2.x2 + */
/* 2 */
/* a33.x3 + a3.x3 + */
/* a12.x1.x2 + */
/* a23.x2.x3 + */
/* b */
/* */
/* (introduit le 20070626140959). */
/* */
/* On notera l'absence de 'a31.x3.x1' trop difficile a introduire recursivement... */
-define BLI4(a11,a1,x1,a22,a2,x2,a33,a3,x3,a44,a4,x4,a12,a23,a34,b) \
-_-_-_- BLI3(a11,a1,x1,a22,a2,x2,a33,a3,x3,a12,a23 \
-_-_-_- ,BLI1(a44,a4,x4 \
-_-_-_- ,LIN1(a34,MUL2(x3,x4),b) \
-_-_-_- ) \
-_-_-_- )
/* Calcul de la forme bilineaire 4-dimensionnelle : */
/* */
/* 2 */
/* a11.x1 + a1.x1 + */
/* 2 */
/* a22.x2 + a2.x2 + */
/* 2 */
/* a33.x3 + a3.x3 + */
/* 2 */
/* a44.x4 + a4.x4 + */
/* a12.x1.x2 + */
/* a23.x2.x3 + */
/* a34.x3.x4 + */
/* b */
/* */
/* (introduit le 20070626140959). */
/* */
/* On notera l'absence de 'a41.x4.x1' trop difficile a introduire recursivement... */
-define BLI5(a11,a1,x1,a22,a2,x2,a33,a3,x3,a44,a4,x4,a55,a5,x5,a12,a23,a34,a45,b) \
-_-_-_- BLI4(a11,a1,x1,a22,a2,x2,a33,a3,x3,a44,a4,x4,a12,a23,a34 \
-_-_-_- ,BLI1(a55,a5,x5 \
-_-_-_- ,LIN1(a45,MUL2(x4,x5),b) \
-_-_-_- ) \
-_-_-_- )
/* Calcul de la forme bilineaire 5-dimensionnelle : */
/* */
/* 2 */
/* a11.x1 + a1.x1 + */
/* 2 */
/* a22.x2 + a2.x2 + */
/* 2 */
/* a33.x3 + a3.x3 + */
/* 2 */
/* a44.x4 + a4.x4 + */
/* 2 */
/* a55.x5 + a5.x5 + */
/* a12.x1.x2 + */
/* a23.x2.x3 + */
/* a34.x3.x4 + */
/* a45.x4.x5 + */
/* b */
/* */
/* (introduit le 20070626140959). */
/* */
/* On notera l'absence de 'a51.x5.x1' trop difficile a introduire recursivement... */
#define MODG(x,origine,extremite,Borne_Inferieure,Borne_Superieure) \
COND(IFNE(origine,extremite) \
/* Cas ou le segment [origine,extremite] n'est pas vide : */ \
,COND(IFLT(x,Borne_Inferieure(origine,extremite)) \
/* Cas ou le nombre 'x' est avant le segment [origine,extremite] : */ \
,SOUS(x \
,MUL2(PRED(QUOD(SOUS(SUCC(x) \
,Borne_Inferieure(origine,extremite) \
) \
,LENG(origine,extremite) \
) \
) \
,LENG(origine,extremite) \
) \
) \
,COND(IFGT(x,Borne_Superieure(origine,extremite)) \
/* Cas ou le nombre 'x' est apres le segment [origine,extremite] : */ \
,SOUS(x \
,MUL2(QUOD(SOUS(x \
,Borne_Inferieure(origine,extremite) \
) \
,LENG(origine,extremite) \
) \
,LENG(origine,extremite) \
) \
) \
/* Cas ou le nombre 'x' est dans le segment [origine,extremite] : */ \
,x \
) \
) \
/* Cas ou le segment [origine,extremite] est vide : */ \
,CHOI(origine,extremite) \
) \
/* Permet de ramener le nombre 'x' dans le segment [origine,extremite] */ \
/* quel que soit le signe de 'x' (ATTENTION : bornes INCLUSES...) : */ \
/* */ \
/* o o o */ \
/* o | o | o */ \
/* o origine o | o */ \
/* ------o------+-----o-----+------o-----> */ \
/* o | o extremite o x */ \
/* o | o | o */ \
/* o o o */ \
/* */ \
/* a comparer a 'TRON'... */ \
/* */ \
/* ATTENTION : 'MODG(...)' ne fonctionne qu'avec des nombres entiers ; pour des nombres */ \
/* flottants, il conviendra d'utiliser 'MODF(...)' avec un segment [origine,extremite] */ \
/* bien ordonne... */
#define MODU(x,origine,extremite) \
MODG(x,origine,extremite,MIN2,MAX2) \
/* Permet de ramener le nombre 'x' dans le segment [origine,extremite] */ \
/* quel que soit le signe de 'x' et quel que soit l'ordre des bornes */ \
/* 'origine' et 'extremite' du segment (ATTENTION : bornes INCLUSES...) : */ \
/* */ \
/* o o o */ \
/* o | o | o */ \
/* o origine o | o */ \
/* ------o------+-----o-----+------o-----> */ \
/* o | o extremite o x */ \
/* o | o | o */ \
/* o o o */ \
/* */ \
/* a comparer a 'TRON'... */ \
/* */ \
/* ATTENTION : 'MODU(...)' ne fonctionne qu'avec des nombres entiers ; pour des nombres */ \
/* flottants, il conviendra d'utiliser 'MODF(...)' avec un segment [origine,extremite] */ \
/* bien ordonne... */
#define MODS(x,origine,extremite) \
MODG(x,origine,extremite,SE12,SE22) \
/* Permet de ramener le nombre 'x' dans le segment [origine,extremite] */ \
/* quel que soit le signe de 'x' et en supposant l'ordre des bornes */ \
/* 'origine' et 'extremite' du segment correct, c'est-a-dire que l'on a */ \
/* origine < extremite (ATTENTION : bornes INCLUSES...) : */ \
/* */ \
/* o o o */ \
/* o | o | o */ \
/* o origine o | o */ \
/* ------o------+-----o-----+------o-----> */ \
/* o | o extremite o x */ \
/* o | o | o */ \
/* o o o */ \
/* */ \
/* a comparer a 'TRON'... */ \
/* */ \
/* ATTENTION : 'MODS(...)' ne fonctionne qu'avec des nombres entiers ; pour des nombres */ \
/* flottants, il conviendra d'utiliser 'MODF(...)' avec un segment [origine,extremite] */ \
/* bien ordonne... */
#define MODF(x,origine,extremite) \
HOMO(CERC(HOMO(x \
,origine,extremite \
,FZERO,CERCLE_TRIGONOMETRIQUE \
) \
) \
,FZERO,CERCLE_TRIGONOMETRIQUE \
,origine,extremite \
) \
/* Permet de ramener le nombre 'x' dans le segment [origine,extremite] */ \
/* quel que soit le signe de 'x' et en supposant l'ordre des bornes */ \
/* 'origine' et 'extremite' du segment correct, c'est-a-dire que l'on a */ \
/* origine < extremite (ATTENTION : bornes INCLUSES...) : */ \
/* */ \
/* o o o */ \
/* o | o | o */ \
/* o origine o | o */ \
/* ------o------+-----o-----+------o-----> */ \
/* o | o extremite o x */ \
/* o | o | o */ \
/* o o o */ \
/* */ \
/* a comparer a 'TRON'... */ \
/* */ \
/* On notera que 'MODF(...)' fonctionne correctement avec des nombres flottants... */
#define MODFcs(x,origine,extremite) \
MEME_SIGNE_QUE(x,MODF(x,origine,extremite)) \
/* Identique a 'MODF(...)' mais en Conservant le Signe, meme si cela n'a que peu de sens, */ \
/* cela fut introduit le 20060814171943 pour 'v $xrs/surfaces.12$I MODFcs'. Cela n'a en */ \
/* effet que peu de sens mathematiquement car, en effet, en respectant le signe de 'x', le */ \
/* resultat du 'MODF(...)' qui etait evidemment dans [origine,extremite], peut en sortir a */ \
/* cause du 'MEME_SIGNE_QUE(...)'... */
#define bSCAL(x,ancien_intervalle,nouvel_intervalle) \
MUL2(DIVI(x \
,ancien_intervalle \
) \
,nouvel_intervalle \
) \
/* Introduit le 20040409122523 specifiquement pour 'v $xcp/Bugs$K bSCAL' afin qu'il n'y */ \
/* ait pas de conditionnalite dans cette regle de trois... */
#define bbSCAL(x,ancien_intervalle,nouvel_intervalle) \
bMUL(bDIV(x \
,ancien_intervalle \
) \
,nouvel_intervalle \
) \
/* Introduit le 20161203114852 pour etre sur de bloquer un processus de derivation (voir */ \
/* par exemple 'v $xrs/huit.11$I bbSCAL'). */
-define gSCAZ(x,ancien_intervalle,nouvel_intervalle,exception,conversion) \
-_-_-_- COND(IZNE(ancien_intervalle) \
-_-_-_- ,MUL2(DIVI(conversion(x) \
-_-_-_- ,conversion(ancien_intervalle) \
-_-_-_- ) \
-_-_-_- ,conversion(nouvel_intervalle) \
-_-_-_- ) \
-_-_-_- ,exception \
-_-_-_- )
/* Fonction identique a 'SCAL(...)' mais prenant en compte la possibilite qu'a l'ancien */
/* intervalle de se reduire a un point et ce quels que soient les types des donnees */
/* (introduit le 20011025140011 a cause de 'v $xrk/rdn_walk.52$K dSCAL'). */
-define SCAZ(x,ancien_intervalle,nouvel_intervalle,exception) \
-_-_-_- gSCAZ(x,ancien_intervalle,nouvel_intervalle,exception,FLOT)
/* Fonction identique a 'SCAL(...)' mais prenant en compte la possibilite qu'a l'ancien */
/* intervalle de se reduire a un point... */
-define SCAL(x,ancien_intervalle,nouvel_intervalle) \
-_-_-_- SCAZ(x,ancien_intervalle,nouvel_intervalle,x)
/* Permet de faire une "regle de trois" qui fait passer le nombre 'x' */
/* d'un 'ancien intervalle' a un 'nouvel intervalle', soit : */
/* */
/* nouvel_intervalle */
/* ------------------- . x */
/* ancien_intervalle */
/* */
/* ou en abrege : */
/* */
/* n */
/* SCAL(x,a,n) = x.--- */
/* a */
/* */
/* le resultat est donne en flottant. ATTENTION, j'ai longtemps utilise : */
/* */
/* MUL2(DIVI(FLOT(nouvel_intervalle) */
/* ,FLOT(ancien_intervalle) */
/* ) */
/* ,FLOT(x) */
/* ) */
/* */
/* mais afin de garantir l'obtention de la valeur 'nouvel_intervalle' dans le cas ou : */
/* */
/* x = ancien_intervalle */
/* */
/* j'ai change l'ordre des operations (ceci s'est vu a la suite d'un probleme de conversion */
/* dans la fonction 'Ifloat_std(...)' de '$xiii/conversion$FON' pour laquelle de temps en */
/* temps le maximum de 'nouvel_intervalle' n'est pas atteint pour 'x' valant le maximum de */
/* 'ancien_intervalle'). */
-define dSCAL(x,ancien_intervalle,nouvel_intervalle) \
-_-_-_- INTE(SCAL(x,ancien_intervalle,nouvel_intervalle))
/* Fonction identique a 'SCAL(...)' mais sans typage des donnees afin de pouvoir l'utiliser, */
/* par exemple, pour dimensionner des tableaux ('v $xrk/rdn_walk.52$K dSCAL'). En fait, */
/* jusqu'au 20011026102952, la definition de 'dSCAL(...)' a ete : */
/* */
/* -define dSCAL(x,ancien_intervalle,nouvel_intervalle) \ */
/* -_-_-_- gSCAZ(x,ancien_intervalle,nouvel_intervalle,x,NEUT) */
/* */
/* mais cela creait un petit probleme car le calcul qui est effectue en realite est : */
/* */
/* x */
/* SCAL(x,a,n) = ---.n */
/* a */
/* */
/* et non pas : */
/* */
/* n */
/* SCAL(x,a,n) = x.--- */
/* a */
/* */
/* La division etant effectuee avant la multiplication, il y a une perte de precision */
/* importante et ainsi, par exemple, dans 'v $xrk/rdn_walk.52$K dSCAL' avec un ancien */
/* et un nouvel intervalles egaux (a 256 au passage), le resultat (egal a 29952) etait */
/* different de 'x' (egal a 30000 dans ce cas). D'ou cette nouvelle version... */
-define idSCAL(x,ancien_intervalle,nouvel_intervalle) \
-_-_-_- gSCAZ(x,ancien_intervalle,nouvel_intervalle,x,NEUT)
/* Le 20170126111709, a cause de '$LACT1A' il a fallu introduire cette version speciale */
/* de 'dSCAL(...)' ne contenant pas de typage 'FLOT(...)'. En effet, 'dSCAL(...)' sur */
/* '$LACT1A' donnait pour les fichers : */
/* */
/* $xrk/SolConnue.11$K */
/* $xrk/SolConnue.21$K */
/* $xrk/lorenz.11$K */
/* $xrk/rdn_walk.52$K */
/* */
/* les messages ennuyeux suivants : */
/* */
/* warning: variably modified '...' at file scope */
/* */
/* par exemple pour 'liste_des_index' (defini a l'EXTERIEUR de toute fonction -et en */
/* particulier du 'main(...)'- avec le type 'Local' -soit donc 'static'- via la procedure */
/* 'v $xrv/champs_5.41$I gDEFINITION_LISTE') et : */
/* */
/* error: storage size of '...' isn't constant */
/* */
/* par exemple pour 'liste_des_corps' (defini a l'INTERIEUR du 'main(...)'- avec le type */
/* 'Local'...). On remarque donc que le type de message depend de la localisation de la */
/* definition du tableau par rapport aux fonctions (et en particulier le 'main(...)'). */
/* */
/* En fait le probleme venait de la presence du typage '(double)' dans la definition */
/* de 'NOMBRE_MAXIMAL_DE_PERIODES_DE_LA_SIMULATION' via donc 'dSCAL(...)'... */
/* */
/* Cela s'est revu aux environs du 20180403185947 sur '$CMAP28, ex(1) "porte-brancion"' */
/* apres que toutes ces MACHINEs aient ete mises a jour. Il a donc fallu modifier en */
/* consequences les '$K's suivants : */
/* */
/* $xrk/SolConnue.11$K */
/* $xrk/SolConnue.21$K */
/* $xrk/lorenz.11$K */
/* $xrk/rdn_walk.52$K */
/* */
/* en introduisant 'SYSTEME_APC_LinuxRedHat_GCC' dans la definition conditionnelle de */
/* 'v $xrk/rdn_walk.52$K NOMBRE_MAXIMAL_DE_PERIODES_DE_LA_SIMULATION' (par exemple...). */
-define HOMO(x,origine1,extremite1,origine2,extremite2) \
-_-_-_- ADD2(SCAL(SOUS(x,origine1),SOUS(extremite1,origine1),SOUS(extremite2,origine2)),origine2)
/* Permet de faire passer le nombre 'x' appartenant a [origine1,extremite1] dans le */
/* segment [origine2,extremite2] en respectant la loi : */
/* */
/* y = f(x) = a.x + b */
/* */
/* ou : */
/* */
/* f(o1) = o2 */
/* f(e1) = e2 */
/* */
-define HOMZ(x,origine1,extremite1,origine2,extremite2,exception) \
-_-_-_- ADD2(SCAZ(SOUS(x,origine1),SOUS(extremite1,origine1),SOUS(extremite2,origine2),exception),origine2)
/* Permet de faire passer le nombre 'x' appartenant a [origine1,extremite1] dans le */
/* segment [origine2,extremite2] avec test de l'egalite de 'origine1' et de 'extremite1'. */
-define NORM(x,origine,extremite) \
-_-_-_- HOMO(x,origine,extremite,COORDONNEE_BARYCENTRIQUE_MINIMALE,COORDONNEE_BARYCENTRIQUE_MAXIMALE)
/* Permet de normaliser le nombre 'x' appartenant a [origine,extremite], c'est-a-dire, */
/* le ramene dans le segment [0,1]. */
-define NORZ(x,origine,extremite,exception) \
-_-_-_- HOMZ(x,origine,extremite,COORDONNEE_BARYCENTRIQUE_MINIMALE,COORDONNEE_BARYCENTRIQUE_MAXIMALE,exception)
/* Permet de normaliser le nombre 'x' appartenant a [origine,extremite], c'est-a-dire, */
/* le ramene dans le segment [0,1] avec test de l'egalite de 'origine' et de 'extremite'. */
-define DENO(x,origine,extremite) \
-_-_-_- HOMO(x,COORDONNEE_BARYCENTRIQUE_MINIMALE,COORDONNEE_BARYCENTRIQUE_MAXIMALE,origine,extremite)
/* Operation inverse de 'NORM(...)', et fait donc passer le nombre 'x' normalise du segment */
/* [0,1] au segment [origine,extremite]. */
#define TRON(x,origine,extremite) \
MIN2(extremite,MAX2(origine,x)) \
/* Permet de ramener par troncation le nombre 'x' dans le segment [origine,extremite] */ \
/* quel que soit son signe et en supposant origine<extremite : */ \
/* */ \
/* o o o o o o */ \
/* o | */ \
/* origine o | */ \
/* ----------+-----o-----+---------> */ \
/* | o extremite x */ \
/* | o */ \
/* o o o o o o */ \
/* */ \
/* a comparer a 'MODU'... */
#define TROQ(x,origine,extremite) \
TRON(x,MIN2(origine,extremite),MAX2(origine,extremite)) \
/* Procedure identique a 'TRON(...)' mais independante de l'ordre relatif de 'origine' */ \
/* et de 'extremite'... */
#define xTRON(x,borne_gauche,borne_droite,valeur_a_gauche,valeur_au_centre,valeur_a_droite,IfInclus) \
COND(IfInclus(x,borne_gauche,borne_droite) \
,valeur_au_centre \
,COND(IFLE(x,borne_gauche) \
,valeur_a_gauche \
,COND(IFGE(x,borne_droite) \
,valeur_a_droite \
,FLOT__UNDEF \
) \
) \
) \
/* Version "eXtended" de 'TRON(...)'. Ceci fut introduit le 20070508095059. On notera */ \
/* que l'on utilise 'IFLE(...)' et 'IFGE(...)' quel que soit 'IfInclus(...)' utilise, mais */ \
/* cela fonctionne correctement car, en effet, lorsque 'IFLE(...)' et 'IFGE(...)' sont */ \
/* appelees, 'IfInclus(...)' a deja fait les bons choix "ouvert"/"ferme". Enfin, on notera */ \
/* le 'FLOT__UNDEF' qui correspond en fait a un cas impossible car, en effet, cela voudrait */ \
/* dire qu'alors 'x' est dans '][borne_gauche,borne_droite][', alors que 'IfInclus(...)' a */ \
/* deja traite ce cas... */
#define xTROQ(x,borne_gauche,borne_droite,valeur_a_gauche,valeur_au_centre,valeur_a_droite,IfInclus) \
xTRON(x \
,MIN2(borne_gauche,borne_droite) \
,MAX2(borne_gauche,borne_droite) \
,valeur_a_gauche \
,valeur_au_centre \
,valeur_a_droite \
,IfInclus \
) \
/* Procedure identique a 'xTRON(...)' mais independante de l'ordre relatif de 'origine' */ \
/* et de 'extremite'. Elle fut introduite le 20070515115443 par symetrie avec 'TROQ(...)'... */
#define ESCA(x,origine,extremite,inferieur,milieu,superieur) \
COND(IFLT(x,origine) \
,inferieur \
,COND(IFGT(x,extremite) \
,superieur \
,milieu \
) \
) \
/* Procedure "marche d'escalier" en supposant 'origine < extremite' : */ \
/* */ \
/* ^ */ \
/* superieur | o o o o o */ \
/* | | */ \
/* | origine | */ \
/* milieu |---------o-o-o-o-o-o-o---------> */ \
/* | | extremite x */ \
/* | | */ \
/* inferieur | o o o o */ \
/* | */ \
/* */
#define ESCQ(x,origine,extremite,inferieur,milieu,superieur) \
ESCA(x,MIN2(origine,extremite),MAX2(origine,extremite),inferieur,milieu,superieur) \
/* Procedure identique a 'ESCA(...)' mais independante de l'ordre relatif de 'origine' */ \
/* et de 'extremite'... */
#define PRENDRE_UN_POURCENTAGE(x,pourcent) \
SCAL(x,CENT,pourcent) \
/* Prend 'pourcent' % du nombre 'x'. */
#define CONVERTIR_EN_UN_POURCENTAGE(x,nombre) \
SCAL(x,nombre,CENT) \
/* Convertit le nombre 'x' en un pourcentage par rapport au cardinal 'nombre' d'un certain */ \
/* ensemble. */
/* Calculs de pourcentages. ATTENTION a ne pas confondre les deux procedures precedentes */
/* introduite sous cette forme le 20061023153419 afin de remplacer 'POURCENTAGE(...)' qui */
/* jouait simultanement les deux roles sans le savoir et qui etait definie par : */
/* */
/* #define POURCENTAGE(x,nombre) \ */
/* SCAL(x,nombre,CENT) */
/* */
/* (equivalent a 'CONVERTIR_EN_UN_POURCENTAGE(...)') avant le 20031111174436, puis ensuite */
/* par : */
/* */
/* #define POURCENTAGE(x,nombre) \ */
/* SCAL(x,CENT,nombre) */
/* */
/* (equivalent a 'PRENDRE_UN_POURCENTAGE(...)'). */
/* */
/* Avec les deux nouvelles definitions, on a, par exemple : */
/* */
/* PRENDRE_UN_POURCENTAGE(1234,80) = 987.2 (=80% de 1234) */
/* CONVERTIR_EN_UN_POURCENTAGE(23,200) = 11.5% (=(23/200)*100) */
/* */
/* ce qui est enfin correct... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* O P E R A T I O N A R I T H M E T I Q U E " U N I V E R S E L L E " : */
/* */
/*************************************************************************************************************************************/
/* L'operateur 'UNI2(...)' a donc ete supprime le 20061024122449 et fut remplace par */
/* 'v $xig/fonct$vv$DEF GENERE__FonctionF_UNI2_02' dont on peut voir un exemple d'usage */
/* dans 'v $xrv/UNI2.11$K GENERE__FonctionF_UNI2_02'... */
/* Operation arithmetique "universelle". Ceci a ete introduit le 20050302163022 et ne sert */
/* a rien a cette date. Elle est en fait prevue pour definir des versions "etendues" des */
/* operateurs de base {ADD2,SOUS,MUL2,DIVZ,MIN2,MAX2,MOYE,MOYZ,MOYQ} ; ainsi, par exemple, */
/* la version etendue de 'ADD2(a,b)' sera 'UNI2(a,b,1,0,0,0,0,0,0,0,0,0,0)' par defaut, mais */
/* pourra etre redefinie dynamiquement comme 'UNI2(a,b,0,0,0,0,1,0,0,0,0,0,0)' c'est-a-dire */
/* 'MIN2(a,b)'. On pourrait alors, par exemple, faire des fractales ou l'addition et la */
/* multiplication seraient remplacees par le minimum et le maximum respectivement... */
/* */
/* Le 20050304114538 je note qu'il serait peut-etre mieux d'utiliser 'fDIVZ(...)' plutot */
/* que 'DIVZ(...)', mais malheureusement le type des arguments 'a' et 'b' n'est pas connu. */
/* La valeur renvoyee par une division par 0 sera donc 'INFINI' quel que soit le type des */
/* arguments 'a' et 'b'... */
/* */
/* Le 20060126113949, je note donc en resume que : */
/* */
/* UNI2(a,b,1,0,0,0,0,0,0,0,0,0,0) = ADD2(a,b) */
/* UNI2(a,b,0,1,0,0,0,0,0,0,0,0,0) = SOUS(a,b) */
/* UNI2(a,b,0,0,1,0,0,0,0,0,0,0,0) = MUL2(a,b) */
/* UNI2(a,b,0,0,0,1,0,0,0,0,0,0,0) = DIVZ(a,b) */
/* UNI2(a,b,0,0,0,0,1,0,0,0,0,0,0) = MIN2(a,b) */
/* UNI2(a,b,0,0,0,0,0,1,0,0,0,0,0) = MAX2(a,b) */
/* UNI2(a,b,0,0,0,0,0,0,1,0,0,0,0) = MINMAX(a,b) */
/* UNI2(a,b,0,0,0,0,0,0,0,1,0,0,0) = MAXMIN(a,b) */
/* UNI2(a,b,0,0,0,0,0,0,0,0,1,0,0) = MOYE(a,b) */
/* UNI2(a,b,0,0,0,0,0,0,0,0,0,1,0) = MOYZ(a,b) */
/* UNI2(a,b,0,0,0,0,0,0,0,0,0,0,1) = MOYQ(a,b) */
/* */
/* et que, pour faire de l'arithmetique "MAX-PLUS", il suffit de parametrer les deux */
/* fonctions : */
/* */
/* FfxADD2(a,b) = UNI2(a,b,0,0,0,0,0,1,0,0,0,0,0) [=MAX2(a,b)] */
/* FfxMUL2(a,b) = UNI2(a,b,1,0,0,0,0,0,0,0,0,0,0) [=ADD2(a,b)] */
/* */
/* en fixant correctement leurs ponderations ('v $xig/fonct$vv$FON FfxADD2' et */
/* 'v $xig/fonct$vv$FON FfxMUL2' respectivement...). */
/* */
/* Le 20061023101624, furent introduits 'MINMAX(...)' et 'MAXMIN(...)'... */
/* */
/* Le 20061024122449, de plus la procedure 'UNI2(...)' a ete supprimee car, en effet, sa */
/* mise a jour etait difficile : il convenait, si une nouvelle ponderation et une nouvelle */
/* procedures etaient ajoutees, de ne pas de tromper en l'inserant partout ou necessaire et */
/* exactement au bon endroit. Voici, malgre tout, sa definition : */
/* */
/* #define UNI2(a,b \ */
/* ,pond_ADD2,pond_SOUS \ */
/* ,pond_MUL2,pond_DIVZ \ */
/* ,pond_MIN2,pond_MAX2 \ */
/* ,pond_MINMAX,pond_MAXMIN \ */
/* ,pond_MOYE,pond_MOYZ,pond_MOYQ \ */
/* ) \ */
/* LIN11(pond_ADD2,ADD2(a,b) \ */
/* ,pond_SOUS,SOUS(a,b) \ */
/* ,pond_MUL2,MUL2(a,b) \ */
/* ,pond_DIVZ,DIVZ(a,b) \ */
/* ,pond_MIN2,MIN2(a,b) \ */
/* ,pond_MAX2,MAX2(a,b) \ */
/* ,pond_MINMAX,MINMAX(a,b) \ */
/* ,pond_MAXMIN,MAXMIN(a,b) \ */
/* ,pond_MOYE,MOYE(a,b) \ */
/* ,pond_MOYZ,MOYZ(a,b) \ */
/* ,pond_MOYQ,MOYQ(a,b) \ */
/* ,ZERO \ */
/* ) */
/* */
/* */
/* Le 20061102164207 je note l'interet de l'arithmetique "MIN-ADD" (ou "MIN-PLUS") a la */
/* place de l'arithmetique usuelle "ADD-MUL" (ou "PLUS-MUL") definie par : */
/* */
/* FfxADD2(a,b) = UNI2(a,b,0,0,0,0,1,0,0,0,0,0,0) [=MIN2(a,b)] */
/* FfxMUL2(a,b) = UNI2(a,b,1,0,0,0,0,0,0,0,0,0,0) [=ADD2(a,b)] */
/* */
/* En particulier, elle permet de trouver les plus courts chemins de longueur 'N' dans un */
/* graphe non oriente (les longueurs sont positives). Soit par exemple le graphe suivant : */
/* */
/* */
/* A */
/* */
/* /\ */
/* / \ */
/* / \ */
/* 2 / \ 3 */
/* / \ */
/* / \ */
/* / \ */
/* -------------- */
/* B 7 C */
/* */
/* */
/* compose des trois noeuds {A,B,C} et de trois aretes non orientees de longueurs */
/* respectives {2,3,7}. La matrice de connexite 'M' est donc : */
/* */
/* */
/* A B C */
/* */
/* A | 0 2 3 | */
/* | | */
/* B | 2 0 7 | = M */
/* | | */
/* C | 3 7 0 | */
/* */
/* */
/* qui donne finalement les plus courts chemins de longueur 'N=1". Son carre calcule avec */
/* l'arithmetique "MIN-PLUS" c'est-a-dire en remplacant : */
/* */
/* Sigma [M(i,j) x M(j,k)] */
/* */
/* par : */
/* */
/* Minimum[M(i,j) + M(j,k)] */
/* */
/* vaut : */
/* */
/* */
/* A B C */
/* */
/* A | 4 2 3 | */
/* | | 2 */
/* B | 2 4 5 | = M */
/* | | */
/* C | 3 5 6 | */
/* */
/* */
/* qui donne les plus courts chemins de longueur 'N=2'. Ainsi, par exemple : */
/* */
/* Chemin2(B,C) = Chemin1(B,A) + Chemin1(A,C) = 2 + 3 = 5 */
/* */
/* ou encore : */
/* */
/* Chemin2(C,C) = Chemin1(C,A) + Chemin1(A,C) = 3 + 3 = 6 */
/* */
/* Enfin, la puissance N-ieme de la matrice 'M' donnerait les plus courts chemins de */
/* longueur 'N'... */
/* */
/* On notera que malheureusement, a la date du 20080108155955, le carre de la matrice 'M' */
/* vaut en fait : */
/* */
/* */
/* A B C */
/* */
/* A | 0 2 3 | */
/* | | 2 */
/* B | 2 0 5 | = M */
/* | | */
/* C | 3 5 0 | */
/* */
/* */
/* la diagonale etant nulle. Cela s'est vu grace a 'v $xci/multi_02.03$K' et vient */
/* evidemment du 'MIN2(...)' pour lequel : */
/* */
/* MIN2(0+0,ValeurPositiveQuelconque) = 0 */
/* */
/* (les '0+0' venant des "carres" des elements de la diagonale de la matrice 'M'). */
/* Il faudrait donc, pour traiter correctement ce cas, une variante de 'MIN2(...)' qui */
/* "eliminerait" en quelque sorte les valeurs nulles (voire negatives ou nulles)... */
/* La solution fut trouvee avec l'option 'v $xiii/tri_image$FON 20080109083121' qui */
/* consiste a permettre d'ignorer les couples {0,0} lors de l'iteration de produit... */
/* */
/* On notera le 20080109110510, au passage, que le carre de la matrice 'M', au sens */
/* traditionnel du terme, est : */
/* */
/* | 13 21 14 | */
/* | | 2 */
/* | 21 53 6 | = M */
/* | | */
/* | 14 6 58 | */
/* */
/* ce qui permettra de faciliter des tests ulterieurs... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N D E L A D E R I V A T I O N N U M E R I Q U E P A R T I E L L E : */
/* */
/*************************************************************************************************************************************/
#define DERIVATION_PARTIELLE(fonction_origine,fonction_extremite,amplitude_de_la_variable) \
DIVI(SOUS(fonction_extremite,fonction_origine) \
,amplitude_de_la_variable \
) \
/* Permet de calculer la derivee numerique partielle d'une fonction suivante la formule */ \
/* "geniale" suivante : */ \
/* */ \
/* extremite - origine */ \
/* derivee = --------------------- */ \
/* amplitude */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N D E S C O O R D O N N E E S B A R Y C E N T R I Q U E S E T D U B A R Y C E N T R E : */
/* */
/*************************************************************************************************************************************/
-define COORDONNEE_BARYCENTRIQUE_MINIMALE \
-_-_-_- FZERO
/* Definition de la valeur minimale d'une coordonnee barycentrique, */
-define COORDONNEE_BARYCENTRIQUE_MAXIMALE \
-_-_-_- FU
/* Definition de la valeur maximale d'une coordonnee barycentrique. */
-define COORDONNEE_BARYCENTRIQUE_CENTRALE \
-_-_-_- MOYE(COORDONNEE_BARYCENTRIQUE_MINIMALE,COORDONNEE_BARYCENTRIQUE_MAXIMALE)
/* Definition de la valeur centrale d'une coordonnee barycentrique. */
-define AMPLITUDE_DES_COORDONNEES_BARYCENTRIQUES \
-_-_-_- bSOU(COORDONNEE_BARYCENTRIQUE_MAXIMALE,COORDONNEE_BARYCENTRIQUE_MINIMALE)
/* Amplitude des coordonnees barycentriques (introduite le 20061218152415). */
/* */
/* Le 20101120092003, 'bSOU(...)' plus logique a remplace 'SOUS(...)'. */
/* */
/* Le 20101210184750, les definitions 'COORDONNEE_BARYCENTRIQUE_CENTRALE' et */
/* 'AMPLITUDE_DES_COORDONNEES_BARYCENTRIQUES' sont passees de '$PASSE_1' a '$PASSE_D' */
/* a cause de 'v $xiii/aleat.2$vv$DEF AMPLITUDE_DES_COORDONNEES_BARYCENTRIQUES'... */
-define BAR2(point1,point2,lambda) \
-_-_-_- ADD2(DIS2(point1,NEUT(COORDONNEE_BARYCENTRIQUE_MAXIMALE),NEGA(lambda)) \
-_-_-_- ,DIS2(point2,NEUT(lambda),NEGA(COORDONNEE_BARYCENTRIQUE_MINIMALE)) \
-_-_-_- )
/* Permet de calculer le barycentre du segment [point1,point2] suivant le parametre */
/* 'lambda', c'est-a-dire la valeur de l'expression : */
/* */
/* [(1-lambda).point1] + [(lambda-0).point2] */
/* */
/* pour les valeurs 0 et 1 de 'lambda', elle vaut : */
/* */
/* BARY(point1,point2,0) = point1 */
/* BARY(point1,point2,1) = point2 */
/* */
/* Introduit le 20060207101350 par symetrie avec le nouveau 'BAR4(...)'... */
-define BARY(origine,extremite,lambda) \
-_-_-_- BAR2(origine,extremite,lambda)
/* Permet de calculer le barycentre du segment [origine,extremite] suivant le parametre */
/* 'lambda', c'est-a-dire la valeur de l'expression : */
/* */
/* [(1-lambda).origine] + [(lambda-0).extremite] */
/* */
/* pour les valeurs 0 et 1 de 'lambda', elle vaut : */
/* */
/* BARY(origine,extremite,0) = origine */
/* BARY(origine,extremite,1) = extremite */
/* */
/* */
/* Autrefois, la fonction 'BARY(...)' etait formulee de la facon suivante : */
/* */
/* #define BARY(origine,extremite,lambda) \ */
/* ADD2(MUL2(SOUS(COORDONNEE_BARYCENTRIQUE_MAXIMALE \ */
/* ,lambda \ */
/* ) \ */
/* ,origine \ */
/* ) \ */
/* ,MUL2(SOUS(lambda \ */
/* ,COORDONNEE_BARYCENTRIQUE_MINIMALE \ */
/* ) \ */
/* ,extremite \ */
/* ) \ */
/* */
/* Mais afin que la fonction 'BARY(...)' puisse participer a la detection de la sensibilite */
/* a la precision des calculs, il est plus simple qu'elle reference 'DIS2(x,a,b)', dont on */
/* consultera avec profit les commentaires... */
#define fBARY(origine,extremite,lambda,fonction) \
BARY(origine,extremite,fonction(lambda)) \
/* Permet de calculer le barycentre du segment [origine,extremite] suivant le parametre */ \
/* 'lambda', c'est-a-dire la valeur de l'expression : */ \
/* */ \
/* [(1-fonction(lambda)).origine] + [fonction(lambda).extremite] */ \
/* */ \
/* pour les valeurs 0 et 1 de 'lambda', elle vaut : */ \
/* */ \
/* fBARY(origine,extremite,0,fonction) = origine */ \
/* fBARY(origine,extremite,1,fonction) = extremite */ \
/* */ \
/* Il est de plus important que : */ \
/* */ \
/* 0 <= fonction(lambda) <= 1 */ \
/* */ \
/* pour : */ \
/* */ \
/* lambda E [0,1] */ \
/* */ \
/* ATTENTION, a cause de la definition en '$PASSE_D' de 'BARY(...)', il est imperatif de */ \
/* definir 'fBARY(...)' a partir de 'BARY(...)' et non pas l'inverse (qui aurait ete en */ \
/* fait plus logique puisque 'fBARY(...)' est plus generale que 'BARY(...)'). */
#define vBARY(origine,extremite,lambda) \
COND(IFINff(lambda,GRAND_EPSILON,SOUS(COORDONNEE_BARYCENTRIQUE_MAXIMALE,GRAND_EPSILON)) \
,BARY(origine,extremite,lambda) \
,COND(IFLT(lambda,GRAND_EPSILON) \
,origine \
,extremite \
) \
) \
/* Permet de calculer le barycentre du segment [origine,extremite] suivant le parametre */ \
/* 'lambda' et avec validation de celui-ci, c'est-a-dire la valeur de l'expression : */ \
/* */ \
/* [(1-lambda).origine] + [lambda.extremite] */ \
/* */ \
/* pour les valeurs 0 et 1 de 'lambda', elle vaut : */ \
/* */ \
/* BARY(origine,extremite,0) = origine */ \
/* BARY(origine,extremite,1) = extremite */ \
/* */
-define BAR4(point1,point2,point3,point4,lambda1,lambda2) \
-_-_-_- BAR2(BAR2(point1,point3,lambda1),BAR2(point2,point4,lambda1),lambda2)
/* Introduit le 20060207101914, permet de calculer le barycentre du quadrilatere */
/* {point1,point2,point3,point4} suivant les parametres {lambda1,lambda2}, c'est-a-dire */
/* la valeur de l'expression : */
/* */
/* [(1-l1).(1-l2).p1] + [(1-l1).(l2-0).p2] + [(l1-0).(1-l2).p3] + [(l1-0).(l2-0).p4] */
/* */
/* ce qui peut s'ecrire : */
/* */
/* {[(1-l1).p1] + [(l1-0).p3]}.(1-l2) + {[(1-l1).p2] + [(l1-0).p4]}.(l2-0) */
/* */
/* soit : */
/* */
/* [BAR2(p1,p3,l1).(1-l2)] + [BAR2(p2,p4,l1).(l2-0)] */
/* */
/* soit encore : */
/* */
/* BAR2(BAR2(p1,p3,l1),BAR2(p2,p4,l1),l2) (1) */
/* */
/* Evidemment, cela pourrait aussi s'ecrire : */
/* */
/* {[(1-l2).p1] + [(l2-0).p2]}.(1-l1) + {[(1-l2).p3] + [(l2-0).p4]}.(l1-0) */
/* */
/* soit : */
/* */
/* [BAR2(p1,p2,l2).(1-l1)] + [BAR2(p3,p4,l2).(l1-0)] */
/* */
/* soit enfin : */
/* */
/* BAR2(BAR2(p1,p2,l2),BAR2(p3,p4,l2),l1) (2) */
/* */
/* qui est donc equivalente a (1)... */
/* */
/* Cette nouvelle formulation introduite le 20060207121926 rend caduque la definition de */
/* de 'DIT2(...)', mais je conserve cette derniere malgre tout, car on ne sait jamais... */
/* */
/* Pour les valeurs 0 et 1 de 'lambda1' et de 'lambda2', elle vaut : */
/* */
/* BAR4(point1,point2,point3,point4,0,0) = point1 */
/* BAR4(point1,point2,point3,point4,0,1) = point2 */
/* BAR4(point1,point2,point3,point4,1,0) = point3 */
/* BAR4(point1,point2,point3,point4,1,1) = point4 */
/* */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* O P E R A T I O N S D E " D E C O U P A G E " D ' U N N O M B R E : */
/* */
/*************************************************************************************************************************************/
/* ATTENTION : depuis qu'a ete introduite la '$PASSE_D', il est imperatif que certaines */
/* definitions soient faites avant d'autres ; en particulier 'NEUT(...)' doit etre definie */
/* avant tout '-define ...'. */
-define FRA1(x) \
-_-_-_- NEUT(x)
/* Par symetrie avec les autres 'FRAi'. */
-define FRA2(x) \
-_-_-_- FRAn(x,DEUX)
/* Moitie du nombre 'x'. */
-define MOIT(x) \
-_-_-_- FRA2(x)
-define fMOIT(x) \
-_-_-_- fFRAn(x,DEUX)
/* Moitie du nombre 'x'. */
#define MOID(x) \
QUOD(x,DEUX) \
/* Moitie par Defaut du nombre 'x'. */
#define MOIE(x) \
QUOE(x,DEUX) \
/* Moitie par Exces du nombre 'x'. */
-define FRA3(x) \
-_-_-_- FRAn(x,TROIS)
/* Tiers du nombre 'x'. */
-define TIER(x) \
-_-_-_- FRA3(x)
-define fTIER(x) \
-_-_-_- fFRAn(x,TROIS)
/* Tiers du nombre 'x' ('fTIER' fut introduit le 20070213092213 pour 'PI_SUR_3'...). */
-define FRA4(x) \
-_-_-_- FRAn(x,QUATRE)
/* Quart du nombre 'x'. */
-define QUAR(x) \
-_-_-_- FRA4(x)
-define fQUAR(x) \
-_-_-_- fFRAn(x,QUATRE)
/* Quart du nombre 'x'. */
-define FRA5(x) \
-_-_-_- FRAn(x,CINQ)
/* Cinquieme du nombre 'x'. */
-define FRA6(x) \
-_-_-_- FRAn(x,SIX)
/* Sixieme du nombre 'x'. */
-define FRA7(x) \
-_-_-_- FRAn(x,SEPT)
/* Septieme du nombre 'x'. */
-define FRA8(x) \
-_-_-_- FRAn(x,HUIT)
/* Huitieme du nombre 'x'. */
-define FRA9(x) \
-_-_-_- FRAn(x,NEUF)
/* Neuvieme du nombre 'x'. */
-define FRA10(x) \
-_-_-_- FRAn(x,DIX)
/* Dixieme du nombre 'x'. */
-define FRA11(x) \
-_-_-_- FRAn(x,ONZE)
/* Onzieme du nombre 'x'. */
-define FRA12(x) \
-_-_-_- FRAn(x,DOUZE)
/* Douzieme du nombre 'x'. */
-define FRA13(x) \
-_-_-_- FRAn(x,TREIZE)
/* Treizieme du nombre 'x'. */
-define FRA14(x) \
-_-_-_- FRAn(x,QUATORZE)
/* Quatorzieme du nombre 'x'. */
-define FRA15(x) \
-_-_-_- FRAn(x,QUINZE)
/* Quinzieme du nombre 'x'. */
-define FRA16(x) \
-_-_-_- FRAn(x,SEIZE)
/* Seizieme du nombre 'x'. */
-define FRAm1(x) \
-_-_-_- FRAn(x,MILLE)
-define FRAm2(x) \
-_-_-_- FRAn(x,MILLION)
-define FRAm3(x) \
-_-_-_- FRAn(x,MILLIARD)
/* Operateurs introduits le 20180504144637 pour 'v $xil/defi_c1$vv$DEF FRAm1' en */
/* particulier... */
/* Le 20101228082819, la definition des operateurs 'GROn(...)' est passee de : */
/* */
/* -define GROn(x) \ */
/* -_-_-_- MUL2(x,n) */
/* */
/* a : */
/* */
/* -define GROn(x) \ */
/* -_-_-_- MUL2(n,x) */
/* */
/* afin que lors d'une eventuelle derivation formelle la derivee de 'n' (='d_CONSTANTES') */
/* apparaisse en premier argument d'un 'MUL2(...)' et qu'ainsi un 'MUL2(0,...)' soit */
/* facilement identifiable en vue de faire des simplifications d'expressions formelles... */
-define GRO0(x) \
-_-_-_- ZERO
/* (par "symetrie" avec 'DOUB' et 'TRIP'...). ATTENTION, il y a eu pendant longtemps : */
/* */
/* -define GRO0(x) \ */
/* -_-_-_- MUL2(x,ZERO) */
/* */
/* or l'existence d'un bug de type 'BUG_SYSTEME_CRAY_C_GRO0' creait un probleme */
/* lie a l'impossibilite d'avoir des definitions de '$PASSE_D' conditionnelles. Il a donc */
/* fallu choisir pour 'GRO0(...)' une definition universelle ('ZERO'...). */
-define GROu(x) \
-_-_-_- UN
/* Introduit le 20200320103803 pour 'v $xrs/vagues.13$I GROu'... */
-define GRO1(x) \
-_-_-_- MUL2(UN,x)
/* (par "symetrie" avec 'DOUB' et 'TRIP'...). */
-define GRO2(x) \
-_-_-_- MUL2(DEUX,x)
/* Double du nombre 'x'. */
-define GRO3(x) \
-_-_-_- MUL2(TROIS,x)
/* Triple du nombre 'x'. */
-define GRO4(x) \
-_-_-_- MUL2(QUATRE,x)
/* Quadruple du nombre 'x'. */
-define GRO5(x) \
-_-_-_- MUL2(CINQ,x)
/* Multiplication par 5 du nombre 'x'. */
-define GRO6(x) \
-_-_-_- MUL2(SIX,x)
/* Multiplication par 6 du nombre 'x'. */
-define GRO7(x) \
-_-_-_- MUL2(SEPT,x)
/* Multiplication par 7 du nombre 'x'. */
-define GRO8(x) \
-_-_-_- MUL2(HUIT,x)
/* Multiplication par 8 du nombre 'x'. */
-define GRO9(x) \
-_-_-_- MUL2(NEUF,x)
/* Multiplication par 9 du nombre 'x'. */
-define GRO10(x) \
-_-_-_- MUL2(DIX,x)
/* Multiplication par 10 du nombre 'x'. */
-define GRO11(x) \
-_-_-_- MUL2(ONZE,x)
/* Multiplication par 11 du nombre 'x'. */
-define GRO12(x) \
-_-_-_- MUL2(DOUZE,x)
/* Multiplication par 12 du nombre 'x'. */
-define GRO13(x) \
-_-_-_- MUL2(TREIZE,x)
/* Multiplication par 13 du nombre 'x'. */
-define GRO14(x) \
-_-_-_- MUL2(QUATORZE,x)
/* Multiplication par 14 du nombre 'x'. */
-define GRO15(x) \
-_-_-_- MUL2(QUINZE,x)
/* Multiplication par 15 du nombre 'x'. */
-define GRO16(x) \
-_-_-_- MUL2(SEIZE,x)
/* Multiplication par 16 du nombre 'x'. */
/* Le 20101228082819, la definition des operateurs 'GROn(...)' est passee de : */
/* */
/* -define GROn(x) \ */
/* -_-_-_- MUL2(x,n) */
/* */
/* a : */
/* */
/* -define GROn(x) \ */
/* -_-_-_- MUL2(n,x) */
/* */
/* afin que lors d'une eventuelle derivation formelle la derivee de 'n' (='d_CONSTANTES') */
/* apparaisse en premier argument d'un 'MUL2(...)' et qu'ainsi un 'MUL2(0,...)' soit */
/* facilement identifiable en vue de faire des simplifications d'expressions formelles... */
-define ZORO(x) \
-_-_-_- GRO0(x)
/* (par "symetrie" avec 'DOUB' et 'TRIP'...). */
-define MONO(x) \
-_-_-_- GRO1(x)
/* (par "symetrie" avec 'DOUB' et 'TRIP'...). */
-define DOUB(x) \
-_-_-_- GRO2(x)
/* Double du nombre 'x'. */
-define DOUP(x) \
-_-_-_- ADD2(DOUB(x),UN)
/* Double du nombre 'x' plus un. */
-define TRIP(x) \
-_-_-_- GRO3(x)
/* Triple du nombre 'x'. */
-define QUAD(x) \
-_-_-_- GRO4(x)
/* Quadruple du nombre 'x'. */
-define EXP0(x) \
-_-_-_- UN
/* 'x' a la puissance 0... */
-define EXP1(x) \
-_-_-_- MUL2(x,EXP0(x))
/* 'x' a la puissance 1... */
-define EXP2(x) \
-_-_-_- MUL2(x,EXP1(x))
/* 'x' a la puissance 2 (ou 'carre')... */
-define EXP3(x) \
-_-_-_- MUL2(x,EXP2(x))
/* 'x' a la puissance 3 (ou 'cube')... */
-define EXP4(x) \
-_-_-_- MUL2(x,EXP3(x))
/* 'x' a la puissance 4... */
-define EXP5(x) \
-_-_-_- MUL2(x,EXP4(x))
/* 'x' a la puissance 5... */
-define EXP6(x) \
-_-_-_- MUL2(EXP3(x),EXP3(x))
/* 'x' a la puissance 6... */
-define EXP7(x) \
-_-_-_- MUL2(EXP3(x),EXP4(x))
/* 'x' a la puissance 7 (introduit le 20170928110301, pour le plaisir...). */
-define EXP8(x) \
-_-_-_- MUL2(EXP4(x),EXP4(x))
/* 'x' a la puissance 8 (introduit le 20170928110301, pour le plaisir...). */
-define EXP9(x) \
-_-_-_- MUL2(EXP3(x),EXP6(x))
/* 'x' a la puissance 9... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E R I V E E S D E S O P E R A T E U R S L O G I Q U E S : */
/* */
/*************************************************************************************************************************************/
#define d_IFOU(condition_1,condition_2) \
IFOU(condition_1,condition_2) \
/* Derivee de la fonction 'IFOU' : */ \
/* */ \
/* d(IFOU(c1,c2)) = IFOU(c1,c2) */ \
/* */
#define d_IFET(condition_1,condition_2) \
IFET(condition_1,condition_2) \
/* Derivee de la fonction 'IFET' : */ \
/* */ \
/* d(IFET(c1,c2)) = IFET(c1,c2) */ \
/* */
#define d_IFEQ(x,a) \
IFEQ(x,a) \
/* Derivee de la fonction 'IFEQ' : */ \
/* */ \
/* d(IFEQ(x,a)) = IFEQ(x,a) */ \
/* */
#define d_IFNE(x,a) \
IFNE(x,a) \
/* Derivee de la fonction 'IFNE' : */ \
/* */ \
/* d(IFNE(x,a)) = IFNE(x,a) */ \
/* */
#define d_IFGE(x,a) \
IFGE(x,a) \
/* Derivee de la fonction 'IFGE' : */ \
/* */ \
/* d(IFGE(x,a)) = IFGE(x,a) */ \
/* */
#define d_IFGT(x,a) \
IFGT(x,a) \
/* Derivee de la fonction 'IFGT' : */ \
/* */ \
/* d(IFGT(x,a)) = IFGT(x,a) */ \
/* */
#define d_IFLE(x,a) \
IFLE(x,a) \
/* Derivee de la fonction 'IFLE( : */ \
/* */ \
/* d(IFLE(x,a)) = IFLE(x,a) */ \
/* */
#define d_IFLT(x,a) \
IFLT(x,a) \
/* Derivee de la fonction 'IFLT' : */ \
/* */ \
/* d(IFLT(x,a)) = IFLT(x,a) */ \
/* */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E R I V E E D E L ' O P E R A T E U R D E S E L E C T I O N C O N D I T I O N N E L L E : */
/* */
/*************************************************************************************************************************************/
#define d_COND(condition,valeur_si_vrai,valeur_si_faux) \
COND(condition,d#valeur_si_vrai,d#valeur_si_faux) \
/* Derivee de la fonction de selection conditionnelle : */ \
/* */ \
/* d(selection(c,v,f)) = selection(c,d(v),d(f)) */ \
/* */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N D E S M A S Q U E S F O N D A M E N T A U X ( F I N ) : */
/* */
/*************************************************************************************************************************************/
/* ATTENTION, a cause de la generation de '$xcp/Konstantes$K', la definition des differents */
/* masques ne peut se faire qu'apres celle des decalages. Ceci est du en particulier au bug */
/* relatif a la fonction 'SARS(...)'. */
#define k___MHEXA \
gMASQUE(NBITHX) \
/* Definition du masque d'acces au chiffre hexa-decimal de droite d'un mot. */ \
/* */ \
/* ATTENTION : la constante 'MHEXA' est pre-generee dans '$xcp/Konstantes$K'. */
#define k___MOCD \
gMASQUE(NBITOC) \
/* Definition du masque d'acces a l'octet de droite d'un mot. */ \
/* */ \
/* ATTENTION : la constante 'MOCD' est pre-generee dans '$xcp/Konstantes$K'. */
#define k___MHWD \
gMASQUE(NBITHW) \
/* Definition du masque d'acces au demi-mot de droite d'un mot. */ \
/* */ \
/* ATTENTION : la constante 'MHWD' est pre-generee dans '$xcp/Konstantes$K'. */
#define k___MMOT \
OUIN(SCLS(MHWD,NBITHW),MHWD) \
/* Definition du masque d'un mot entier. */ \
/* */ \
/* ATTENTION : la constante 'MMOT' est pre-generee dans '$xcp/Konstantes$K'. */ \
/* */ \
/* Jusqu'au 20171219152301, 'k___MMOT' etait defini par : */ \
/* */ \
/* #define k___MMOT \ */ \
/* gMASQUE(NBITMO) */ \
/* */ \
/* Malheureusement cela donnait le message suivant sur '$CMAP28' : */ \
/* */ \
/* warning: left shift count >= width of type [enabled by default] */ \
/* */ \
/* L'option 'v $Fcompilers .Wno.shift.count.overflow' n'existant pas sur '$CMAP28' */ \
/* (contrairement a '$LACT1A') il a fallu definir 'k___MMOT' autrement... */
#if ( (defined(BUG_SYSTEME_C_SARS)) \
)
# undef k___MHWD
# define k___MHWD \
SLRS(MMOT,NBITHW) \
/* Definition du masque d'acces au demi-mot de Droite d'un mot. */ \
/* */ \
/* ATTENTION : voir le commentaire associe a la definition de 'SIZE_GENERAL(...)'. */ \
/* */ \
/* ATTENTION : la constante 'MHWD' est pre-generee dans '$xcp/Konstantes$K'. */
# undef k___MMOT
# define k___MMOT \
NEGA(UN) \
/* Definition du masque d'un mot entier ; dans la mesure ou les decalages Arithmetiques */ \
/* a droite n'existent pas ici, et que leur simulation demande 'MMOT' (via 'COMK(...)'), */ \
/* il est difficile de definir 'MMOT' a l'aide 'NBITHW' qui utilise 'SARS(...)'... */ \
/* */ \
/* ATTENTION : voir le commentaire associe a la definition de 'SIZE_GENERAL(...)'. */ \
/* */ \
/* ATTENTION : la constante 'MMOT' est pre-generee dans '$xcp/Konstantes$K'. */
#Aif ( (defined(BUG_SYSTEME_C_SARS)) \
)
#Eif ( (defined(BUG_SYSTEME_C_SARS)) \
)
#define k___VALEUR_MINIMALE_DANS_UN_OCTET \
MASQUE_VIDE
#define k___VALEUR_MAXIMALE_DANS_UN_OCTET \
MOCD
#define k___NOMBRE_D_OCTETS_DIFFERENTS \
LENG(VALEUR_MINIMALE_DANS_UN_OCTET,VALEUR_MAXIMALE_DANS_UN_OCTET)
/* Plus petite et plus grande valeur (non signees) stockables dans un octet. Le parametre */
/* 'NOMBRE_D_OCTETS_DIFFERENTS' a ete introduit le 20041202091409... */
/* */
/* ATTENTION : ces constantes sont pre-generees dans '$xcp/Konstantes$K'. */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* " P R E - G E N E R A T I O N " D E S C O N S T A N T E S F O N D A M E N T A L E S : */
/* */
/*************************************************************************************************************************************/
#TestADef MHEXA \
k___MHEXA
#TestADef MOCD \
k___MOCD
#TestADef MHWD \
k___MHWD
#TestADef MMOT \
k___MMOT
#TestADef VALEUR_MINIMALE_DANS_UN_OCTET \
k___VALEUR_MINIMALE_DANS_UN_OCTET
#TestADef VALEUR_MAXIMALE_DANS_UN_OCTET \
k___VALEUR_MAXIMALE_DANS_UN_OCTET
#TestADef NOMBRE_D_OCTETS_DIFFERENTS \
k___NOMBRE_D_OCTETS_DIFFERENTS
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* O P E R A T I O N S S U R B I T S D A N S U N M O T : */
/* */
/*************************************************************************************************************************************/
#define LBIT \
UNITE \
/* Longueur d'un bit... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* O P E R A T I O N S S U R O C T E T D A N S U N M O T : */
/* */
/*************************************************************************************************************************************/
#define Decalage_octet(numero_de_l_octet) \
bMUL(bSOU(TRMU(NOCMO),numero_de_l_octet),NBITOC) \
/* Cette fonction convertit un numero d'octet (l'octet '0' etant l'octet de */ \
/* gauche) en une amplitude de decalage a droite. */
#define BYTn(mot,numero_de_l_octet) \
ETLO(SLRS(mot,Decalage_octet(numero_de_l_octet)),MOCD) \
/* Recuperation de l'octet numero 'n' dans un mot, l'octet '0' etant le plus a gauche... */
#define BYT0(mot) \
BYTn(mot,ZERO) \
/* Recuperation de l'octet numero '0' dans un mot, l'octet '0' etant le plus a gauche... */
#define BYT1(mot) \
BYTn(mot,UN) \
/* Recuperation de l'octet numero '1' dans un mot, l'octet '0' etant le plus a gauche... */
#define BYT2(mot) \
BYTn(mot,DEUX) \
/* Recuperation de l'octet numero '2' dans un mot, l'octet '0' etant le plus a gauche... */
#define BYT3(mot) \
BYTn(mot,TROIS) \
/* Recuperation de l'octet numero '3' dans un mot, l'octet '0' etant le plus a gauche... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* O P E R A T I O N S D ' I N C R E M E N T A T I O N : */
/* */
/*************************************************************************************************************************************/
#define INCR(x,increment) \
EGAL(x,bADD(x,increment)) \
/* Incrementation d'une variable. */ \
/* */ \
/* Le 20101120092003, 'bADD(...)' plus logique a remplace 'ADD2(...)'. */
#define DECR(x,decrement) \
EGAL(x,bSOU(x,decrement)) \
/* Decrementation d'une variable. */ \
/* */ \
/* Le 20101120092003, 'bSOU(...)' plus logique a remplace 'SOUS(...)'. */
#define INCK(x) \
INCR(x,I) \
/* Incrementation d'un compteur (introduit le 20200404105518). */
#define DECK(x) \
DECR(x,I) \
/* Decrementation d'un compteur (introduit le 20200404105518). */
#define PRED(x) \
bSOU(x,I) \
/* Fonction 'PREDecesseur'. */ \
/* */ \
/* Le 20101120092003, 'bSOU(...)' plus logique a remplace 'SOUS(...)'. */
-define SUCC(x) \
-_-_-_- bADD(x,I)
/* Fonction 'SUCCesseur'. */
/* */
/* Le 20101120092003, 'bADD(...)' plus logique a remplace 'ADD2(...)'. */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* O P E R A T I O N S D E P E R M U T A T I O N S D E D E U X V A L E U R S : */
/* */
/*************************************************************************************************************************************/
#define SWAP(x,y) \
Bblock \
EGAL(x,OUEX(x,y)); \
EGAL(y,OUEX(y,x)); \
EGAL(x,OUEX(x,y)); \
Eblock \
/* Permutation des variables (de type 'Int', 'Char' ou 'CHAR') 'x' et 'y' ; cette solution */ \
/* par 'OUEX()' permet de ne pas faire d'allocation memoire locale, et donc pas d'hypotheses */ \
/* trop strictes sur le type des arguments 'x' et 'y'... */
#define xSWAP(x,y,Type) \
Bblock \
DEFV(Type,INIT(variable_de_manoeuvre,x)); \
EGAL(x,y); \
EGAL(y,variable_de_manoeuvre); \
Eblock \
/* Permutation des variables (de type 'Type' quelconque) 'x' et 'y'. */
#define cSWAP(x,y) \
Bblock \
xSWAP(x,y,CHAR); \
Eblock \
/* Permutation des variables (de type 'CHAR') 'x' et 'y'. */
#define iSWAP(x,y) \
Bblock \
xSWAP(x,y,Int); \
Eblock \
/* Permutation des variables (de type 'Int') 'x' et 'y'. */
#define fSWAP(x,y) \
Bblock \
xSWAP(x,y,Float); \
Eblock \
/* Permutation des variables (de type 'Float') 'x' et 'y'. */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* S E L E C T I O N S C O N D I T I O N N E L L E S : */
/* */
/*************************************************************************************************************************************/
#define CONV(condition,valeur_si_vrai,valeur_si_faux) \
COND(TOUJOURS_VRAI,valeur_si_vrai,valeur_si_faux) \
/* 'COND(...)' toujours VRAI ; on notera qu'il pourrait etre programme de facon peut-etre */ \
/* plus optimise par : */ \
/* */ \
/* SE23(condition,valeur_si_vrai,valeur_si_faux) */ \
/* */
#define CONF(condition,valeur_si_vrai,valeur_si_faux) \
COND(TOUJOURS_FAUX,valeur_si_vrai,valeur_si_faux) \
/* 'COND(...)' toujours FAUX ; on notera qu'il pourrait etre programme de facon peut-etre */ \
/* plus optimise par : */ \
/* */ \
/* SE33(condition,valeur_si_vrai,valeur_si_faux) */ \
/* */
_____define(GenOperator_PASSE_1_____CONnn,++D++#define $1($3,$4,vl_FAUX) \
CON01($3,$2($4,vl_FAUX))++F++
)
/* Generateur des 'CON??(....)'s introduit le 20070912125718... */
/* */
/* Definition des arguments de 'GenOperator.PASSE.D.....CONnn(...)' (on notera la presence */
/* des "."s au lieu des "_"s dans les commentaires relatifs a cet operateur : cela est */
/* destine a bloquer l'action de '$m4' dans ces commentaires...) : */
/* */
/* $1 : nom de l'operateur 'CON??' a definir (de rang 'n'), */
/* $2 : nom de l'operateur 'CON??' a utiliser (de rang 'n-1'), */
/* $3 : premiere liste d'arguments (toujours deux elements). */
/* $4 : deuxieme liste d'arguments (nombre variables d'elements), */
/* */
/* ATTENTION : l'absence de "," en bout de ligne (derriere 'GenOperator.PASSE.D.....CONnn') */
/* donne a priori a 'GenOperator.PASSE.D.....CONnn' une valeur vide. Or cela fait partie de */
/* mon modele de programmation. La modification 'v $xcc/cpp$Z 20070912133816' est destinee */
/* justement a deplacer la "," de debut de ligne pour la mettre a la fin de la ligne */
/* precedente et ainsi donner a 'GenOperator.PASSE.D.....CONnn' la bonne definition... */
#define CON01(c1,v1,vl_FAUX) \
COND(c1 \
,v1 \
,vl_FAUX \
)
/* Valeur conditionnelle a une condition (introduite le 20100512122420)... */
GenOperator_PASSE_1_____CONnn(CON02,CON01
,++D++c1,v1++F++
,++D++c2,v2++F++
)
/* ATTENTION, on notera ici (pour 'CON02(...)') et dans les definitions qui suivent (pour */
/* 'CON03(...)' a 'CON20(...)') des "choses" non conventionnelles : en effet. on trouve : */
/* */
/* CON02,CON01 */
/* */
/* (sur une meme ligne donc) et non pas : */
/* */
/* CON02 */
/* ,CON01 */
/* */
/* comme on pourrait l'esperer et comme cela est fait habituellement... */
/* */
/* De meme, la "(" est juste derriere l'appel a 'GenOperator_PASSE_1_____CONnn' et non */
/* pas devant le 'CON??' de la ligne qui suit... */
/* */
/* Tout cela est du a '$M4' qui est utilise ici et qui est tres "sensible" a la position */
/* des ","s comme cela s'est vu dans 'v $xiMo/GENERE$Z virgule' il y a bien longtemps... */
/* */
/* Le 20180823181138 pour la commande 'vG' ('v $Falias_vG GenOperator_'), j'ai ramene le */
/* nom de l'operateur defini (ici 'CON02') et celui qui le definit (ici 'CON01') sur la */
/* ligne que 'GenOperator_PASSE_1_____CONnn'... */
GenOperator_PASSE_1_____CONnn(CON03,CON02
,++D++c1,v1++F++
,++D++c2,v2,c3,v3++F++
)
GenOperator_PASSE_1_____CONnn(CON04,CON03
,++D++c1,v1++F++
,++D++c2,v2,c3,v3,c4,v4++F++
)
GenOperator_PASSE_1_____CONnn(CON05,CON04
,++D++c1,v1++F++
,++D++c2,v2,c3,v3,c4,v4,c5,v5++F++
)
GenOperator_PASSE_1_____CONnn(CON06,CON05
,++D++c1,v1++F++
,++D++c2,v2,c3,v3,c4,v4,c5,v5,c6,v6++F++
)
GenOperator_PASSE_1_____CONnn(CON07,CON06
,++D++c1,v1++F++
,++D++c2,v2,c3,v3,c4,v4,c5,v5,c6,v6,c7,v7++F++
)
GenOperator_PASSE_1_____CONnn(CON08,CON07
,++D++c1,v1++F++
,++D++c2,v2,c3,v3,c4,v4,c5,v5,c6,v6,c7,v7,c8,v8++F++
)
GenOperator_PASSE_1_____CONnn(CON09,CON08
,++D++c1,v1++F++
,++D++c2,v2,c3,v3,c4,v4,c5,v5,c6,v6,c7,v7,c8,v8,c9,v9++F++
)
GenOperator_PASSE_1_____CONnn(CON10,CON09
,++D++c1,v1++F++
,++D++c2,v2,c3,v3,c4,v4,c5,v5,c6,v6,c7,v7,c8,v8,c9,v9,cA,vA++F++
)
GenOperator_PASSE_1_____CONnn(CON11,CON10
,++D++c1,v1++F++
,++D++c2,v2,c3,v3,c4,v4,c5,v5,c6,v6,c7,v7,c8,v8,c9,v9,cA,vA,cB,vB++F++
)
GenOperator_PASSE_1_____CONnn(CON12,CON11
,++D++c1,v1++F++
,++D++c2,v2,c3,v3,c4,v4,c5,v5,c6,v6,c7,v7,c8,v8,c9,v9,cA,vA,cB,vB,cC,vC++F++
)
GenOperator_PASSE_1_____CONnn(CON13,CON12
,++D++c1,v1++F++
,++D++c2,v2,c3,v3,c4,v4,c5,v5,c6,v6,c7,v7,c8,v8,c9,v9,cA,vA,cB,vB,cC,vC,cD,vD++F++
)
GenOperator_PASSE_1_____CONnn(CON14,CON13
,++D++c1,v1++F++
,++D++c2,v2,c3,v3,c4,v4,c5,v5,c6,v6,c7,v7,c8,v8,c9,v9,cA,vA,cB,vB,cC,vC,cD,vD,cE,vE++F++
)
GenOperator_PASSE_1_____CONnn(CON15,CON14
,++D++c1,v1++F++
,++D++c2,v2,c3,v3,c4,v4,c5,v5,c6,v6,c7,v7,c8,v8,c9,v9,cA,vA,cB,vB,cC,vC,cD,vD,cE,vE,cF,vF++F++
)
GenOperator_PASSE_1_____CONnn(CON16,CON15
,++D++c1,v1++F++
,++D++c2,v2,c3,v3,c4,v4,c5,v5,c6,v6,c7,v7,c8,v8,c9,v9,cA,vA,cB,vB,cC,vC,cD,vD,cE,vE,cF,vF,cG,vG++F++
)
GenOperator_PASSE_1_____CONnn(CON17,CON16
,++D++c1,v1++F++
,++D++c2,v2,c3,v3,c4,v4,c5,v5,c6,v6,c7,v7,c8,v8,c9,v9,cA,vA,cB,vB,cC,vC,cD,vD,cE,vE,cF,vF,cG,vG,cH,vH++F++
)
GenOperator_PASSE_1_____CONnn(CON18,CON17
,++D++c1,v1++F++
,++D++c2,v2,c3,v3,c4,v4,c5,v5,c6,v6,c7,v7,c8,v8,c9,v9,cA,vA,cB,vB,cC,vC,cD,vD,cE,vE,cF,vF,cG,vG,cH,vH,cI,vI++F++
)
GenOperator_PASSE_1_____CONnn(CON19,CON18
,++D++c1,v1++F++
,++D++c2,v2,c3,v3,c4,v4,c5,v5,c6,v6,c7,v7,c8,v8,c9,v9,cA,vA,cB,vB,cC,vC,cD,vD,cE,vE,cF,vF,cG,vG,cH,vH,cI,vI,cJ,vJ++F++
)
GenOperator_PASSE_1_____CONnn(CON20,CON19
,++D++c1,v1++F++
,++D++c2,v2,c3,v3,c4,v4,c5,v5,c6,v6,c7,v7,c8,v8,c9,v9,cA,vA,cB,vB,cC,vC,cD,vD,cE,vE,cF,vF,cG,vG,cH,vH,cI,vI,cJ,vJ,cK,vK++F++
)
GenOperator_PASSE_1_____CONnn(CON21,CON20
,++D++c1,v1++F++
,++D++c2,v2,c3,v3,c4,v4,c5,v5,c6,v6,c7,v7,c8,v8,c9,v9,cA,vA,cB,vB,cC,vC,cD,vD,cE,vE,cF,vF,cG,vG,cH,vH,cI,vI,cJ,vJ,cK,vK,cL,vL++F++
)
/* Valeurs conditionnelles a deux,..., vingt conditions (introduites sous cette forme */
/* le 20170419095556). */
/* */
/* La procedure 'CON21(...)' a ete introduite le 20170515104124... */
/* */
/* Le 20180823181138 pour la commande 'vG' ('v $Falias_vG GenOperator_'), j'ai ramene le */
/* nom de l'operateur defini (du type 'CON??') et celui qui le definit (du type 'CON??') */
/* sur la ligne que 'GenOperator_PASSE_1_____CONnn'... */
#define SEL1(clef,clef1,valeur1,valeur_par_defaut) \
CON01(IFEQ(clef,clef1),valeur1 \
,valeur_par_defaut \
) \
/* Selection d'une valeur conditionnelle a une clef (introduite le 20070716103625)... */
#define SEL2(clef,clef1,valeur1,clef2,valeur2,valeur_par_defaut) \
CON02(IFEQ(clef,clef1),valeur1 \
,IFEQ(clef,clef2),valeur2 \
,valeur_par_defaut \
) \
/* Selection d'une valeur conditionnelle a deux clefs (introduite le 20070716103625)... */
#define SEL3(clef,clef1,valeur1,clef2,valeur2,clef3,valeur3,valeur_par_defaut) \
CON03(IFEQ(clef,clef1),valeur1 \
,IFEQ(clef,clef2),valeur2 \
,IFEQ(clef,clef3),valeur3 \
,valeur_par_defaut \
) \
/* Selection d'une valeur conditionnelle a trois clefs (introduite le 20070716103625)... */
#define SEL4(clef,clef1,valeur1,clef2,valeur2,clef3,valeur3,clef4,valeur4,valeur_par_defaut) \
CON04(IFEQ(clef,clef1),valeur1 \
,IFEQ(clef,clef2),valeur2 \
,IFEQ(clef,clef3),valeur3 \
,IFEQ(clef,clef4),valeur4 \
,valeur_par_defaut \
) \
/* Selection d'une valeur conditionnelle a quatre clefs (introduite le 20070716103625)... */
#define ZNE1(valeur1,valeur_par_defaut) \
CON01(IZNE(valeur1),valeur1 \
,valeur_par_defaut \
) \
/* Recherche de la premiere valeur non nulle parmi une (introduite le 20100623134438). */
#define ZNE2(valeur1,valeur2,valeur_par_defaut) \
CON02(IZNE(valeur1),valeur1 \
,IZNE(valeur2),valeur2 \
,valeur_par_defaut \
) \
/* Recherche de la premiere valeur non nulle parmi deux (introduite le 20100623134438). */
#define ZNE3(valeur1,valeur2,valeur3,valeur_par_defaut) \
CON03(IZNE(valeur1),valeur1 \
,IZNE(valeur2),valeur2 \
,IZNE(valeur4),valeur4 \
,valeur_par_defaut \
) \
/* Recherche de la premiere valeur non nulle parmi trois (introduite le 20100623134438). */
#define ZNE4(valeur1,valeur2,valeur3,valeur4,valeur_par_defaut) \
CON04(IZNE(valeur1),valeur1 \
,IZNE(valeur2),valeur2 \
,IZNE(valeur3),valeur3 \
,IZNE(valeur4),valeur4 \
,valeur_par_defaut \
) \
/* Recherche de la premiere valeur non nulle parmi quatre (introduite le 20100623134438). */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* R E G L E D E S S I G N E S : */
/* */
/*************************************************************************************************************************************/
#define k___SIGNE_PLUS \
ABSO(UN) \
/* Pour definir le signe "+" (et la nullite...), */ \
/* */ \
/* ATTENTION, on notera que les valeurs de 'SIGNE_PLUS' et de 'SIGNE_MOINS' sont choisies */ \
/* de facon a etre utilisable dans des produits, par exemple dans 'MEME_SIGNE_QUE(...)'. */ \
/* */ \
/* Le 20101119160847, 'SIGNE_PLUS' est devenue une constante fondamentale... */
#define k___SIGNE_MOINS \
NEGA(SIGNE_PLUS) \
/* Pour definir le signe "-" ; ainsi, on respecte la tres fameuse */ \
/* regle des signes : "++" = "--" = "+", et "+-" = "-+" = "-". */ \
/* Malheureusement, on ne peut le valider par des "#if", car en effet, */ \
/* le pre-processeur n'admet pas l'appel a des macros dans les expressions */ \
/* de tests !!! */ \
/* */ \
/* ATTENTION, on notera que les valeurs de 'SIGNE_PLUS' et de 'SIGNE_MOINS' sont choisies */ \
/* de facon a etre utilisable dans des produits, par exemple dans 'MEME_SIGNE_QUE(...)'. */ \
/* */ \
/* Le 20101119160847, 'SIGNE_MOINS' est devenue une constante fondamentale... */
#TestADef SIGNE_PLUS \
k___SIGNE_PLUS
#TestADef SIGNE_MOINS \
k___SIGNE_MOINS
/* ATTENTION : les definitions de 'SIGNE_PLUS' et de 'SIGNE_MOINS' sont ici (et non pas */
/* apres celle de 'VALIDE' ci-apres, comme la logique le voudrait) a cause de la definition */
/* de 'SIGN(...)' ci-apres qui est en '$PASSE_D'... */
#define SIGNE_NUL \
MOYE(SIGNE_PLUS,SIGNE_MOINS) \
/* Pour definir eventuellement la nullite... */
#if ( (defined(BUG_SYSTEME_SGIND_C_divisions_entieres)) \
)
# undef SIGNE_NUL
# define SIGNE_NUL \
INTE(MOYE(SIGNE_PLUS,SIGNE_MOINS)) \
/* Pour definir eventuellement la nullite. ATTENTION, avant l'introduction de la primitive */ \
/* 'DIVn(...)' qui est utilisee dans 'MOYE(...)' via 'FRA2(...)', et qui sert donc ci-dessus */ \
/* pour definir 'SIGNE_NUL', il y avait ici : */ \
/* */ \
/* #define SIGNE_NUL \ */ \
/* MOYE(SIGNE_PLUS,SIGNE_MOINS) */ \
/* */ \
/* Or maintenant 'SIGNE_NUL' est defini par un 'FLOT(...)', il faut donc introduire un */ \
/* 'INTE(...)'. */
#Aif ( (defined(BUG_SYSTEME_SGIND_C_divisions_entieres)) \
)
#Eif ( (defined(BUG_SYSTEME_SGIND_C_divisions_entieres)) \
)
-define SIGN(x) \
-_-_-_- COND(IZLT(x),SIGNE_MOINS,SIGNE_PLUS)
/* Signe de 'x' qui peut etre utilise comme multiplicateur +1/-1. ATTENTION, la definition */
/* de 'SIGN(...)' doit suivre celle de 'SIGNE_PLUS' depuis l'introduction de la derivation */
/* formelle... */
-define SIGZ(x) \
-_-_-_- COND(IZEQ(x),SIGNE_NUL,COND(IZLT(x),SIGNE_MOINS,SIGNE_PLUS))
/* Intoduit le 20170305112745 afin d'integrer la nullite... */
-define MEME_SIGNE_QUE(signe,x) \
-_-_-_- bMUL(SIGN(signe),ABSO(x))
/* Donne a 'x' le meme signe que 'signe'... */
/* */
/* Le 20101120081525, 'bMUL(...)' a remplace 'MUL2(...)'. */
#define SONT_DE_MEME_SIGNE(x,y) \
IZGE(bMUL(x,y)) \
/* Indique si les deux nombres sont du meme signe (l'un ou les deux pouvant etre nuls)... */ \
/* */ \
/* Le 20101120081525, 'bMUL(...)' a remplace 'MUL2(...)'. */
#define NE_SONT_PAS_DE_MEME_SIGNE(x,y) \
NOTL(SONT_DE_MEME_SIGNE(x,y)) \
/* Indique si les deux nombres ne sont pas de meme signe (tous deux etant non nuls)... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* S T R U C T U R E S D E T E S T B I N A I R E : */
/* */
/*************************************************************************************************************************************/
#define TOUJOURS_VRAI \
EST_VRAI(VRAI) \
/* Condition toujours 'VRAI'... */
#define TOUJOURS_FAUX \
EST_VRAI(FAUX) \
/* Condition toujours 'FAUX'... */
#define TesV(conditions) \
Test(TOUJOURS_VRAI) \
/* 'Test' toujours 'VRAI'... */
#define TesF(conditions) \
Test(TOUJOURS_FAUX) \
/* 'Test' toujours 'FAUX'... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* O P E R A T E U R S D E T E S T B I N A I R E : */
/* */
/*************************************************************************************************************************************/
#define NEUL(x) \
NEUT(x) \
/* Condition logique 'x' inchangee. */ \
/* */ \
/* Le 20060718111227, je me demande quelle est finalement la difference entre 'NEUL(...)' */ \
/* et 'NEUTL(...)' ? */
#define VRAL(x) \
VRAI \
/* Condition logique 'x' toujours 'VRAI'. */
#define FAUL(x) \
FAUX \
/* Condition logique 'x' toujours 'FAUX'. */
#define gETAT_LOGIQUE(variable_logique,Chaine_VRAI,Chaine_FAUX) \
COND(IFEQ(variable_logique,VRAI) \
,Chaine_VRAI \
,COND(IFEQ(variable_logique,FAUX) \
,Chaine_FAUX \
,"LA VARIABLE N'A PAS UNE VALEUR LOGIQUE" \
) \
)
#define ETAT_LOGIQUE(variable_logique) \
gETAT_LOGIQUE(variable_logique,C_VRAI____,C_FAUX____)
#define ETAT_LOGIQUE_ABREGE(variable_logique) \
gETAT_LOGIQUE(variable_logique,C_VRAI_____ABREGE,C_FAUX_____ABREGE)
/* Permet de generer une chaine "VRAI"/"FAUX" suivant la valeur d'une variable logique */
/* argument. La version abregee a ete introduite le 20050128215608... */
#define NEUTL(x) \
COND(IFEQ(x,VRAI) \
,VRAI \
,COND(IFEQ(x,FAUX) \
,FAUX \
,LUNDEF \
) \
) \
/* Operation NEUTre Logique. */ \
/* */ \
/* Le 20060718111227, je me demande quelle est finalement la difference entre 'NEUL(...)' */ \
/* et 'NEUTL(...)' ? */
#define NOTL(x) \
COND(EST_VRAI(x) \
,FAUX \
,COND(EST_FAUX(x) \
,VRAI \
,LUNDEF \
) \
) \
/* Negation logique de 'x'. */
#define IMPLIQUE(p,q) \
OUIN(NOTL(p),q) \
/* Implication logique "p==>q" (introduite le 20210403090456). */
#define EQUI(condition_1,condition_2) \
IFOU(IFET(EST_VRAI(condition_1),EST_VRAI(condition_2)) \
,IFET(EST_FAUX(condition_1),EST_FAUX(condition_2)) \
) \
/* Test de l'equivalence logique de deux conditions. On notera que l'on pourrait ecrire */ \
/* ainsi cette definition : */ \
/* */ \
/* #define EQUI(condition_1,condition_2) \ */ \
/* IFEQ(condition_1,condition_2) */ \
/* */ \
/* mais, cela serait moins elegant... */
#define NEQU(condition_1,condition_2) \
NOTL(EQUI(condition_1,condition_2)) \
/* Test de la non-equivalence logique de deux conditions. On notera que l'on pourrait ecrire */ \
/* ainsi cette definition : */ \
/* */ \
/* #define EQUI(condition_1,condition_2) \ */ \
/* IFOU(IFET(EST_VRAI(condition_1),EST_FAUX(condition_2)) \ */ \
/* ,IFET(EST_FAUX(condition_1),EST_VRAI(condition_2)) \ */ \
/* ) */ \
/* */ \
/* cela serait aussi valable... */
#define I3OU(condition_1,condition_2,condition_3) \
IFOU(IFOU(condition_1,condition_2),condition_3) \
/* 'OU' binaire a 3 conditions (anciennement 'IMOU(....)'). */
#define I3ET(condition_1,condition_2,condition_3) \
IFET(IFET(condition_1,condition_2),condition_3) \
/* 'ET' binaire a 3 conditions (anciennement 'IMET(....)'). */
#define I4OU(condition_1,condition_2,condition_3,condition_4) \
IFOU(I3OU(condition_1,condition_2,condition_3),condition_4) \
/* 'OU' binaire a 4 conditions (anciennement 'INOU(....)'). */
#define I4ET(condition_1,condition_2,condition_3,condition_4) \
IFET(I3ET(condition_1,condition_2,condition_3),condition_4) \
/* 'ET' binaire a 4 conditions (anciennement 'INET(....)'). */
#define I5OU(condition_1,condition_2,condition_3,condition_4,condition_5) \
IFOU(I4OU(condition_1,condition_2,condition_3,condition_4),condition_5) \
/* 'OU' binaire a 5 conditions (introduit le 20030204093117, 'v $xiidP/fonct$vv$DEF I5OU', */ \
/* anciennement 'IOOU(....)'). */
#define I5ET(condition_1,condition_2,condition_3,condition_4,condition_5) \
IFET(I4ET(condition_1,condition_2,condition_3,condition_4),condition_5) \
/* 'ET' binaire a 5 conditions (introduit le 20030204093117, anciennement 'IOET(....)'). */
#define I6OU(cond_1,cond_2,cond_3,cond_4,cond_5,cond_6) \
IFOU(I5OU(cond_1,cond_2,cond_3,cond_4,cond_5),cond_6) \
/* 'OU' binaire a 9 conditions (introduit le 20170612113542). */
#define I6ET(cond_1,cond_2,cond_3,cond_4,cond_5,cond_6) \
IFET(I5ET(cond_1,cond_2,cond_3,cond_4,cond_5),cond_6) \
/* 'ET' binaire a 9 conditions (introduit le 20170612113542). */
#define I7OU(cond_1,cond_2,cond_3,cond_4,cond_5,cond_6,cond_7) \
IFOU(I6OU(cond_1,cond_2,cond_3,cond_4,cond_5,cond_6),cond_7) \
/* 'OU' binaire a 9 conditions (introduit le 20170612113542). */
#define I7ET(cond_1,cond_2,cond_3,cond_4,cond_5,cond_6,cond_7) \
IFET(I6ET(cond_1,cond_2,cond_3,cond_4,cond_5,cond_6),cond_7) \
/* 'ET' binaire a 9 conditions (introduit le 20170612113542). */
#define I8OU(cond_1,cond_2,cond_3,cond_4,cond_5,cond_6,cond_7,cond_8) \
IFOU(I7OU(cond_1,cond_2,cond_3,cond_4,cond_5,cond_6,cond_7),cond_8) \
/* 'OU' binaire a 9 conditions (introduit le 20170612113542). */
#define I8ET(cond_1,cond_2,cond_3,cond_4,cond_5,cond_6,cond_7,cond_8) \
IFET(I7ET(cond_1,cond_2,cond_3,cond_4,cond_5,cond_6,cond_7),cond_8) \
/* 'ET' binaire a 9 conditions (introduit le 20170612113542). */
#define I9OU(cond_1,cond_2,cond_3,cond_4,cond_5,cond_6,cond_7,cond_8,cond_9) \
IFOU(I8OU(cond_1,cond_2,cond_3,cond_4,cond_5,cond_6,cond_7,cond_8),cond_9) \
/* 'OU' binaire a 9 conditions (introduit le 20170612113542). */
#define I9ET(cond_1,cond_2,cond_3,cond_4,cond_5,cond_6,cond_7,cond_8,cond_9) \
IFET(I8ET(cond_1,cond_2,cond_3,cond_4,cond_5,cond_6,cond_7,cond_8),cond_9) \
/* 'ET' binaire a 9 conditions (introduit le 20170612113542). */
#define I10OU(cond_1,cond_2,cond_3,cond_4,cond_5,cond_6,cond_7,cond_8,cond_9,cond_10) \
IFOU(I9OU(cond_1,cond_2,cond_3,cond_4,cond_5,cond_6,cond_7,cond_8,cond_9),cond_10) \
/* 'OU' binaire a 10 conditions (introduit le 20210701140132). */
#define I10ET(cond_1,cond_2,cond_3,cond_4,cond_5,cond_6,cond_7,cond_8,cond_9,cond_10) \
IFET(I9ET(cond_1,cond_2,cond_3,cond_4,cond_5,cond_6,cond_7,cond_8,cond_9),cond_10) \
/* 'ET' binaire a 10 conditions (introduit le 20210701140132). */
#define IMEQ(x,a,b) \
IFOU(IFEQ(x,a),IFEQ(x,b)) \
/* Test de 'x=a' ou 'x=b'. */
#define IMNE(x,a,b) \
IFET(IFNE(x,a),IFNE(x,b)) \
/* Test de 'x#a' et 'x#b'. */
#define INEQ(x,a,b,c) \
I3OU(IFEQ(x,a),IFEQ(x,b),IFEQ(x,c)) \
/* Test de 'x=a' ou 'x=b' ou 'x=c' (introduit le 20160615104458). */
#define INNE(x,a,b,c) \
I3ET(IFNE(x,a),IFNE(x,b),IFNE(x,c)) \
/* Test de 'x#a' et 'x#b' et 'x#c' (introduit le 20160615104458). */
#define IFEQ_a_peu_pres_absolu(x,a,epsilon) \
IFLE(SOUA(x,a) \
,epsilon \
) \
/* Test absolu de 'x=a' a 'epsilon' pres. On notera que l'on utilise 'IFLE(...)' afin que : */ \
/* */ \
/* IFEQ_a_peu_pres_absolu(x,a,0) == IFEQ(x,a) */ \
/* */
#define IZEQ_a_peu_pres(x,epsilon) \
IFEQ_a_peu_pres_absolu(x,ZERO,epsilon) \
/* Test de 'x=0' a 'epsilon' pres. */
#define IFEQ_a_peu_pres_relatif(x,a,pourcentage) \
IFEQ_a_peu_pres_absolu(x,a,bMUL(pourcentage,MOYE(ABSO(x),ABSO(a)))) \
/* Test relatif de 'x=a' a 'pourcentage' pres (le test est alors fonction de l'ordre de */ \
/* grandeur de la moyenne des valeurs absolues des nombres 'x' et 'a'). On notera que l'on */ \
/* utilise 'IFLE(...)' afin que : */ \
/* */ \
/* IFEQ_a_peu_pres_relatif(x,a,0) == IFEQ(x,a) */ \
/* */ \
/* ATTENTION : un "pourcentage" est un nombre dans [0,1] et non pas dans [0,100]... */ \
/* */ \
/* Avant le 20060417193804, cette definition etait : */ \
/* */ \
/* IFLE(SOUA(x,a) */ \
/* ,MUL2(pourcentage,MOYE(ABSO(x),ABSO(a))) */ \
/* ) */ \
/* */ \
/* Le 20100701170542, je note que 'IFEQ_a_peu_pres_relatif(...)' comparant '|x-a|' a */ \
/* 'p.(|x|+|a|)/2' semble etre un test assez stupide et inutile... */ \
/* */ \
/* Le 20101120092003, 'bMUL(...)' a remplace 'MUL2(...)'. */
/* ATTENTION, le 20050106112944, j'ai voulu definir : */
/* */
/* #define IZEQ_a_peu_pres_relatif(x,pourcentage) \ */
/* IFEQ_a_peu_pres_relatif(x,ZERO,pourcentage) */
/* */
/* ce qui est particulierement stupide car quand on developpe cette defintion, cela */
/* signifie comparer 'ABSO(x)' a une fraction de lui-meme !!! */
#define IFNE_a_peu_pres_absolu(x,a,epsilon) \
IFGT(SOUA(x,a) \
,epsilon \
) \
/* Test absolu de 'x#a' a 'epsilon' pres. On notera que l'on utilise 'IFGT(...)' afin que : */ \
/* */ \
/* IFNE_a_peu_pres_absolu(x,a,0) == IFNE(x,a) */ \
/* */
#define IZNE_a_peu_pres(x,epsilon) \
IFNE_a_peu_pres_absolu(x,ZERO,epsilon) \
/* Test de 'x#0' a 'epsilon' pres. */
#define IFNE_a_peu_pres_relatif(x,a,pourcentage) \
IFNE_a_peu_pres_absolu(x,a,bMUL(pourcentage,MOYE(ABSO(x),ABSO(a)))) \
/* Test relatif de 'x#a' a 'pourcentage' pres (le test est alors fonction de l'ordre de */ \
/* grandeur de la moyenne des valeurs absolues des nombres 'x' et 'a'). On notera que l'on */ \
/* utilise 'IFGT(...)' afin que : */ \
/* */ \
/* IFNE_a_peu_pres_relatif(x,a,0) == IFNE(x,a) */ \
/* */ \
/* ATTENTION : un "pourcentage" est un nombre dans [0,1] et non pas dans [0,100]... */ \
/* */ \
/* Avant le 20060417193804, cette definition etait : */ \
/* */ \
/* IFGT(SOUA(x,a) */ \
/* ,MUL2(pourcentage,MOYE(ABSO(x),ABSO(a))) */ \
/* ) */ \
/* */ \
/* Le 20100701170542, je note que 'IFNE_a_peu_pres_relatif(...)' comparant '|x-a|' a */ \
/* 'p.(|x|+|a|)/2' semble etre un test assez stupide et inutile... */ \
/* */ \
/* Le 20101120092003, 'bMUL(...)' a remplace 'MUL2(...)'. */
/* ATTENTION, le 20050106112944, j'ai voulu definir : */
/* */
/* #define IZNE_a_peu_pres_relatif(x,pourcentage) \ */
/* IFNE_a_peu_pres_relatif(x,ZERO,pourcentage) */
/* */
/* ce qui est particulierement stupide car quand on developpe cette defintion, cela */
/* signifie comparer 'ABSO(x)' a une fraction de lui-meme !!! */
#define IFLT_a_peu_pres_absolu(x,a,epsilon) \
IFLT(x \
,bSOU(a,epsilon) \
) \
/* Test absolu de 'x<a' a 'epsilon' pres (introduit le 20101008121303). */ \
/* */ \
/* Le 20101120092003, 'bSOU(...)' plus logique a remplace 'SOUS(...)'. */
#define IFGT_a_peu_pres_absolu(x,a,epsilon) \
IFGT(x \
,bADD(a,epsilon) \
) \
/* Test absolu de 'x>a' a 'epsilon' pres (introduit le 20101008121303). */ \
/* */ \
/* Le 20101120092003, 'bADD(...)' plus logique a remplace 'ADD2(...)'. */
#define IFEQ_chaine(chaine,chaine1) \
EST_VRAI(chain_compare(chaine,chaine1)) \
/* Test de l'egalite de deux chaines de caracteres. */
#define IMEQ_chaine(chaine,chaine1,chaine2) \
IFOU(IFEQ_chaine(chaine,chaine1),IFEQ_chaine(chaine,chaine2)) \
/* Test de 'chaine=chaine1' ou 'chaine=chaine2', {chaine,chaine1,chaine2} etant des chaines */ \
/* (introduit le 20170717192423...). */
#define IFNE_chaine(chaine,chaine1) \
EST_FAUX(chain_compare(chaine,chaine1)) \
/* Test de la difference de deux chaines de caracteres. */
#define IMNE_chaine(chaine,chaine1,chaine2) \
IFET(IFNE_chaine(chaine,chaine1),IFNE_chaine(chaine,chaine2)) \
/* Test de 'chaine#chaine1' et 'chaine#chaine2', {chaine,chaine1,chaine2} etant des chaines */ \
/* (introduit le 20170717192423...). */
#define IFOUV(condition_1,condition_2) \
TOUJOURS_VRAI \
/* 'OU' binaire ('Test' toujours 'VRAI'...), */
#define IFETV(condition_1,condition_2) \
TOUJOURS_VRAI \
/* 'ET' binaire ('Test' toujours 'VRAI'...). */
#define IFEQV(x,a) \
TOUJOURS_VRAI \
/* Test de 'x=a' ('Test' toujours 'VRAI'...). */
#define IFNEV(x,a) \
TOUJOURS_VRAI \
/* Test de 'x#a' ('Test' toujours 'VRAI'...). */
#define IFGEV(x,a) \
TOUJOURS_VRAI \
/* Test de 'x>=a' ('Test' toujours 'VRAI'...). */
#define IFGTV(x,a) \
TOUJOURS_VRAI \
/* Test de 'x>a' ('Test' toujours 'VRAI'...). */
#define IFLEV(x,a) \
TOUJOURS_VRAI \
/* Test de 'x<=a' ('Test' toujours 'VRAI'...). */
#define IFLTV(x,a) \
TOUJOURS_VRAI \
/* Test de 'x<a' ('Test' toujours 'VRAI'...). */
#define IFOUF(condition_1,condition_2) \
TOUJOURS_FAUX \
/* 'OU' binaire ('Test' toujours 'FAUX'...), */
#define IFETF(condition_1,condition_2) \
TOUJOURS_FAUX \
/* 'ET' binaire ('Test' toujours 'FAUX'...). */
#define IFEQF(x,a) \
TOUJOURS_FAUX \
/* Test de 'x=a' ('Test' toujours 'FAUX'...). */
#define IFNEF(x,a) \
TOUJOURS_FAUX \
/* Test de 'x#a' ('Test' toujours 'FAUX'...). */
#define IFGEF(x,a) \
TOUJOURS_FAUX \
/* Test de 'x>=a' ('Test' toujours 'FAUX'...). */
#define IFGTF(x,a) \
TOUJOURS_FAUX \
/* Test de 'x>a' ('Test' toujours 'FAUX'...). */
#define IFLEF(x,a) \
TOUJOURS_FAUX \
/* Test de 'x<=a' ('Test' toujours 'FAUX'...). */
#define IFLTF(x,a) \
TOUJOURS_FAUX \
/* Test de 'x<a' ('Test' toujours 'FAUX'...). */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* T E S T S S T R I C T S O U N O N S T R I C T S ( D I T S " C O N D I T I O N N E L S " ) : */
/* */
/*************************************************************************************************************************************/
#define IFLc(a,b,le_test_est_strict) \
COND(EST_VRAI(le_test_est_strict),IFLT(a,b),IFLE(a,b)) \
/* Test conditionnel de l'inferiorite (introduit le 20020625105813). */
#define IFGc(a,b,le_test_est_strict) \
COND(EST_VRAI(le_test_est_strict),IFGT(a,b),IFGE(a,b)) \
/* Test conditionnel de la superiorite (introduit le 20020625105813). */
#define IFINcc(x,a,b,le_test_est_strict_a_gauche,le_test_est_strict_a_droite) \
IFET(IFGc(x,a,le_test_est_strict_a_gauche),IFLc(x,b,le_test_est_strict_a_droite)) \
/* Test de 'x E [a,b]', en supposant a<=b (introduit le 20020708180055). */
#define IFEXcc(x,a,b,le_test_est_strict_a_gauche,le_test_est_strict_a_droite) \
IFOU(IFLc(x,a,le_test_est_strict_a_gauche),IFGc(x,b,le_test_est_strict_a_droite)) \
/* Test de 'x E/ [a,b]', en supposant a<=b (introduit le 20020708180055). */
#define INCLcc(x,a,b,le_test_est_strict_a_gauche,le_test_est_strict_a_droite) \
IFINcc(x,MIN2(a,b),MAX2(a,b),le_test_est_strict_a_gauche,le_test_est_strict_a_droite) \
/* Test de 'x E [a,b]', quelles que soient les valeurs de 'a' et 'b' (introduit le */ \
/* 20020708180055). */
#define NINCcc(x,a,b,le_test_est_strict_a_gauche,le_test_est_strict_a_droite) \
IFEXcc(x,MIN2(a,b),MAX2(a,b),le_test_est_strict_a_gauche,le_test_est_strict_a_droite) \
/* Test de 'x E/ [a,b]', quelles que soient les valeurs de 'a' et 'b' (introduit le */ \
/* 20020708180055). */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* O P E R A T E U R S D ' I N C L U S I O N B I N A I R E P A R R A P P O R T A U N F E R M E : */
/* */
/*************************************************************************************************************************************/
#define IFINff(x,a,b) \
IFET(IFGE(x,a),IFLE(x,b)) \
/* Test de 'x E [a,b]', en supposant a<=b (appele 'IFIN(x,a,b)' avant le 20020529130223). */
#define IFEXff(x,a,b) \
IFOU(IFLT(x,a),IFGT(x,b)) \
/* Test de 'x E/ [a,b]', en supposant a<=b (appele 'IFEX(x,a,b)' avant le 20020529130223). */
#define INCLff(x,a,b) \
IFINff(x,MIN2(a,b),MAX2(a,b)) \
/* Test de 'x E [a,b]', quelles que soient les valeurs de 'a' et 'b' (appele 'INCL(x,a,b)' */ \
/* avant le 20020529130223). */
#define NINCff(x,a,b) \
IFEXff(x,MIN2(a,b),MAX2(a,b)) \
/* Test de 'x E/ [a,b]', quelles que soient les valeurs de 'a' et 'b' (appele 'NINC(x,a,b)' */ \
/* avant le 20020529130223). */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* O P E R A T E U R S D ' I N C L U S I O N B I N A I R E P A R R A P P O R T A U N O U V E R T : */
/* */
/*************************************************************************************************************************************/
#define IFINoo(x,a,b) \
IFET(IFGT(x,a),IFLT(x,b)) \
/* Test de 'x E ]a,b[', en supposant a<=b. */
#define IFEXoo(x,a,b) \
IFOU(IFLE(x,a),IFGE(x,b)) \
/* Test de 'x E/ ]a,b[', en supposant a<=b. */
#define INCLoo(x,a,b) \
IFINoo(x,MIN2(a,b),MAX2(a,b)) \
/* Test de 'x E ]a,b[', quelles que soient les valeurs de 'a' et 'b'... */
#define NINCoo(x,a,b) \
IFEXoo(x,MIN2(a,b),MAX2(a,b)) \
/* Test de 'x E/ ]a,b[', quelles que soient les valeurs de 'a' et 'b'... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* O P E R A T E U R S D ' I N C L U S I O N B I N A I R E P A R R A P P O R T */
/* A U N " O U V E R T / F E R M E " : */
/* */
/*************************************************************************************************************************************/
#define IFINof(x,a,b) \
IFET(IFGT(x,a),IFLE(x,b)) \
/* Test de 'x E ]a,b]', en supposant a<=b. */
#define IFEXof(x,a,b) \
IFOU(IFLE(x,a),IFGT(x,b)) \
/* Test de 'x E/ ]a,b]', en supposant a<=b. */
#define INCLof(x,a,b) \
IFINof(x,MIN2(a,b),MAX2(a,b)) \
/* Test de 'x E ]a,b]', quelles que soient les valeurs de 'a' et 'b'... */
#define NINCof(x,a,b) \
IFEXof(x,MIN2(a,b),MAX2(a,b)) \
/* Test de 'x E/ ]a,b]', quelles que soient les valeurs de 'a' et 'b'... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* O P E R A T E U R S D ' I N C L U S I O N B I N A I R E P A R R A P P O R T */
/* A U N " F E R M E / O U V E R T " : */
/* */
/*************************************************************************************************************************************/
#define IFINfo(x,a,b) \
IFET(IFGE(x,a),IFLT(x,b)) \
/* Test de 'x E [a,b[', en supposant a<=b. */
#define IFEXfo(x,a,b) \
IFOU(IFLT(x,a),IFGE(x,b)) \
/* Test de 'x E/ [a,b[', en supposant a<=b. */
#define INCLfo(x,a,b) \
IFINfo(x,MIN2(a,b),MAX2(a,b)) \
/* Test de 'x E [a,b[', quelles que soient les valeurs de 'a' et 'b'... */
#define NINCfo(x,a,b) \
IFEXfo(x,MIN2(a,b),MAX2(a,b)) \
/* Test de 'x E/ [a,b[', quelles que soient les valeurs de 'a' et 'b'... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* O P E R A T E U R S D E T E S T D ' I D E N T I T E D E D E U X O B J E T S : */
/* */
/*************************************************************************************************************************************/
#define aIFID(objet1,objet2) \
IFEQ(aIDENTITE(objet1),aIDENTITE(objet2)) \
/* Test de l'identite "directe" de deux objets. */
#define aIFDI(objet1,objet2) \
IFNE(aIDENTITE(objet1),aIDENTITE(objet2)) \
/* Test de la difference "directe" de deux objets. */
/* ATTENTION, on peut etre amene a "caster" 'objet1' et/ou 'objet2' car, en effet, on ne */
/* peut comparer que des pointeurs de meme nature ('v $xrv/champs_5.14$I'). */
#define IFID(objet1,objet2) \
IFEQ(IDENTITE(objet1),IDENTITE(objet2)) \
/* Test de l'identite "indirecte" de deux objets. */
#define IFDI(objet1,objet2) \
IFNE(IDENTITE(objet1),IDENTITE(objet2)) \
/* Test de la difference "indirecte" de deux objets. */
/* ATTENTION, on peut etre amene a "caster" 'objet1' et/ou 'objet2' car, en effet, on ne */
/* peut comparer que des pointeurs de meme nature ('v $xrv/champs_5.14$I'). */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* C O N S T A N T E S L O G I Q U E S : */
/* */
/*************************************************************************************************************************************/
#define k___FAUX \
IFNE(ZERO,ZERO) \
/* Definition du faux. ATTENTION, autrefois on utilisait : */ \
/* */ \
/* LOGI(ZERO) */ \
/* */ \
/* Cette nouvelle version est beaucoup plus sure et generale... */ \
/* */ \
/* ATTENTION : la constante 'FAUX' est pre-generee dans '$xcp/Konstantes$K'. */
#define k___VRAI \
IFEQ(ZERO,ZERO) \
/* Definition du vrai. ATTENTION, autrefois on utilisait : */ \
/* */ \
/* LOGI(OUEX(FAUX,BIT)) */ \
/* */ \
/* (le 'NOTL(...)' etant inutilisable pour des raisons de recursivite...) */ \
/* */ \
/* Cette nouvelle version est beaucoup plus sure et generale... */ \
/* */ \
/* ATTENTION : la constante 'VRAI' est pre-generee dans '$xcp/Konstantes$K'. */
#define k___INDECIS \
ADD2(ADD2(FAUX,FAUX),ADD2(VRAI,VRAI)) \
/* Definition de l'indecis defini de facon a etre du type 'Logical' (c'est-a-dire un */ \
/* entier positif), mais different evidemment de 'FAUX' et de 'VRAI'. Cela a ete introduit */ \
/* le 20180107171545... */
#define k___NEXIST \
FAUX \
/* Ce qui n'existe pas. */ \
/* */ \
/* ATTENTION : la constante 'NEXIST' est pre-generee dans '$xcp/Konstantes$K'. */
#define k___EXIST \
NOTL(k___NEXIST) \
/* Ce qui existe. */ \
/* */ \
/* ATTENTION : la constante 'EXIST' est pre-generee dans '$xcp/Konstantes$K'. */
#define k___INACTIF \
NEXIST \
/* Pour caracteriser ce qui est inactif, */ \
/* */ \
/* ATTENTION : la constante 'INACTIF' est pre-generee dans '$xcp/Konstantes$K'. */
#define k___ACTIF \
EXIST \
/* Et ce qui est actif. */ \
/* */ \
/* ATTENTION : la constante 'ACTIF' est pre-generee dans '$xcp/Konstantes$K'. */
#define k___INTERDIT \
NEXIST \
/* Pour caracteriser ce qui est interdit, */ \
/* */ \
/* ATTENTION : la constante 'INTERDIT' est pre-generee dans '$xcp/Konstantes$K'. */
#define k___AUTORISE \
EXIST \
/* Et ce qui est autorise. */ \
/* */ \
/* ATTENTION : la constante 'AUTORISE' est pre-generee dans '$xcp/Konstantes$K'. */
#define k___INVALIDE \
NEXIST \
/* Pour caracteriser ce qui est invalide, */ \
/* */ \
/* ATTENTION : la constante 'INVALIDE' est pre-generee dans '$xcp/Konstantes$K'. */
#define k___VALIDE \
EXIST \
/* Et ce qui est valide. */ \
/* */ \
/* ATTENTION : la constante 'VALIDE' est pre-generee dans '$xcp/Konstantes$K'. */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* " P R E - G E N E R A T I O N " D E S C O N S T A N T E S F O N D A M E N T A L E S : */
/* */
/*************************************************************************************************************************************/
#TestADef FAUX \
k___FAUX
#TestADef VRAI \
k___VRAI
#TestADef INDECIS \
k___INDECIS
#TestADef NEXIST \
k___NEXIST
#TestADef EXIST \
k___EXIST
#TestADef INACTIF \
k___INACTIF
#TestADef ACTIF \
k___ACTIF
#TestADef INTERDIT \
k___INTERDIT
#TestADef AUTORISE \
k___AUTORISE
#TestADef INVALIDE \
k___INVALIDE
#TestADef VALIDE \
k___VALIDE
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* C O N S T R U C T I O N S L O G I Q U E S S T A N D A R D S : */
/* */
/*************************************************************************************************************************************/
#define IL_FAUT(x) \
IFEQ(x,VRAI)
#define IL_NE_FAUT_PAS(x) \
IFEQ(x,FAUX)
#define EST_VRAI(x) \
IFEQ(x,VRAI)
#define EST_FAUX(x) \
IFEQ(x,FAUX)
#define EST_INDECIS(x) \
IFEQ(x,INDECIS)
#define EST_CERTAIN(x) \
IFNE(x,INDECIS)
#define EST_LOGIQUE(x) \
IFOU(EST_VRAI(x),EST_FAUX(x))
#define N_EST_PAS_LOGIQUE(x) \
NOTL(EST_LOGIQUE(x))
#define PRESENT(x) \
IFEQ(x,EXIST)
#define PAS_PRESENT(x) \
IFEQ(x,NEXIST)
#define ABSENT(x) \
PAS_PRESENT(x)
#define EST_ACTIF(x) \
IFEQ(x,ACTIF)
#define EST_INACTIF(x) \
IFEQ(x,INACTIF)
#define EST_AUTORISE(x) \
IFEQ(x,AUTORISE)
#define EST_INTERDIT(x) \
IFEQ(x,INTERDIT)
#define EST_VALIDE(x) \
IFEQ(x,VALIDE)
#define EST_INVALIDE(x) \
IFEQ(x,INVALIDE)
#define PAS_D_ERREUR(f) \
IFEQ(f,OK) \
/* ATTENTION : a la difference entre 'PAS_D_ERREUR' et 'PAS_D_ERRORS'... */
#define IL_Y_A_ERREUR(f) \
IFNE(f,OK) \
/* ATTENTION : a la difference entre 'IL_Y_A_ERREUR' et 'IL_Y_A_ERRORS'... */
#define PAS_D_ERRORS(f) \
IFGE(f,OK) \
/* ATTENTION : a la difference entre 'PAS_D_ERREUR' et 'PAS_D_ERRORS'... */
#define IL_Y_A_ERRORS(f) \
IFLT(f,OK) \
/* ATTENTION : a la difference entre 'IL_Y_A_ERREUR' et 'IL_Y_A_ERRORS'... */
#define PAS_DE_PROBLEMES(f) \
IFNE(f,PROBLEMES)
#define IL_Y_A_PROBLEMES(f) \
IFEQ(f,PROBLEMES)
#define BASE_DE_PARITE \
DEUX \
/* Introduit le 20130110104955 pour 'v $xrk/Goldbach.01$K BASE_DE_PARITE'... */
#define EST_PAIR(x) \
IFEQ(PARI(x),PARI(BASE_DE_PARITE))
#define EST_IMPAIR(x) \
IFNE(PARI(x),PARI(BASE_DE_PARITE))
#define fEST_PAIR(x) \
IZEQ(fREST(x,FLOT(BASE_DE_PARITE)))
#define fEST_IMPAIR(x) \
IZNE(fREST(x,FLOT(BASE_DE_PARITE)))
/* Introduits le 20110308090400 pour 'v $ximf/nombres$FON 20110308090607' afin de pouvoir */
/* tester la parite d'un nombre entier represente par un 'Float'. On notera que cela fut */
/* valide grace a 'v $xtc/fmod.02$c'. */
-define IZLT(x) \
-_-_-_- IFLT(x,ZERO)
/* Test 'x' negatif strictement. */
-define IZLE(x) \
-_-_-_- IFLE(x,ZERO)
/* Test 'x' negatif ou nul. */
-define IZEQ(x) \
-_-_-_- IFEQ(x,ZERO)
/* Test 'x' nul. */
-define IZNE(x) \
-_-_-_- IFNE(x,ZERO)
/* Test 'x' non nul. */
-define IZGE(x) \
-_-_-_- IFGE(x,ZERO)
/* Test 'x' positif ou nul. */
-define IZGT(x) \
-_-_-_- IFGT(x,ZERO)
/* Test 'x' positif strictement. */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* S T R U C T U R E S D E T E S T F L O U : */
/* */
/*************************************************************************************************************************************/
#define fFAUX \
COORDONNEE_BARYCENTRIQUE_MINIMALE \
/* Valeur materialisant le 'FAUX' flou, */
#define fVRAI \
COORDONNEE_BARYCENTRIQUE_MAXIMALE \
/* Valeur materialisant le 'VRAI' flou. */
#define SEUIL_DE_LA_LOGIQUE_FLOUE \
MOYE(fFAUX,fVRAI) \
/* Les variables de la logique floue sont des variables reelles a valeur dans [0,1], */ \
/* le '0' etant le 'FAUX', et '1' etant le 'VRAI'. 'SEUIL_DE_LA_LOGIQUE_FLOUE' est la */ \
/* limite implicite entre le 'FAUX' et le 'VRAI'... */
#define fTest(conditions) \
BblockV \
Test(IFGE(conditions,SEUIL_DE_LA_LOGIQUE_FLOUE)) \
Bblock \
/* On fait preceder le "if" d'un debut de block, afin que la fin du "fTest" */ \
/* (c'est-a-dire le "EfTes") puisse etre valide par le compilateur ; en */ \
/* effet, s'il s'agissait d'une instruction vide, son absence ne serait */ \
/* pas diagnostiquee. On notera aussi la dissymetrie au niveau des 'Bblock'/'Eblock' entre */ \
/* 'AfTes' et 'EfTes', et ce afin de rendre obligatoire le triplet (fTest,AfTes,EfTes). */
#define AfTes \
Eblock \
ATes \
Bblock \
BblockV \
/* Alternative du 'fTest'. */
#define EfTes \
EblockV \
Eblock \
ETes \
EblockV \
/* Fin du 'fTest'. */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* O P E R A T E U R S S E C O N D A I R E S D E L A L O G I Q U E F L O U E : */
/* */
/*************************************************************************************************************************************/
#define MODULATEUR_DE_LA_LOGIQUE_FLOUE \
FU \
/* Constante materialisee par la lettre 'k' dans les formules qui suivront, et qui */ \
/* permet de "resserer" plus ou moins la zone de flou, au voisinage de la valeur reelle */ \
/* 'SEUIL_DE_LA_LOGIQUE_FLOUE'... */
#define fD(a,b) \
DIVI(SOUS(b,a) \
,RACX(ADD2(FU,FU)) \
) \
/* Distance signee d'un point de coordonnees (a,b) a la premiere bissectrice y=x : */ \
/* */ \
/* b - a */ \
/* d(a,b) = ------- */ \
/* --- */ \
/* \/ 2 */ \
/* */ \
/* */ \
/* y ^ */ \
/* | + */ \
/* . | + */ \
/* * point (a,b) | + y=x (premiere bissectrice) */ \
/* y > x . | + */ \
/* d > 0 . | + */ \
/* . | + */ \
/* . | + */ \
/* ----------------------.-------O----------------------------> */ \
/* . + | x */ \
/* + | */ \
/* + . | */ \
/* + . */ \
/* + | . y < x */ \
/* + | . d < 0 */ \
/* + | . */ \
/* */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* O P E R A T E U R S D E T E S T F L O U : */
/* */
/*************************************************************************************************************************************/
#define fNOTL(x) \
ADD2(fFAUX \
,PUIX(SOUS(fVRAI,x) \
,DIVI(LOGX(SOUS(SEUIL_DE_LA_LOGIQUE_FLOUE,fFAUX)) \
,LOGX(SOUS(fVRAI,SEUIL_DE_LA_LOGIQUE_FLOUE)) \
) \
) \
) \
/* Negation floue de 'x' : */ \
/* */ \
/* Log(S) */ \
/* ---------- */ \
/* Log(1-S) */ \
/* fNOTL(x) = (1 - x) */ \
/* */ \
/* */ \
/* fNOTL(x) ^ */ \
/* | */ \
/* 1 * */ \
/* | fNOTL(1) = 0 */ \
/* | fNOTL(S) = S */ \
/* |* fNOTL(0) = 1 */ \
/* | */ \
/* | */ \
/* | * */ \
/* | */ \
/* | * */ \
/* S |....* */ \
/* | . * */ \
/* | . * */ \
/* ------------------------------O----------------*-----------> */ \
/* | S 1 x */ \
/* */
#define fIFOU(condition_1,condition_2) \
MAX2(condition_1,condition_2) \
/* 'OU' flou, */
#define fIFET(condition_1,condition_2) \
MIN2(condition_1,condition_2) \
/* 'ET' flou. */
#define fIFEQ(x,a) \
ADD2(fFAUX \
,MUL2(SOUS(fVRAI,fFAUX) \
,EXPX(NEGA(MUL2(MODULATEUR_DE_LA_LOGIQUE_FLOUE \
,EXP2(fD(x,a)) \
) \
) \
) \
) \
) \
/* Test de 'x=a' : */ \
/* */ \
/* 2 */ \
/* -k.d(x,a) */ \
/* fIFEQ(x,a) = e */ \
/* */ \
/* */ \
/* fIFEQ(x,a) ^ */ \
/* | x = a */ \
/* | . */ \
/* | . */ \
/* |. */ \
/* 1 * */ \
/* *|* */ \
/* | */ \
/* * | * */ \
/* * | * */ \
/* * | * */ \
/* * | * */ \
/* * | * */ \
/* x # a * | * x # a */ \
/* * | * */ \
/* * * * * * | * * * * * */ \
/* ------------------------------O----------------------------> */ \
/* | d(x,a) */ \
/* */
#define fIFNE(x,a) \
fNOTL(fIFEQ(x,a)) \
/* Test de 'x#a'. */
#define fIFGE(x,a) \
ADD2(fFAUX \
,MUL2(SOUS(fVRAI,fFAUX) \
,DIVI(MUL2(SEUIL_DE_LA_LOGIQUE_FLOUE \
,EXPX(NEGA(MUL2(MODULATEUR_DE_LA_LOGIQUE_FLOUE,fD(x,a)))) \
) \
,BARY(EXPX(NEUT(MUL2(MODULATEUR_DE_LA_LOGIQUE_FLOUE,fD(x,a)))) \
,EXPX(NEGA(MUL2(MODULATEUR_DE_LA_LOGIQUE_FLOUE,fD(x,a)))) \
,SEUIL_DE_LA_LOGIQUE_FLOUE \
) \
) \
) \
) \
/* Test de 'x>=a' : */ \
/* */ \
/* -k.d(x,a) */ \
/* S.e */ \
/* fIFGE(x,a) = --------------------------------- */ \
/* +k.d(x,a) -k.d(x,a) */ \
/* (1-S).e + S.e */ \
/* */ \
/* */ \
/* fIFGE(x,a) ^ */ \
/* | */ \
/* - - - - - - - - - - - - - - - 1 - - - - - - - - - - - - - - */ \
/* * * * * | */ \
/* * | */ \
/* x > a * | */ \
/* * | x = a */ \
/* | . */ \
/* * | . */ \
/* |. */ \
/* S * */ \
/* | x < a */ \
/* | * */ \
/* | * * * * * * * * */ \
/* ------------------------------O----------------------------> */ \
/* | d(x,a) */ \
/* */
#define fIFGT(x,a) \
fIFGE(x,a) \
/* Test de 'x>a'. */
#define fIFLT(x,a) \
fNOTL(fIFGE(x,a)) \
/* Test de 'x<a'. */
#define fIFLE(x,a) \
fIFLT(x,a) \
/* Test de 'x<=a'. */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* C O N S T R U C T E U R S D ' I T E R A T I O N S : */
/* */
/*************************************************************************************************************************************/
#define DoQu(index,index_de_depart,index_d_arrivee,pas_index) \
BblockV \
DEFV(Int,INIT(pas_index_effectif,pas_index)); \
/* Introduit le 20110908103354 suite a un probleme avec 'v $xci/genere$K pas_des_images' */ \
/* dans 'v $Falias_execALBUM 20110908102935' ou le '$xci/genere$X' avait recu "pas=0"... */ \
\
Test(IZEQ(pas_index_effectif)) \
Bblock \
EGAL(pas_index_effectif,I); \
PRINT_ATTENTION("une boucle a un pas nul et une valeur par defaut est forcee pour eviter une division par 0"); \
CAL1(Prer1("(pas force pour la boucle : %d)\n",pas_index_effectif)); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
\
Test(NON_DIVISIBLE(bSOU(index_d_arrivee,index_de_depart) \
,MEME_SIGNE_QUE(bSOU(index_d_arrivee,index_de_depart),pas_index_effectif) \
) \
) \
/* ATTENTION ; ce sont bien deux 'SOUS(...)' qu'il faut ci-dessus et non pas des 'NBRE(...)' */ \
/* car il s'agit ici d'un probleme de piquets et d'intervalles. A titre d'exemple, il est */ \
/* bien exact que l'on ne peut aller de 1 a 512 par pas de 8 (par contre un pas de 7 est */ \
/* bon...). */ \
Bblock \
Test(IL_FAUT(DoQu_____editer_le_message_d_une_possible_boucle_infinie)) \
/* Test introduit le 20120419143132... */ \
Bblock \
PRINT_ATTENTION("une boucle 'DoQu' risque de ne pas se terminer"); \
CAL1(Prer3("(depart,arrivee,pas) = (%g,%g,%g)\n" \
,FLOT(index_de_depart),FLOT(index_d_arrivee),FLOT(pas_index_effectif) \
) \
); \
/* On notera l'utilisation de 'FLOT(...)' pour permettre une utilisation valide de "%g" ; on */ \
/* permet ainsi tous les types possibles pour les bornes de l'index. Malgre tout, cela est */ \
/* certainement inutile car 'DIVISIBLE(...)' utilise 'REST(...)' qui doit n'etre utilisable */ \
/* qu'avec des arguments 'Int'... */ \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
\
Bouc(INIT(index,index_de_depart) \
,IFOU(IFET(IFLE(index_de_depart,index_d_arrivee),IFLE(index,index_d_arrivee)) \
,IFET(IFGT(index_de_depart,index_d_arrivee),IFGE(index,index_d_arrivee)) \
) \
,INCR(index,MEME_SIGNE_QUE(bSOU(index_d_arrivee,index_de_depart),pas_index_effectif)) \
) \
/* DoQu : iteration avec ordre indifferent des bornes, le test d'arret se faisant sur une */ \
/* egalite ; il faut donc faire attention au relation entre les bornes et le pas (par */ \
/* exemple 'DoQu(n,1,7,4)' ne peut pas se terminer...). */ \
/* */ \
/* Exemple : */ \
/* */ \
/* DoQu(n,1,4,1) */ \
/* */ \
/* genere : */ \
/* */ \
/* n=(1,2,3,4) */ \
/* */ \
/* alors que : */ \
/* */ \
/* DoQu(n,4,1,1) */ \
/* */ \
/* genere : */ \
/* */ \
/* n=(4,3,2,1) */ \
/* */ \
/* ATTENTION : on fait preceder le "DoQu" d'un debut de block, afin que la fin du "for" */ \
/* (c'est-a-dire le "EDoQ") puisse etre valide par le compilateur ; en */ \
/* effet, s'il s'agissait d'une instruction vide, son absence ne serait */ \
/* pas diagnostiquee !!! */ \
Bblock
#define EDoQ \
Eblock \
EblockV
#define DoIn(index,minimum_index,maximum_index,pas_index) \
BblockV \
Bouc(INIT(index,minimum_index),IFLE(index,maximum_index),INCR(index,pas_index)) \
/* DoIn : iteration incrementale... */ \
/* */ \
/* Exemple : */ \
/* */ \
/* DoIn(n,1,4,1) */ \
/* */ \
/* genere : */ \
/* */ \
/* n=(1,2,3,4) */ \
/* */ \
/* ATTENTION : on fait preceder le "DoIn" d'un debut de block, afin que la fin du "for" */ \
/* (c'est-a-dire le "EDoI") puisse etre valide par le compilateur ; en */ \
/* effet, s'il s'agissait d'une instruction vide, son absence ne serait */ \
/* pas diagnostiquee !!! */ \
/* */ \
/* ATTENTION : a la fin de la boucle (apres le 'EDoI'), on a : */ \
/* */ \
/* index = maximum_index+pas_index si : minimum_index <= maximum_index */ \
/* index = minimum_index si : minimum_index > maximum_index */ \
/* */ \
Bblock
#define EDoI \
Eblock \
EblockV
#define IDoIn(index,minimum_index,maximum_index,pas_index) \
Bblock \
DEFV(Int,INIT(index,UNDEF)); \
DoIn(index,minimum_index,maximum_index,pas_index)
#define EIDoI \
EDoI \
Eblock
/* IDoIn : iteration incrementale avec declaration automatique de l'index de type 'Int'. */
/* Ceci fut introduit le 20060602110719... */
#define FDoIn(index,minimum_index,maximum_index,pas_index) \
Bblock \
DEFV(Float,INIT(index,FLOT__UNDEF)); \
DoIn(index,minimum_index,maximum_index,pas_index)
#define EFDoI \
EDoI \
Eblock
/* FDoIn : iteration incrementale avec declaration automatique de l'index de type 'Float'. */
/* Ceci fut introduit le 20060602110719... */
#define DoDe(index,minimum_index,maximum_index,pas_index) \
BblockV \
Bouc(INIT(index,maximum_index),IFGE(index,minimum_index),DECR(index,pas_index)) \
/* DoDe : iteration decrementale... */ \
/* */ \
/* Exemple : */ \
/* */ \
/* DoDe(n,1,4,1) */ \
/* */ \
/* genere : */ \
/* */ \
/* n=(4,3,2,1) */ \
/* */ \
/* ATTENTION : on fait preceder le "DoDe" d'un debut de block, afin que la fin du "for" */ \
/* (c'est-a-dire le "EDoD") puisse etre valide par le compilateur ; en */ \
/* effet, s'il s'agissait d'une instruction vide, son absence ne serait */ \
/* pas diagnostiquee !!! */ \
/* */ \
/* ATTENTION : a la fin de la boucle (apres le 'EDoD'), on a : */ \
/* */ \
/* index = minimum_index-pas_index si : minimum_index <= maximum_index */ \
/* index = maximum_index si : minimum_index > maximum_index */ \
/* */ \
Bblock
#define EDoD \
Eblock \
EblockV
#define IDoDe(index,minimum_index,maximum_index,pas_index) \
Bblock \
DEFV(Int,INIT(index,UNDEF)); \
DoDe(index,minimum_index,maximum_index,pas_index)
#define EIDoD \
EDoD \
Eblock
/* IDoDe : iteration decrementale avec declaration automatique de l'index de type 'Int'. */
/* Ceci fut introduit le 20060602110719... */
#define FDoDe(index,minimum_index,maximum_index,pas_index) \
Bblock \
DEFV(Float,INIT(index,FLOT__UNDEF)); \
DoDe(index,minimum_index,maximum_index,pas_index)
#define EFDoD \
EDoD \
Eblock
/* FDoDe : iteration decrementale avec declaration automatique de l'index de type 'Float'. */
/* Ceci fut introduit le 20060602110719... */
#define DoVa(index,minimum_index,maximum_index,pas_index,il_faut_incrementer) \
BblockV \
Bouc(INIT(index \
,COND(EST_VRAI(il_faut_incrementer) \
,minimum_index \
,maximum_index \
) \
) \
,IFOU(IFET(EST_VRAI(il_faut_incrementer) \
,IFLE(index,maximum_index) \
) \
,IFET(EST_FAUX(il_faut_incrementer) \
,IFGE(index,minimum_index) \
) \
) \
,INCR(index \
,COND(EST_VRAI(il_faut_incrementer) \
,NEUT(pas_index) \
,NEGA(pas_index) \
) \
) \
) \
/* DoVa : iteration incrementale ou decrementale ("Variable")... */ \
/* */ \
/* ATTENTION : on fait preceder le "DoVa" d'un debut de block, afin que la fin du "for" */ \
/* (c'est-a-dire le "EDoV") puisse etre valide par le compilateur ; en */ \
/* effet, s'il s'agissait d'une instruction vide, son absence ne serait */ \
/* pas diagnostiquee !!! */ \
/* */ \
/* Ceci fut introduit le 20070906140106 pour 'v $xrv/polynome.01$K DoVa'... */ \
/* */ \
/* On notera qu'il est impossible d'ecrire : */ \
/* */ \
/* COND(EST_VRAI(il_faut_incrementer) */ \
/* ,INCR(index,pas_index) */ \
/* ,DECR(index,pas_index) */ \
/* ) */ \
/* */ \
/* par definition de 'Bouc(...)'. */ \
/* */ \
/* En resume, 'DoVa' equivaut a : */ \
/* */ \
/* DoIn(...) si 'EST_VRAI(il_faut_incrementer)' */ \
/* DoDe(...) si 'EST_FAUX(il_faut_incrementer)' */ \
/* */ \
Bblock
#define EDoV \
Eblock \
EblockV
#define IDoVa(index,minimum_index,maximum_index,pas_index,incrementer) \
Bblock \
DEFV(Int,INIT(index,UNDEF)); \
DoVa(index,minimum_index,maximum_index,pas_index,incrementer)
#define EIDoV \
EDoV \
Eblock
/* IDoVa : iteration "Variable" avec declaration automatique de l'index de type 'Int'. */
/* Ceci fut introduit le 20070906140106... */
#define FDoVa(index,minimum_index,maximum_index,pas_index,incrementer) \
Bblock \
DEFV(Float,INIT(index,FLOT__UNDEF)); \
DoVa(index,minimum_index,maximum_index,pas_index,incrementer)
#define EFDoV \
EDoV \
Eblock
/* FDoVa : iteration "Variable" avec declaration automatique de l'index de type 'Float'. */
/* Ceci fut introduit le 20070906140106... */
#if ( (defined(SYSTEME_SG4D20G_IRIX_CC)) \
|| (defined(SYSTEME_SG4D25TG_IRIX_CC)) \
|| (defined(SYSTEME_SG4D310VGX_IRIX_CC)) \
|| (defined(SYSTEME_SG4D35TG_IRIX_CC)) \
|| (defined(SYSTEME_SG4D85GT_IRIX_CC)) \
|| (defined(SYSTEME_SGIND308_IRIX_CC)) \
|| (defined(SYSTEME_SGIND324_IRIX_CC)) \
|| (defined(SYSTEME_SGIND3GA_IRIX_CC)) \
|| (defined(SYSTEME_SGIND408_IRIX_CC)) \
|| (defined(SYSTEME_SGIND424_IRIX_CC)) \
|| (defined(SYSTEME_SGIND4GA_IRIX_CC)) \
|| (defined(SYSTEME_SGIND508_IRIX_CC)) \
|| (defined(SYSTEME_SGIND524_IRIX_CC)) \
|| (defined(SYSTEME_SGIND5GA_IRIX_CC)) \
|| (defined(SYSTEME_SGIND808_IRIX_CC)) \
|| (defined(SYSTEME_SGIND824_IRIX_CC)) \
|| (defined(SYSTEME_SGIND8GA_IRIX_CC)) \
|| (defined(SYSTEME_SGINDA08_IRIX_CC)) \
|| (defined(SYSTEME_SGINDA24_IRIX_CC)) \
|| (defined(SYSTEME_SGINDAGA_IRIX_CC)) \
|| (defined(SYSTEME_SGO200A1_IRIX_CC)) \
|| (defined(SYSTEME_SGO200A2_IRIX_CC)) \
|| (defined(SYSTEME_SGO200A4_IRIX_CC)) \
|| (defined(SYSTEME_SGO25224_IRIX_CC)) \
|| (defined(SYSTEME_SGO252VA_IRIX_CC)) \
|| (defined(SYSTEME_SGO252VN_IRIX_CC)) \
|| (defined(SYSTEME_SGPCM801_IRIX_CC)) \
|| (defined(SYSTEME_SGPCMA01_IRIX_CC)) \
)
# define Loop \
/* ATTENTION : on n'utilise pas ici le couple ('BblockV','EblockV') car en effet sur */ \
/* certains systemes, il est vide ; or ici, dans la mesure ou l'on redefinit des variables */ \
/* locales, il est absoluement necessaire que ce couple soit equivalent au couple */ \
/* ('Bblock','Eblock')... */ \
Bblock \
DEFV(Logical,INIT(controleur_du_Loop,VRAI)); \
/* Variable toujours VRAI... */ \
Tant(EST_VRAI(controleur_du_Loop)) \
/* On fait preceder le "Loop" d'un debut de block, afin que la fin du "Tant" */ \
/* (c'est-a-dire le "ELoo") puisse etre valide par le compilateur ; en */ \
/* effet, s'il s'agissait d'une instruction vide, son absence ne serait */ \
/* pas diagnostiquee !!! D'autre part, le compilateur de 'SYSTEME_SG4D..._IRIX_CC' */ \
/* n'accepte pas les boucles infinies (par 'for ( ; ; )') et donne un mesage : */ \
/* "uopt: Warning: xxxx: part(s) of procedure have no exit point", d'ou ce subterfuge... */ \
/* ATTENTION : on notera que ce defaut n'apparait pas sur le 'SYSTEME_NWS3000_NEWSOS_CC' */ \
/* ni sur 'SYSTEME_NWS3000_NEWSOS_2CC', ce qui est paradoxal, puisque theoriquement, il */ \
/* s'agit la du meme compilateur (d'origine 'Mips'). */ \
Bblock
# define ELoo \
Eblock \
/* ATTENTION : on n'utilise pas ici le couple ('BblockV','EblockV') car en effet sur */ \
/* certains systemes, il est vide ; or ici, dans la mesure ou l'on redefinit des variables */ \
/* locales, il est absoluement necessaire que ce couple soit equivalent au couple */ \
/* ('Bblock','Eblock')... */ \
ETan \
Eblock
#Aif ( (defined(SYSTEME_SG4D20G_IRIX_CC)) \
|| (defined(SYSTEME_SG4D25TG_IRIX_CC)) \
|| (defined(SYSTEME_SG4D310VGX_IRIX_CC)) \
|| (defined(SYSTEME_SG4D35TG_IRIX_CC)) \
|| (defined(SYSTEME_SG4D85GT_IRIX_CC)) \
|| (defined(SYSTEME_SGIND308_IRIX_CC)) \
|| (defined(SYSTEME_SGIND324_IRIX_CC)) \
|| (defined(SYSTEME_SGIND3GA_IRIX_CC)) \
|| (defined(SYSTEME_SGIND408_IRIX_CC)) \
|| (defined(SYSTEME_SGIND424_IRIX_CC)) \
|| (defined(SYSTEME_SGIND4GA_IRIX_CC)) \
|| (defined(SYSTEME_SGIND508_IRIX_CC)) \
|| (defined(SYSTEME_SGIND524_IRIX_CC)) \
|| (defined(SYSTEME_SGIND5GA_IRIX_CC)) \
|| (defined(SYSTEME_SGIND808_IRIX_CC)) \
|| (defined(SYSTEME_SGIND824_IRIX_CC)) \
|| (defined(SYSTEME_SGIND8GA_IRIX_CC)) \
|| (defined(SYSTEME_SGINDA08_IRIX_CC)) \
|| (defined(SYSTEME_SGINDA24_IRIX_CC)) \
|| (defined(SYSTEME_SGINDAGA_IRIX_CC)) \
|| (defined(SYSTEME_SGO200A1_IRIX_CC)) \
|| (defined(SYSTEME_SGO200A2_IRIX_CC)) \
|| (defined(SYSTEME_SGO200A4_IRIX_CC)) \
|| (defined(SYSTEME_SGO25224_IRIX_CC)) \
|| (defined(SYSTEME_SGO252VA_IRIX_CC)) \
|| (defined(SYSTEME_SGO252VN_IRIX_CC)) \
|| (defined(SYSTEME_SGPCM801_IRIX_CC)) \
|| (defined(SYSTEME_SGPCMA01_IRIX_CC)) \
)
# define Loop \
BblockV \
Bouc(VIDE,EST_VRAI(VRAI),VIDE) \
/* On fait preceder le "Loop" d'un debut de block, afin que la fin du "for" */ \
/* (c'est-a-dire le "ELoo") puisse etre valide par le compilateur ; en */ \
/* effet, s'il s'agissait d'une instruction vide, son absence ne serait */ \
/* pas diagnostiquee !!! La sequence 'EST_VRAI(VRAI)' est destinee a eviter l'ecriture */ \
/* 'for ( ; ; )' qui serait fatale a cause de l'adjonction d'une nouvelle commande de */ \
/* pre-processing '$xcp/redondants$X' dans '$xcc/cpp$Z'... */ \
Bblock
# define ELoo \
Eblock \
EblockV
#Eif ( (defined(SYSTEME_SG4D20G_IRIX_CC)) \
|| (defined(SYSTEME_SG4D25TG_IRIX_CC)) \
|| (defined(SYSTEME_SG4D310VGX_IRIX_CC)) \
|| (defined(SYSTEME_SG4D35TG_IRIX_CC)) \
|| (defined(SYSTEME_SG4D85GT_IRIX_CC)) \
|| (defined(SYSTEME_SGIND308_IRIX_CC)) \
|| (defined(SYSTEME_SGIND324_IRIX_CC)) \
|| (defined(SYSTEME_SGIND3GA_IRIX_CC)) \
|| (defined(SYSTEME_SGIND408_IRIX_CC)) \
|| (defined(SYSTEME_SGIND424_IRIX_CC)) \
|| (defined(SYSTEME_SGIND4GA_IRIX_CC)) \
|| (defined(SYSTEME_SGIND508_IRIX_CC)) \
|| (defined(SYSTEME_SGIND524_IRIX_CC)) \
|| (defined(SYSTEME_SGIND5GA_IRIX_CC)) \
|| (defined(SYSTEME_SGIND808_IRIX_CC)) \
|| (defined(SYSTEME_SGIND824_IRIX_CC)) \
|| (defined(SYSTEME_SGIND8GA_IRIX_CC)) \
|| (defined(SYSTEME_SGINDA08_IRIX_CC)) \
|| (defined(SYSTEME_SGINDA24_IRIX_CC)) \
|| (defined(SYSTEME_SGINDAGA_IRIX_CC)) \
|| (defined(SYSTEME_SGO200A1_IRIX_CC)) \
|| (defined(SYSTEME_SGO200A2_IRIX_CC)) \
|| (defined(SYSTEME_SGO200A4_IRIX_CC)) \
|| (defined(SYSTEME_SGO25224_IRIX_CC)) \
|| (defined(SYSTEME_SGO252VA_IRIX_CC)) \
|| (defined(SYSTEME_SGO252VN_IRIX_CC)) \
|| (defined(SYSTEME_SGPCM801_IRIX_CC)) \
|| (defined(SYSTEME_SGPCMA01_IRIX_CC)) \
)
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* T R A N S M I S S I O N D ' U N B L O C D ' I N S T R U C T I O N S : */
/* */
/*************************************************************************************************************************************/
#define BLOC(block) \
block \
/* Permet de transmettre elegamment un bloc d'instructions a une macro. ATTENTION, pour une */ \
/* utilisation en tant qu'argument d'une fonction, il conviendra d'ecrire : */ \
/* */ \
/* #define fonction1(argument1,argument2,...,argumentP,...,argumentN) \ */ \
/* Bblock \ */ \
/* . \ */ \
/* . \ */ \
/* . \ */ \
/* fonction2(argument1 \ */ \
/* ,argument2 \ */ \
/* ,... \ */ \
/* ,BLOC(argumentP) <----------- \ */ \
/* ,... | \ */ \
/* ,argumentN | \ */ \
/* ); | \ */ \
/* . | \ */ \
/* . | \ */ \
/* . | \ */ \
/* BLOC(VIDE;); | \ */ \
/* . | \ */ \
/* . | \ */ \
/* . | \ */ \
/* Eblock | */ \
/* */ \
/* (ou 'argumentP' est une sequence d'instructions elle-meme argument d'appel de la */ \
/* fonction 'fonction1(...)') */ \
/* | */ \
/* ou encore : | */ \
/* | */ \
/* . | */ \
/* . | */ \
/* . | */ \
/* fonction1(argument1 | */ \
/* ,argument2 | */ \
/* ,... | */ \
/* ,BLOC(VIDE;) <-----------------------------------| */ \
/* ,... | */ \
/* ,argumentN | */ \
/* ); | */ \
/* . | */ \
/* . | */ \
/* . | */ \
/* BLOC(VIDE;); | */ \
/* . | */ \
/* . | */ \
/* . | */ \
/* | */ \
/* ou encore : | */ \
/* | */ \
/* . | */ \
/* . | */ \
/* . | */ \
/* fonction1(argument1 | */ \
/* ,argument2 | */ \
/* ,... | */ \
/* ,BLOC(instruction1; | */ \
/* ,instruction2; | */ \
/* ,...; | */ \
/* ,instructionM; | */ \
/* ) <----------------------------------------| */ \
/* ,... | */ \
/* ,argumentN | */ \
/* ); | */ \
/* . | */ \
/* . | */ \
/* . | */ \
/* */ \
/* et on notera bien l'absence de point-virgule apres 'BLOC(...)'. Par contre, lorsqu'il */ \
/* d'une sequence de code figurant dans un bloc, le point-virgule devra apparaitre : */ \
/* */ \
/* Bblock | */ \
/* . | */ \
/* . | */ \
/* . | */ \
/* BLOC(instruction1; | */ \
/* ,instruction2; | */ \
/* ,...; | */ \
/* ,instructionM; | */ \
/* ); <-------------------------------------------------| */ \
/* . | */ \
/* . | */ \
/* . | */ \
/* Eblock | */ \
/* | */ \
/* et encore : | */ \
/* */ \
/* #define fonction1(argument1,argument2,...,argumentP,...,argumentN) \ */ \
/* Bblock \ */ \
/* . | \ */ \
/* . | \ */ \
/* . | \ */ \
/* BLOC(argumentP); <-------------------- \ */ \
/* . \ */ \
/* . \ */ \
/* . \ */ \
/* Eblock */ \
/* */ \
/* (ou 'argumentP' est une sequence d'instructions elle-meme argument d'appel de la */ \
/* fonction 'fonction1(...)') */ \
/* */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* V A R I A N T E P L U S G E N E R A L E D E " C A S E " A V E C V A R I A B L E S : */
/* */
/*************************************************************************************************************************************/
#define gCHoi(expression_de_CHoi,valeur_initiale,pas_d_incrementation) \
BblockV \
BblockV \
/* On fait preceder le "CHoi" de deux debuts de block, afin que la fin du "CHoi" */ \
/* (c'est-a-dire le "ECHo") et la presence du traitement par default (c'est-a-dire */ \
/* 'DEfo') puissent etre detectes par le compilateur ; en effet, s'il s'agissait */ \
/* d'une instruction vide, son absence ne serait pas diagnostiquee !!! */ \
Bblock \
DEFV(Float,INIT(expression_cherchee,FLOT(expression_de_CHoi))); \
/* Creation d'une variable locale (incluant les 'Int' et les 'Float') destinee a memoriser */ \
/* pour les differents 'CAse' la valeur recherchee. */ \
DEFV(Logical,INIT(on_a_trouve_l_expression_cherchee,FAUX)); \
/* Afin de savoir si un 'CAse' a ete "positif"... */ \
DEFV(Int,INIT(CAse_courant_SEQUENTIEL,valeur_initiale)); \
DEFV(Int,INIT(pas_des_CAse_SEQUENTIEL,pas_d_incrementation)); \
/* Pour indexer sequentiellement les 'CAse' lors d'une utilisation sequentielle (a ce */ \
/* propos 'v $xcp/substitue.01$K gCHoi'). */
#define CHoi(expression_de_CHoi) \
gCHoi(expression_de_CHoi,ZERO,I) \
/* On notera que les valeurs 'ZERO' et 'I' sont inutiles et donc arbitraires... */
#define CAse(expression_de_CAse) \
Test(IFET(EST_FAUX(on_a_trouve_l_expression_cherchee) \
,IFEQ(expression_cherchee,FLOT(expression_de_CAse)) \
) \
) \
Bblock \
/* Traitement du cas courant, */
#define ECAs \
EGAL(on_a_trouve_l_expression_cherchee,VRAI); \
/* Ainsi, on sait que la recherche est terminee (les autres 'CAse' seront sautes). */ \
Eblock \
ATes \
Bblock \
INCR(CAse_courant_SEQUENTIEL,pas_des_CAse_SEQUENTIEL); \
/* Au cas ou l'on serait dans un 'gCHoi(...)'... */ \
Eblock \
ETes \
/* Fin de traitement du cas courant. */
#define CAge(expression_test) \
Test(IFET(EST_FAUX(on_a_trouve_l_expression_cherchee) \
,expression_test \
) \
) \
Bblock
#define ECAg \
ECAs \
/* Traitement General du cas courant (introduit le 20241126101752)... */
#define CA1e(c1) \
CAge(IFEQ(expression_cherchee,FLOT(c1)) \
)
#define ECA1 \
ECAg \
/* Traitement de 01 cas courant (introduit le 20220404154702). */
#define CA2e(c1,c2) \
CAge(IFOU(IFEQ(expression_cherchee,FLOT(c1)) \
,IFEQ(expression_cherchee,FLOT(c2)) \
) \
)
#define ECA2 \
ECAg \
/* Traitement de 02 cas courant (introduit le 20220404154702). */
#define CA3e(c1,c2,c3) \
CAge(I3OU(IFEQ(expression_cherchee,FLOT(c1)) \
,IFEQ(expression_cherchee,FLOT(c2)) \
,IFEQ(expression_cherchee,FLOT(c3)) \
) \
)
#define ECA3 \
ECAg \
/* Traitement de 03 cas courant (introduit le 20220404154702). */
#define CA4e(c1,c2,c3,c4) \
CAge(I4OU(IFEQ(expression_cherchee,FLOT(c1)) \
,IFEQ(expression_cherchee,FLOT(c2)) \
,IFEQ(expression_cherchee,FLOT(c3)) \
,IFEQ(expression_cherchee,FLOT(c4)) \
) \
)
#define ECA4 \
ECAg \
/* Traitement de 04 cas courant (introduit le 20220404154702). */
#define CA5e(c1,c2,c3,c4,c5) \
CAge(I5OU(IFEQ(expression_cherchee,FLOT(c1)) \
,IFEQ(expression_cherchee,FLOT(c2)) \
,IFEQ(expression_cherchee,FLOT(c3)) \
,IFEQ(expression_cherchee,FLOT(c4)) \
,IFEQ(expression_cherchee,FLOT(c5)) \
) \
)
#define ECA5 \
ECAg \
/* Traitement de 05 cas courant (introduit le 20220404154702). */
#define CA6e(c1,c2,c3,c4,c5,c6) \
CAge(I6OU(IFEQ(expression_cherchee,FLOT(c1)) \
,IFEQ(expression_cherchee,FLOT(c2)) \
,IFEQ(expression_cherchee,FLOT(c3)) \
,IFEQ(expression_cherchee,FLOT(c4)) \
,IFEQ(expression_cherchee,FLOT(c5)) \
,IFEQ(expression_cherchee,FLOT(c6)) \
) \
)
#define ECA6 \
ECAg \
/* Traitement de 06 cas courant (introduit le 20220404165910). */
#define CA7e(c1,c2,c3,c4,c5,c6,c7) \
CAge(I7OU(IFEQ(expression_cherchee,FLOT(c1)) \
,IFEQ(expression_cherchee,FLOT(c2)) \
,IFEQ(expression_cherchee,FLOT(c3)) \
,IFEQ(expression_cherchee,FLOT(c4)) \
,IFEQ(expression_cherchee,FLOT(c5)) \
,IFEQ(expression_cherchee,FLOT(c6)) \
,IFEQ(expression_cherchee,FLOT(c7)) \
) \
)
#define ECA7 \
ECAg \
/* Traitement de 07 cas courant (introduit le 20220404165910). */
#define CA8e(c1,c2,c3,c4,c5,c6,c7,c8) \
CAge(I8OU(IFEQ(expression_cherchee,FLOT(c1)) \
,IFEQ(expression_cherchee,FLOT(c2)) \
,IFEQ(expression_cherchee,FLOT(c3)) \
,IFEQ(expression_cherchee,FLOT(c4)) \
,IFEQ(expression_cherchee,FLOT(c5)) \
,IFEQ(expression_cherchee,FLOT(c6)) \
,IFEQ(expression_cherchee,FLOT(c7)) \
,IFEQ(expression_cherchee,FLOT(c8)) \
) \
)
#define ECA8 \
ECAg \
/* Traitement de 08 cas courant (introduit le 20220404165910). */
#define CA9e(c1,c2,c3,c4,c5,c6,c7,c8,c9) \
CAge(I9OU(IFEQ(expression_cherchee,FLOT(c1)) \
,IFEQ(expression_cherchee,FLOT(c2)) \
,IFEQ(expression_cherchee,FLOT(c3)) \
,IFEQ(expression_cherchee,FLOT(c4)) \
,IFEQ(expression_cherchee,FLOT(c5)) \
,IFEQ(expression_cherchee,FLOT(c6)) \
,IFEQ(expression_cherchee,FLOT(c7)) \
,IFEQ(expression_cherchee,FLOT(c8)) \
,IFEQ(expression_cherchee,FLOT(c9)) \
) \
)
#define ECA9 \
ECAg \
/* Traitement de 09 cas courant (introduit le 20220404165910). */
#define CAse_SEQUENTIEL \
CAse(CAse_courant_SEQUENTIEL)
#define ECAs_SEQUENTIEL \
ECAs
#define DEfo \
Test(EST_FAUX(on_a_trouve_l_expression_cherchee)) \
Bblock \
/* Traitement du cas par defaut, */
#define EDEf \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
EblockV \
/* Fin de traitement du cas par defaut. */
#define EgCHo \
EblockV \
/* Fin de l'instruction 'gCHoi'. */
#define ECHo \
EgCHo \
/* Fin de l'instruction 'CHoi'. */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* S U I T E D E T E S T S D O N T S E U L L E P R E M I E R V R A I E S T P R I S E N C O M P T E : */
/* */
/*************************************************************************************************************************************/
/* Ce qui suit a ete introduit le 20161128143705 afin de permettre la definition d'une */
/* suite de tests dits "Uniques" dont l'un seulement (le premier rencontre avec une */
/* certaine condition VRAIe) s'executera... */
#define TestU \
BblockV \
BblockV \
/* On fait preceder le "TestU" de deux debuts de block, afin que la fin du "TestU" */ \
/* (c'est-a-dire le "ETestU") et la presence du traitement par default (c'est-a-dire */ \
/* 'UDEfo') puissent etre detectes par le compilateur ; en effet, s'il s'agissait */ \
/* d'une instruction vide, son absence ne serait pas diagnostiquee !!! */ \
Bblock \
DEFV(Logical,INIT(on_a_trouve_la_condition_cherchee,FAUX)); \
/* Afin de savoir si un 'CAse' a ete "positif"... */
#define UCAse(condition) \
Test(IFET(EST_FAUX(on_a_trouve_la_condition_cherchee) \
,EST_VRAI(condition) \
) \
) \
Bblock \
/* Traitement du cas courant, */
#define EUCAs \
EGAL(on_a_trouve_la_condition_cherchee,VRAI); \
/* Ainsi, on sait que la recherche est terminee (les autres 'UCAse' seront sautes). */ \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
/* Fin de traitement du cas courant. */
#define UDEfo \
Test(EST_FAUX(on_a_trouve_la_condition_cherchee)) \
Bblock \
/* Traitement du cas par defaut, */
#define EUDEf \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
EblockV \
/* Fin de traitement du cas par defaut. */
#define ETestU \
EblockV \
/* Fin de l'instruction 'TestU'. */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* C O N S T R U C T E U R S D ' I T E R A T I O N S : */
/* */
/*************************************************************************************************************************************/
#define PREMIERE_ITERATION_D_UN_Komp \
UN \
/* Numero de le premiere iteration d'un 'Komp(...)'. */
#define Komp(compteur_des_repetitions_du_Komp,nombre_de_repetitions) \
Bblock \
/* ATTENTION : 'Bblock' et non pas 'BblockV', et ce a cause du compteur local defini apres. */ \
DEFV(Int,INIT(nombre_de_repetitions_du_Komp,nombre_de_repetitions)); \
/* Variable introduite pour 'v $xig/fonct$vv$FON nombre_de_repetitions_du_Komp' le */ \
/* 20210401165114... */ \
DEFV(Int,INIT(compteur_des_repetitions_du_Komp,UNDEF)); \
/* Cette variable locale va servir d'indice pour la boucle 'DoIn' qui suit, mais */ \
/* ATTENTION : elle ne peut etre un 'Positive' au cas ou un nombre de repetitions */ \
/* negatif serait communique... */ \
DoIn(compteur_des_repetitions_du_Komp,PREMIERE_ITERATION_D_UN_Komp,nombre_de_repetitions_du_Komp,I) \
/* On fait debuter le "Komp" par un debut de block ('Bblock'), afin que la fin de la */ \
/* boucle (c'est-a-dire le "EKom") puisse etre validee par le compilateur ; en effet, */ \
/* s'il s'agissait d'une instruction vide, son absence ne serait pas diagnostiquee !!! */ \
Bblock
#define EKom \
Eblock \
EDoI \
Eblock
#define PREMIERE_ITERATION_D_UN_Repe \
PREMIERE_ITERATION_D_UN_Komp \
/* Numero de le premiere iteration d'un 'Repe(...)'. */
#define nombre_de_repetitions_du_Repe \
nombre_de_repetitions_du_Komp \
/* Nombre de repetitions d'un 'Repe(...)' (introduit le 20210401171123 pour etre utilise */ \
/* dans 'v $xig/fonct$vv$FON 20210401144342')... */
#define Repe(nombre_de_repetitions) \
BblockV \
Komp(compteur_des_repetitions_du_Repe,nombre_de_repetitions) \
/* On fait preceder le "Repe" d'un debut de block, afin que la fin de la boucle */ \
/* (c'est-a-dire le "ERep") puisse etre valide par le compilateur ; en */ \
/* effet, s'il s'agissait d'une instruction vide, son absence ne serait */ \
/* pas diagnostiquee !!! */ \
Bblock
#define ERep \
Eblock \
EKom \
EblockV
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N D E S E Q U E N C E S P R O V I S O I R E M E N T I N C O M P L E T E S */
/* E T C E A F I N D E F A C I L I T E R L E " P R O T O T Y P A G E " : */
/* */
/*************************************************************************************************************************************/
#define SEQUENCE_INCOMPLETE(message) \
Bblock \
BLOC(VIDE;); \
/* Il n'y a donc a priori aucune instruction... */ \
PRINT_MESSAGE("sequence incomplete",message); \
Eblock \
/* Definition d'une sequence incomplete, et edition d'un message si 'message' n'est pas */ \
/* le message VIDE... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* S T R U C T U R E S D E C O N T R O L E D ' U N M O D E " D E B U G " : */
/* */
/*************************************************************************************************************************************/
#ifdef MODE_DEBUG
# define DEBU(block) \
block \
/* Permet de faire la compilation conditionnelle, suivant que 'DEBU' ne */ \
/* fait rien, ou equivaut a 'block' (comme 'BLOC')... */ \
/* */ \
/* ATTENTION, ne pas mettre de point-virgule ou autre parce que l'on ne sait pas dans quel */ \
/* contexte 'DEBU(...)' va etre utilise, et donc ne pas ecrire en particulier : */ \
/* */ \
/* BLOC(block); */ \
/* */
#Aifdef MODE_DEBUG
# define DEBU(block) \
VIDE \
/* Permet de faire la compilation conditionnelle, suivant que 'DEBU' ne */ \
/* fait rien, ou equivaut a 'block' (comme 'BLOC')... */ \
/* */ \
/* ATTENTION, ne pas mettre de point-virgule ou autre parce que l'on ne sait pas dans quel */ \
/* contexte 'DEBU(...)' va etre utilise, et donc, en particulier, ne pas definir 'DEBU(...)' */ \
/* par : */ \
/* */ \
/* BLOC(VIDE;); */ \
/* */
#Eifdef MODE_DEBUG
#define DBOF(block) \
/* Permet de ne pas compiler un module (s'utilise en "bascule" avec 'DBON')... */
#define DBON(block) \
block \
/* Permet de compiler un module (s'utilise en "bascule" avec 'DBOF')... */ \
/* */ \
/* ATTENTION, ne pas mettre de point-virgule ou autre parce que l'on ne sait pas dans quel */ \
/* contexte 'DEBU(...)' va etre utilise... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N D E S O B J E T S A N E P A S E X T E R I O R I S E R : */
/* */
/*************************************************************************************************************************************/
TypedefT(Local,Static)
/* Ce mot clef doit etre mis devant les "objets" locaux a un fichier (structures, fonctions, */
/* donnees diverses...). */
/* */
/* ATTENTION, l'utilisation de 'Local' est dangereux a l'interieur d'une boucle, au cas */
/* ou la variable definie est simultanement initialisee. En effet, cette initialisation */
/* n'aura lieu qu'une seule fois ('v $xrk/rdn_walk.52$K 19991116105451'). */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N D E S O B J E T S A E X T E R I O R I S E R : */
/* */
/*************************************************************************************************************************************/
TypedefP(Common,VIDE)
/* Ce mot clef vide devra etre mis devant tous les objets (donnees, */
/* structures, fonctions,...) dont la portee est superieure au */
/* fichier courant ; mais ATTENTION, c'est la chaine "Common " (c'est-a-dire */
/* le mot "Common" suivi d'un "ESPACE" qui est recherche, et ce afin de pouvoir */
/* l'utiliser dans un commentaire, par exemple sous la forme "Common" ou */
/* 'Common' (donc entre apostrophes). En general, on trouvera "Common " en */
/* tete de ligne (tel "^Common int..."), ou en milieu de ligne a l'interieur */
/* d'un commentaire (tel dans un "#define ...). */
TypedefP(LoF,VIDE)
/* Introduit le 20170117140001 pour, par exemple, 'v $xci/valeurs_Hilbert2D$K LoF' */
/* ces fichiers eux-memes en ayant besoin pour 'v $xi/DICO_Fonction$Z LoF'. */
/* */
/* L'usage de 'Local' (a la place de 'LoF' donnait lors de la compilation du fichier */
/* 'v $xci/valeurs_Hilbert2D$K LoF' le message d'erreur suivant : */
/* */
/* error: static declaration of 'GenerationDeLaCourbeDeHilbert_L' */
/* follows non-static declaration */
/* */
/* C'est cela qui a rendu necessaire la definition de 'SuperLocal' (le nom peut paraitre */
/* "curieux", mais je n'ai rien trouve de mieux a cette date...). */
/* */
/* Le 20170124114631, il a fallu remplacer le 'SuperLocal' du 20170117140001 par quelque */
/* chose de plus court ('LoF' pour "LOcal Fovction") afin que les appels a */
/* 'GENERE__Fonction__OPT(...)' tiennent tous sur une seule ligne afin que des espaces */
/* ne s'introduisent pas dans la liste des arguments d'appel... */
/* */
/* En fait, le probleme venait de 'v $xrq/particle.M1$I 20170124134356', donc le changement */
/* de 'SuperLocal' en 'LoF' n'etait pas utile... */
#define PARENTHESES_DES_FONCTIONS \
/* Ce mot clef vide est utilise pour la generation des fichiers ".ext" pour le traitement */ \
/* des 'GENERE__FonctionI_GRAPHIQUES'... */
TypedefAES(Ailleurs,___Extern E___ <><> )
/* Ce mot clef doit etre mis devant toutes les definitions des objets externes a un module. */
/* On notera la syntaxe tres particuliere 'Extern E___ <><> ' destinee a obtenir la */
/* concatenation du prefixe 'E___' des modules "personnels" mais definis ailleurs... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N D ' O P E R A T E U R S D I T S " S I G N E S " : */
/* */
/*************************************************************************************************************************************/
#define SOPER(operateur,variable,translation) \
MEME_SIGNE_QUE(variable,operateur(ADD2(ABSO(variable),translation)))
#define fSOPER(operateur,variable,translation) \
MEME_SIGNE_QUE(variable,operateur(ADD2(fABSO(variable),translation)))
/* Introduit le 20160616181059 pour definir d'une facon generale des operateurs tels */
/* 'SRACX(...)' ou encore 'SLOGX(...)'... */
/* */
/* Le 20160617153646 fut introduit 'fSOPER(...)' utilisant 'fABSO(...)' de facon a */
/* accelerer les compilations correspondantes. Evidemment, cela implique une utilisation */
/* avec des variables de type 'Float', mais ce n'est pas limitatif puisque cela n'est */
/* utilise que dans des procedures du type 'SRACX(...)' ou encore 'SLOGX(...)'... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N S " V I S I B L E S " D E S F O N C T I O N S M A T H E M A T I Q U E S */
/* N E P O S A N T P A S D E P R O B L E M E S : */
/* */
/*************************************************************************************************************************************/
/* ATTENTION, bien noter la difference entre les definitions : */
/* */
/* #define FONCTION(...) \ */
/* DEFINITION(...) \ */
/* */
/* qui correspondent a des fonctions dont la derivee va etre definie explicitement */
/* ci-apres, et les definitions : */
/* */
/* -define FONCTION(...) \ */
/* -_-_-_- DEFINITION(...) */
/* */
/* qui correspondent a des fonctions dont la derivee va etre calculee formellement a */
/* l'aide des regles deja enregistrees... */
#define EXPn(x,p) \
x_a_la_puissance_p(FLOT(x),INTE(p)) \
/* Fonction 'exponentielle entiere' (introduite le 20100602090456). */
#define FACT(x) \
factorielle_non_recursive(INTE(x)) \
/* Fonction 'factorielle'. Deux possibilites sont disponibles : */ \
/* */ \
/* #define FACT(x) \ */ \
/* FLOT(factorielle_recursive(INTE(x))) */ \
/* */ \
/* et : */ \
/* */ \
/* #define FACT(x) \ */ \
/* factorielle_non_recursive(INTE(x)) */ \
/* */ \
/* la premiere etant plus elegante, alors que la seconde est plus rapide. ATTENTION, on */ \
/* notera bien que dans les deux cas, le resultat est de type 'Float', alors que la premiere */ \
/* fonction est de type 'Int', alors que la seconde est de type 'Float'. Dans les deux cas, */ \
/* au dela de 12, le resultat est faux dans le premier cas, et approxime dans le second... */
#define RACX(x) \
RACD(x) \
/* Fonction 'racine carree'. Des tests montrent que le rapport entre les temps d'execution */ \
/* de 'RACX(...)' et 'EXP2(...)' est legerement inferieur a 3 et 5 sur '$LACT29' et sur */ \
/* '$LACT27' respectivement. */
#define RACO(x) \
RACX(ABSO(x)) \
/* Fonction 'racine carree de la valeur absOlue' (introduite le 20220130102415)... */
#define SRACX(x) \
SOPER(RACX,x,FZERO) \
/* Fonction 'racine carree de x' "Signee" : */ \
/* */ \
/* __ */ \
/* x>0 : SRACX(x,y) = \/x */ \
/* */ \
/* ____ */ \
/* x<0 : SRACX(x,y) = -\/|x| */ \
/* */ \
/* Ceci a ete introduit le 20150407092509... */ \
/* */ \
/* L'introduction de 'fOPIR0n(...)' a permis de remettre 'SOPER(...)' plutot que */ \
/* 'fSOPER(...)' le 20160618111504, ce qui est plus general... */
#if ( (defined(SYSTEME_SGIND308_IRIX_CC)) \
|| (defined(SYSTEME_SGIND324_IRIX_CC)) \
|| (defined(SYSTEME_SGIND3GA_IRIX_CC)) \
|| (defined(SYSTEME_SGIND408_IRIX_CC)) \
|| (defined(SYSTEME_SGIND424_IRIX_CC)) \
|| (defined(SYSTEME_SGIND4GA_IRIX_CC)) \
|| (defined(SYSTEME_SGIND508_IRIX_CC)) \
|| (defined(SYSTEME_SGIND524_IRIX_CC)) \
|| (defined(SYSTEME_SGIND5GA_IRIX_CC)) \
|| (defined(SYSTEME_SGIND808_IRIX_CC)) \
|| (defined(SYSTEME_SGIND824_IRIX_CC)) \
|| (defined(SYSTEME_SGIND8GA_IRIX_CC)) \
|| (defined(SYSTEME_SGINDA08_IRIX_CC)) \
|| (defined(SYSTEME_SGINDA24_IRIX_CC)) \
|| (defined(SYSTEME_SGINDAGA_IRIX_CC)) \
|| (defined(SYSTEME_SGO200A1_IRIX_CC)) \
|| (defined(SYSTEME_SGO200A2_IRIX_CC)) \
|| (defined(SYSTEME_SGO200A4_IRIX_CC)) \
|| (defined(SYSTEME_SGO25224_IRIX_CC)) \
|| (defined(SYSTEME_SGO252VA_IRIX_CC)) \
|| (defined(SYSTEME_SGO252VN_IRIX_CC)) \
|| (defined(SYSTEME_SGPCM801_IRIX_CC)) \
|| (defined(SYSTEME_SGPCMA01_IRIX_CC)) \
)
# TestADef BUG_SYSTEME_SGIND_C_log \
/* La fonction 'log(...)' fait une division par 0 lorsque son argument est nul (voir */ \
/* 'v $Dbugs/SGIND424$D/IRIX$D/CC$D/log.01$c')... */
#Aif ( (defined(SYSTEME_SGIND308_IRIX_CC)) \
|| (defined(SYSTEME_SGIND324_IRIX_CC)) \
|| (defined(SYSTEME_SGIND3GA_IRIX_CC)) \
|| (defined(SYSTEME_SGIND408_IRIX_CC)) \
|| (defined(SYSTEME_SGIND424_IRIX_CC)) \
|| (defined(SYSTEME_SGIND4GA_IRIX_CC)) \
|| (defined(SYSTEME_SGIND508_IRIX_CC)) \
|| (defined(SYSTEME_SGIND524_IRIX_CC)) \
|| (defined(SYSTEME_SGIND5GA_IRIX_CC)) \
|| (defined(SYSTEME_SGIND808_IRIX_CC)) \
|| (defined(SYSTEME_SGIND824_IRIX_CC)) \
|| (defined(SYSTEME_SGIND8GA_IRIX_CC)) \
|| (defined(SYSTEME_SGINDA08_IRIX_CC)) \
|| (defined(SYSTEME_SGINDA24_IRIX_CC)) \
|| (defined(SYSTEME_SGINDAGA_IRIX_CC)) \
|| (defined(SYSTEME_SGO200A1_IRIX_CC)) \
|| (defined(SYSTEME_SGO200A2_IRIX_CC)) \
|| (defined(SYSTEME_SGO200A4_IRIX_CC)) \
|| (defined(SYSTEME_SGO25224_IRIX_CC)) \
|| (defined(SYSTEME_SGO252VA_IRIX_CC)) \
|| (defined(SYSTEME_SGO252VN_IRIX_CC)) \
|| (defined(SYSTEME_SGPCM801_IRIX_CC)) \
|| (defined(SYSTEME_SGPCMA01_IRIX_CC)) \
)
#Eif ( (defined(SYSTEME_SGIND308_IRIX_CC)) \
|| (defined(SYSTEME_SGIND324_IRIX_CC)) \
|| (defined(SYSTEME_SGIND3GA_IRIX_CC)) \
|| (defined(SYSTEME_SGIND408_IRIX_CC)) \
|| (defined(SYSTEME_SGIND424_IRIX_CC)) \
|| (defined(SYSTEME_SGIND4GA_IRIX_CC)) \
|| (defined(SYSTEME_SGIND508_IRIX_CC)) \
|| (defined(SYSTEME_SGIND524_IRIX_CC)) \
|| (defined(SYSTEME_SGIND5GA_IRIX_CC)) \
|| (defined(SYSTEME_SGIND808_IRIX_CC)) \
|| (defined(SYSTEME_SGIND824_IRIX_CC)) \
|| (defined(SYSTEME_SGIND8GA_IRIX_CC)) \
|| (defined(SYSTEME_SGINDA08_IRIX_CC)) \
|| (defined(SYSTEME_SGINDA24_IRIX_CC)) \
|| (defined(SYSTEME_SGINDAGA_IRIX_CC)) \
|| (defined(SYSTEME_SGO200A1_IRIX_CC)) \
|| (defined(SYSTEME_SGO200A2_IRIX_CC)) \
|| (defined(SYSTEME_SGO200A4_IRIX_CC)) \
|| (defined(SYSTEME_SGO25224_IRIX_CC)) \
|| (defined(SYSTEME_SGO252VA_IRIX_CC)) \
|| (defined(SYSTEME_SGO252VN_IRIX_CC)) \
|| (defined(SYSTEME_SGPCM801_IRIX_CC)) \
|| (defined(SYSTEME_SGPCMA01_IRIX_CC)) \
)
#define EXPONENTIELLE_DE_0 \
EXPX(FZERO) \
/* Exponentielle de 0 (introduit le 20220522165734)... */
#define LOGX(x) \
LOGD(x) \
/* Fonction 'logarithme neperien'. */
#define LOGO(x) \
LOGX(ADD2(ABSO(x),EXPONENTIELLE_DE_0)) \
/* Fonction 'logarithme de valeur absOlue de 'x' (introduite le 20220130102415)... */
#define SLOGX(x) \
SOPER(LOGX,x,EXPONENTIELLE_DE_0) \
/* Fonction 'logarithme de x' "Signee" : */ \
/* */ \
/* x>0 : SLOGX(x) = log(x+1) */ \
/* */ \
/* x<0 : SLOGX(x) = -log(|x|+1) */ \
/* */ \
/* On notera donc que cette fonction conserve d'une part le 0 et d'autre part le signe : */ \
/* */ \
/* SLOGX(0) = 0 */ \
/* */ \
/* Signe(x) = Signe(SLOGX(x)) */ \
/* */ \
/* SLOGX(-x) = -SLOGX(x) */ \
/* */ \
/* Ceci a ete introduit le 20150407092509 et modifie le 20150407115843 en introduisant le */ \
/* "+1" afin d'eviter le probleme de 'log(0)'... */ \
/* */ \
/* Le 20160609083413 je mets en evidence le fait que 'LOGX(...)' et 'EXPX(...)' sont deux */ \
/* fonctions inverses l'une de l'autre... */ \
/* */ \
/* L'introduction de 'fOPIR0n(...)' a permis de remettre 'SOPER(...)' plutot que */ \
/* 'fSOPER(...)' le 20160618111504, ce qui est plus general... */
#define LOGXfs(x,traiter_les_valeurs_negatives) \
COND(IL_NE_FAUT_PAS(traiter_les_valeurs_negatives) \
,LOGX(x) \
,bMUL(SIGN(x),LOGX(ABSO(x))) \
) \
/* Fonction 'logarithme neperien' dite "Faussement Signee" (introduite le 20121022095146). */ \
/* */ \
/* On notera que si 'IL_NE_FAUT_PAS(traiter_les_valeurs_negatives)', alors un 'x' negatif */ \
/* peut donner la valeur : */ \
/* */ \
/* nan */ \
/* */ \
/* On pourrait evidemment utiliser 'LOGX(ABSO(x))' plutot que 'LOGX(x)', mais c'est une */ \
/* erreur que d'utiliser un 'x' negatif ; il faut donc que cela apparaisse... */
#if ( (defined(BUG_SYSTEME_SGIND_C_log)) \
)
# undef LOGX
# define LOGX(x) \
COND(IZNE(x),LOGD(x),F_MOINS_L_INFINI) \
/* Fonction 'logarithme neperien'. ATTENTION, on notera que l'on ne prend en compte que */ \
/* l'erreur 'x=0' ; pour les valeurs negatives de 'x' on laisse ce soin a l a fonction */ \
/* logarithme elle-meme. Ceci a ete rendu necessaire pour eviter une division par 0... */
#Aif ( (defined(BUG_SYSTEME_SGIND_C_log)) \
)
#Eif ( (defined(BUG_SYSTEME_SGIND_C_log)) \
)
-define LOIN(x) \
-_-_-_- DIVI(x,LOGX(x))
/* Approximation du LOgarithme INtegral (introduit le 20171030111459) : */
/* */
/* /x */
/* | */
/* | 1 x */
/* li(x) = | -------dt ~ ------- (avec x # 1) */
/* | ln(t) ln(x) */
/* | */
/* /0 */
/* */
/* qui donne a la limite (x --> infini) le nombre de nombres premiers inferieurs ou */
/* egaux a 'x'... */
-define LObX(x,b) \
-_-_-_- DIVI(LOGX(x),LOGX(b))
/* Fonction 'logarithme base b'. */
-define LO2X(x) \
-_-_-_- LObX(x,FBASE2)
/* Fonction 'logarithme base 2'. */
#define EST_UNE_PUISSANCE_DE_2(x) \
EST_ENTIER(LO2X(x)) \
/* Le nombre 'x' est-il une puissance de 2 (introduit le 20060313100414) ? */
#if ( ((defined(SYSTEME_SGIND308_IRIX_CC)) && ((nSYSTEM_RELEASE >= 500000000) && (nSYSTEM_RELEASE < 502000000))) \
|| ((defined(SYSTEME_SGIND324_IRIX_CC)) && ((nSYSTEM_RELEASE >= 500000000) && (nSYSTEM_RELEASE < 502000000))) \
|| ((defined(SYSTEME_SGIND3GA_IRIX_CC)) && ((nSYSTEM_RELEASE >= 500000000) && (nSYSTEM_RELEASE < 502000000))) \
|| ((defined(SYSTEME_SGIND408_IRIX_CC)) && ((nSYSTEM_RELEASE >= 500000000) && (nSYSTEM_RELEASE < 502000000))) \
|| ((defined(SYSTEME_SGIND424_IRIX_CC)) && ((nSYSTEM_RELEASE >= 500000000) && (nSYSTEM_RELEASE < 502000000))) \
|| ((defined(SYSTEME_SGIND4GA_IRIX_CC)) && ((nSYSTEM_RELEASE >= 500000000) && (nSYSTEM_RELEASE < 502000000))) \
|| ((defined(SYSTEME_SGIND508_IRIX_CC)) && ((nSYSTEM_RELEASE >= 500000000) && (nSYSTEM_RELEASE < 502000000))) \
|| ((defined(SYSTEME_SGIND524_IRIX_CC)) && ((nSYSTEM_RELEASE >= 500000000) && (nSYSTEM_RELEASE < 502000000))) \
|| ((defined(SYSTEME_SGIND5GA_IRIX_CC)) && ((nSYSTEM_RELEASE >= 500000000) && (nSYSTEM_RELEASE < 502000000))) \
|| ((defined(SYSTEME_SGIND808_IRIX_CC)) && ((nSYSTEM_RELEASE >= 500000000) && (nSYSTEM_RELEASE < 502000000))) \
|| ((defined(SYSTEME_SGIND824_IRIX_CC)) && ((nSYSTEM_RELEASE >= 500000000) && (nSYSTEM_RELEASE < 502000000))) \
|| ((defined(SYSTEME_SGIND8GA_IRIX_CC)) && ((nSYSTEM_RELEASE >= 500000000) && (nSYSTEM_RELEASE < 502000000))) \
|| ((defined(SYSTEME_SGINDA08_IRIX_CC)) && ((nSYSTEM_RELEASE >= 500000000) && (nSYSTEM_RELEASE < 502000000))) \
|| ((defined(SYSTEME_SGINDA24_IRIX_CC)) && ((nSYSTEM_RELEASE >= 500000000) && (nSYSTEM_RELEASE < 502000000))) \
|| ((defined(SYSTEME_SGINDAGA_IRIX_CC)) && ((nSYSTEM_RELEASE >= 500000000) && (nSYSTEM_RELEASE < 502000000))) \
|| ((defined(SYSTEME_SGO200A1_IRIX_CC)) && ((nSYSTEM_RELEASE >= 500000000) && (nSYSTEM_RELEASE < 502000000))) \
|| ((defined(SYSTEME_SGO200A2_IRIX_CC)) && ((nSYSTEM_RELEASE >= 500000000) && (nSYSTEM_RELEASE < 502000000))) \
|| ((defined(SYSTEME_SGO200A4_IRIX_CC)) && ((nSYSTEM_RELEASE >= 500000000) && (nSYSTEM_RELEASE < 502000000))) \
|| ((defined(SYSTEME_SGO25224_IRIX_CC)) && ((nSYSTEM_RELEASE >= 500000000) && (nSYSTEM_RELEASE < 502000000))) \
|| ((defined(SYSTEME_SGO252VA_IRIX_CC)) && ((nSYSTEM_RELEASE >= 500000000) && (nSYSTEM_RELEASE < 502000000))) \
|| ((defined(SYSTEME_SGO252VN_IRIX_CC)) && ((nSYSTEM_RELEASE >= 500000000) && (nSYSTEM_RELEASE < 502000000))) \
|| ((defined(SYSTEME_SGPCM801_IRIX_CC)) && ((nSYSTEM_RELEASE >= 500000000) && (nSYSTEM_RELEASE < 502000000))) \
|| ((defined(SYSTEME_SGPCMA01_IRIX_CC)) && ((nSYSTEM_RELEASE >= 500000000) && (nSYSTEM_RELEASE < 502000000))) \
)
# TestADef BUG_SYSTEME_SGIND_C_log10 \
/* La fonction 'log10(...)' peut renvoyer en certaines circonstances le logarithme neperien */ \
/* de son argument (voir 'v $Dbugs/SGIND424$D/IRIX$D/CC$D/log10.02$c'). */
#Aif ( ((defined(SYSTEME_SGIND308_IRIX_CC)) && ((nSYSTEM_RELEASE >= 500000000) && (nSYSTEM_RELEASE < 502000000))) \
|| ((defined(SYSTEME_SGIND324_IRIX_CC)) && ((nSYSTEM_RELEASE >= 500000000) && (nSYSTEM_RELEASE < 502000000))) \
|| ((defined(SYSTEME_SGIND3GA_IRIX_CC)) && ((nSYSTEM_RELEASE >= 500000000) && (nSYSTEM_RELEASE < 502000000))) \
|| ((defined(SYSTEME_SGIND408_IRIX_CC)) && ((nSYSTEM_RELEASE >= 500000000) && (nSYSTEM_RELEASE < 502000000))) \
|| ((defined(SYSTEME_SGIND424_IRIX_CC)) && ((nSYSTEM_RELEASE >= 500000000) && (nSYSTEM_RELEASE < 502000000))) \
|| ((defined(SYSTEME_SGIND4GA_IRIX_CC)) && ((nSYSTEM_RELEASE >= 500000000) && (nSYSTEM_RELEASE < 502000000))) \
|| ((defined(SYSTEME_SGIND508_IRIX_CC)) && ((nSYSTEM_RELEASE >= 500000000) && (nSYSTEM_RELEASE < 502000000))) \
|| ((defined(SYSTEME_SGIND524_IRIX_CC)) && ((nSYSTEM_RELEASE >= 500000000) && (nSYSTEM_RELEASE < 502000000))) \
|| ((defined(SYSTEME_SGIND5GA_IRIX_CC)) && ((nSYSTEM_RELEASE >= 500000000) && (nSYSTEM_RELEASE < 502000000))) \
|| ((defined(SYSTEME_SGIND808_IRIX_CC)) && ((nSYSTEM_RELEASE >= 500000000) && (nSYSTEM_RELEASE < 502000000))) \
|| ((defined(SYSTEME_SGIND824_IRIX_CC)) && ((nSYSTEM_RELEASE >= 500000000) && (nSYSTEM_RELEASE < 502000000))) \
|| ((defined(SYSTEME_SGIND8GA_IRIX_CC)) && ((nSYSTEM_RELEASE >= 500000000) && (nSYSTEM_RELEASE < 502000000))) \
|| ((defined(SYSTEME_SGINDA08_IRIX_CC)) && ((nSYSTEM_RELEASE >= 500000000) && (nSYSTEM_RELEASE < 502000000))) \
|| ((defined(SYSTEME_SGINDA24_IRIX_CC)) && ((nSYSTEM_RELEASE >= 500000000) && (nSYSTEM_RELEASE < 502000000))) \
|| ((defined(SYSTEME_SGINDAGA_IRIX_CC)) && ((nSYSTEM_RELEASE >= 500000000) && (nSYSTEM_RELEASE < 502000000))) \
|| ((defined(SYSTEME_SGO200A1_IRIX_CC)) && ((nSYSTEM_RELEASE >= 500000000) && (nSYSTEM_RELEASE < 502000000))) \
|| ((defined(SYSTEME_SGO200A2_IRIX_CC)) && ((nSYSTEM_RELEASE >= 500000000) && (nSYSTEM_RELEASE < 502000000))) \
|| ((defined(SYSTEME_SGO200A4_IRIX_CC)) && ((nSYSTEM_RELEASE >= 500000000) && (nSYSTEM_RELEASE < 502000000))) \
|| ((defined(SYSTEME_SGO25224_IRIX_CC)) && ((nSYSTEM_RELEASE >= 500000000) && (nSYSTEM_RELEASE < 502000000))) \
|| ((defined(SYSTEME_SGO252VA_IRIX_CC)) && ((nSYSTEM_RELEASE >= 500000000) && (nSYSTEM_RELEASE < 502000000))) \
|| ((defined(SYSTEME_SGO252VN_IRIX_CC)) && ((nSYSTEM_RELEASE >= 500000000) && (nSYSTEM_RELEASE < 502000000))) \
|| ((defined(SYSTEME_SGPCM801_IRIX_CC)) && ((nSYSTEM_RELEASE >= 500000000) && (nSYSTEM_RELEASE < 502000000))) \
|| ((defined(SYSTEME_SGPCMA01_IRIX_CC)) && ((nSYSTEM_RELEASE >= 500000000) && (nSYSTEM_RELEASE < 502000000))) \
)
#Eif ( ((defined(SYSTEME_SGIND308_IRIX_CC)) && ((nSYSTEM_RELEASE >= 500000000) && (nSYSTEM_RELEASE < 502000000))) \
|| ((defined(SYSTEME_SGIND324_IRIX_CC)) && ((nSYSTEM_RELEASE >= 500000000) && (nSYSTEM_RELEASE < 502000000))) \
|| ((defined(SYSTEME_SGIND3GA_IRIX_CC)) && ((nSYSTEM_RELEASE >= 500000000) && (nSYSTEM_RELEASE < 502000000))) \
|| ((defined(SYSTEME_SGIND408_IRIX_CC)) && ((nSYSTEM_RELEASE >= 500000000) && (nSYSTEM_RELEASE < 502000000))) \
|| ((defined(SYSTEME_SGIND424_IRIX_CC)) && ((nSYSTEM_RELEASE >= 500000000) && (nSYSTEM_RELEASE < 502000000))) \
|| ((defined(SYSTEME_SGIND4GA_IRIX_CC)) && ((nSYSTEM_RELEASE >= 500000000) && (nSYSTEM_RELEASE < 502000000))) \
|| ((defined(SYSTEME_SGIND508_IRIX_CC)) && ((nSYSTEM_RELEASE >= 500000000) && (nSYSTEM_RELEASE < 502000000))) \
|| ((defined(SYSTEME_SGIND524_IRIX_CC)) && ((nSYSTEM_RELEASE >= 500000000) && (nSYSTEM_RELEASE < 502000000))) \
|| ((defined(SYSTEME_SGIND5GA_IRIX_CC)) && ((nSYSTEM_RELEASE >= 500000000) && (nSYSTEM_RELEASE < 502000000))) \
|| ((defined(SYSTEME_SGIND808_IRIX_CC)) && ((nSYSTEM_RELEASE >= 500000000) && (nSYSTEM_RELEASE < 502000000))) \
|| ((defined(SYSTEME_SGIND824_IRIX_CC)) && ((nSYSTEM_RELEASE >= 500000000) && (nSYSTEM_RELEASE < 502000000))) \
|| ((defined(SYSTEME_SGIND8GA_IRIX_CC)) && ((nSYSTEM_RELEASE >= 500000000) && (nSYSTEM_RELEASE < 502000000))) \
|| ((defined(SYSTEME_SGINDA08_IRIX_CC)) && ((nSYSTEM_RELEASE >= 500000000) && (nSYSTEM_RELEASE < 502000000))) \
|| ((defined(SYSTEME_SGINDA24_IRIX_CC)) && ((nSYSTEM_RELEASE >= 500000000) && (nSYSTEM_RELEASE < 502000000))) \
|| ((defined(SYSTEME_SGINDAGA_IRIX_CC)) && ((nSYSTEM_RELEASE >= 500000000) && (nSYSTEM_RELEASE < 502000000))) \
|| ((defined(SYSTEME_SGO200A1_IRIX_CC)) && ((nSYSTEM_RELEASE >= 500000000) && (nSYSTEM_RELEASE < 502000000))) \
|| ((defined(SYSTEME_SGO200A2_IRIX_CC)) && ((nSYSTEM_RELEASE >= 500000000) && (nSYSTEM_RELEASE < 502000000))) \
|| ((defined(SYSTEME_SGO200A4_IRIX_CC)) && ((nSYSTEM_RELEASE >= 500000000) && (nSYSTEM_RELEASE < 502000000))) \
|| ((defined(SYSTEME_SGO25224_IRIX_CC)) && ((nSYSTEM_RELEASE >= 500000000) && (nSYSTEM_RELEASE < 502000000))) \
|| ((defined(SYSTEME_SGO252VA_IRIX_CC)) && ((nSYSTEM_RELEASE >= 500000000) && (nSYSTEM_RELEASE < 502000000))) \
|| ((defined(SYSTEME_SGO252VN_IRIX_CC)) && ((nSYSTEM_RELEASE >= 500000000) && (nSYSTEM_RELEASE < 502000000))) \
|| ((defined(SYSTEME_SGPCM801_IRIX_CC)) && ((nSYSTEM_RELEASE >= 500000000) && (nSYSTEM_RELEASE < 502000000))) \
|| ((defined(SYSTEME_SGPCMA01_IRIX_CC)) && ((nSYSTEM_RELEASE >= 500000000) && (nSYSTEM_RELEASE < 502000000))) \
)
#define LO1X(x) \
LO1D(x) \
/* Fonction 'logarithme decimal'. */
#if ( (defined(BUG_SYSTEME_SGIND_C_log10)) \
)
# undef LO1X
# define LO1X(x) \
LObX(x,FBASE10) \
/* Fonction 'logarithme decimal'. On notera que l'option '-O2' de compilation est aussi */ \
/* une facon d'eviter le probleme (voir 'v $Fcompilers'). */
#Aif ( (defined(BUG_SYSTEME_SGIND_C_log10)) \
)
#Eif ( (defined(BUG_SYSTEME_SGIND_C_log10)) \
)
#define PUIX(x,y) \
COND(IFET(IZEQ(x),IZEQ(y)),FU,PUID(x,y)) \
/* Fonction 'x a la puissance y'. */ \
/* */ \
/* ATTENTION, jusqu'au 1994120800, la definition suivante etait utilise : */ \
/* */ \
/* #define PUIX(x,y) \ */ \
/* PUID(x,y) */ \
/* */ \
/* J'ai malheureusement trouve le probleme suivant : sur 'SYSTEME_HP???_HPUX_CC' la */ \
/* valeur : */ \
/* */ \
/* 0 */ \
/* 0 */ \
/* */ \
/* ne vaut pas 1 (par continuite), mais 'NaN', et donne simultanement le message : */ \
/* */ \
/* pow: DOMAIN error */ \
/* */ \
/* Or a cause des problemes de derivation formelle, la definition de 'PUIX(...)' ne peut */ \
/* etre rendue conditionnelle ; c'est pourquoi elle prend cette nouvelle forme sur tous */ \
/* les SYSTEMEs... */
#define SPUIX(x,y) \
MEME_SIGNE_QUE(x \
,COND(IFET(IZEQ(x),IZLT(y)) \
,MEME_SIGNE_QUE(y,F_INFINI) \
,PUIX(ABSO(x),y) \
) \
) \
/* Fonction 'x a la puissance y' etendue et "Signee" : */ \
/* */ \
/* y */ \
/* x>0 : SPUIX(x,y) = x */ \
/* */ \
/* */ \
/* x=0, y<0 : SPUIX(x,y) = +/-infini (valeur infinie introduite */ \
/* le 20080104162535 a cause de */ \
/* 'v $xig/fonct$vv$DEF SPUIX') */ \
/* y */ \
/* x<0 : SPUIX(x,y) = -|x| */ \
/* */ \
/* Ceci a ete introduit le 20030510184549 pour 'v $xiii/di_image$FON Fpolynomial_Fermat'. */ \
/* */ \
/* Le 20080104152848 le nom 'sPUIX(...)' a ete change en 'SPUIX(...)' par soucis */ \
/* d'homogeneite dans 'v $xig/fonct$vv$DEF GENERE__FonctionF_UNI2_02' (tous les noms de */ \
/* procedures {ADD2,SOUS,...} commencant par une majuscule...). */
#define PUIXfs(x,y,traiter_les_valeurs_negatives) \
COND(IL_NE_FAUT_PAS(traiter_les_valeurs_negatives) \
,PUIX(x,y) \
,bMUL(SIGN(x),PUIX(ABSO(x),y)) \
) \
/* Fonction 'x a la puissance y' dite "Faussement Signee" (introduite le 20121022095146 */ \
/* par symetrie avec 'v $xil/defi_K2$vv$DEF LOGXfs'...). */ \
/* */ \
/* On notera que si 'IL_NE_FAUT_PAS(traiter_les_valeurs_negatives)', alors un 'x' negatif */ \
/* peut donner la valeur : */ \
/* */ \
/* nan */ \
/* */ \
/* Ici, contrairement a 'LOGXfs(...)', on ne pourrait pas utiliser 'PUIX(ABSO(x),y)' */ \
/* puisque certaines valeurs de l'exposant 'y' autorisent ses valeurs negatives de 'x'... */
#define MONX(x,n) \
COND(IFET(IZEQ(x),IZEQ(n)),FU,MOND(x,n)) \
/* Fonction 'x a la puissance n'. Cette fonction en apparence inutile a ete introduite pour */ \
/* permettre de definir sa derivee. En effet, on verra lors de la definition de la derivee */ \
/* de la fonction 'PUIX(...)' que se pose un probleme delicat lorsque 'x' est negatif */ \
/* puisque l'on prend son logarithme. Pour resoudre partiellement ce probleme, on fait donc */ \
/* un cas particulier de celui ou 'y' est un nombre entier 'n', puisqu'alors il est possible */ \
/* de calculer sa derivee formelle sans passer par la derivee logarithmique... */ \
/* D'autre part, on notera que l'on ne definit pas 'MONX(...)' par : */ \
/* */ \
/* #define MONX(x,n) \ */ \
/* PUID(x,n) */ \
/* */ \
/* ce qu'explique le commentaire relatif a 'MOND(...)' dans '$xil/defi_c1$vv$DEF' */ \
/* */ \
/* ATTENTION, jusqu'au 1994120800, la definition suivante etait utilise : */ \
/* */ \
/* #define MONX(x,y) \ */ \
/* MOND(x,y) */ \
/* */ \
/* J'ai malheureusement trouve le probleme suivant : sur 'SYSTEME_HP???_HPUX_CC' la */ \
/* valeur : */ \
/* */ \
/* 0 */ \
/* 0 */ \
/* */ \
/* ne vaut pas 1 (par continuite), mais 'NaN', et donne simultanement le message : */ \
/* */ \
/* pow: DOMAIN error */ \
/* */ \
/* Or a cause des problemes de derivation formelle, la definition de 'MONX(...)' ne peut */ \
/* etre rendue conditionnelle ; c'est pourquoi elle prend cette nouvelle forme sur tous */ \
/* les SYSTEMEs... */
#define EXPX(x) \
EXPD(x) \
/* Fonction 'exponentielle'. */
#define COSX(x) \
COSD(x) \
/* Fonction 'cosinus' circulaire dans [-1,+1], */
#define COS1(cosinus_de_x) \
NORM(cosinus_de_x,COSINUS_DE_PI,COSINUS_DE_0) \
/* Mise d'une fonction 'cosinus' circulaire dans [0,+1]. */
#define SECX(x) \
fINVZ(COSX(x)) \
/* Fonction 'secante' circulaire (introduite le 20070727103657). */
#define SINX(x) \
SIND(x) \
/* Fonction 'sinus' circulaire dans [-1,+1], */
#define SIN1(sinus_de_x) \
NORM(sinus_de_x,SINUS_DE_3_PI_SUR_2,SINUS_DE_PI_SUR_2) \
/* Mise d'une fonction 'sinus' circulaire dans [0,+1]. */
#define CSEX(x) \
fINVZ(SINX(x)) \
/* Fonction 'cosecante' circulaire (introduite le 20070727103657). */
#if ( (defined(BUG_SYSTEME_SG_C_sin)) \
)
# undef SINX
# define SINX(x) \
COND(IFNE(ABSO(COSX(x)),COSX(FZERO)),SIND(x),SIND(FZERO)) \
/* Fonction 'sinus' circulaire, */
#Aif ( (defined(BUG_SYSTEME_SG_C_sin)) \
)
#Eif ( (defined(BUG_SYSTEME_SG_C_sin)) \
)
-define SICX(u) \
-_-_-_- COND(IZNE(u),DIVI(SINX(MUL2(PI,u)),MUL2(PI,u)),FU)
/* Fonction 'sinc' definie comme suit. Soit R(x) la fonction suivante : */
/* */
/* R(x) ^ */
/* | */
/* 1| */
/* * * *|* * * */
/* * | * */
/* * | * */
/* * | * */
/* * | * */
/* -*-*-*-*-*-*-*-*----+----*-*-*-*-*-*-*-*> */
/* 1 | 1 x */
/* - --- | + --- */
/* 2 | 2 */
/* | */
/* */
/* 'R(x)' definit donc un creneau unite. Sa transformee de Fourier est 'sinc(u)', soit : */
/* */
/* / +oo */
/* | */
/* sin(pi.u) | -2.i.pi.u.x */
/* sinc(u) = ----------- = | R(x).e dx */
/* pi.u | */
/* | */
/* / -oo */
/* */
/* le nom 'sinc' signifiant apparemment 'SINus Cardinal'... */
-define SINC(x) \
-_-_-_- COND(IZNE(x),DIVI(SINX(x),x),FU)
/* Fonction 'sinc' (introduite le 20230204101019 pour 'v $ximcd/operator$FON SINC') ou */
/* notera la disparition de 'PI' qui figurait dans 'SICX(...)'... */
-define TANX(x) \
-_-_-_- fDIVZ(SINX(x),COSX(x))
/* Fonction 'tangente' circulaire. On notera que la 'tangente' est definie par le rapport */
/* du 'sinus' au 'cosinus', et non pas en referencant une fonction de bibliotheque, afin de */
/* pouvoir en calculer la derivee formelle... */
-define CTGX(x) \
-_-_-_- fDIVZ(COSX(x),SINX(x))
/* Fonction 'cotangente' circulaire (introduite le 20070713185306)... */
/* */
/* On notera que l'on ne la definit pas par : */
/* */
/* 1 */
/* cotg(theta) = ----------- */
/* tg(theta) */
/* */
/* afin d'alleger l'ecriture et simplifier la gestion du cas ou 'SINX(x)' est nul... */
-define PI_SUR_2 \
-_-_-_- fMOIT(PI)
/* Valeur en radians d'un quart du cercle trigonometrique. On notera le passage de la */
/* fonction 'MOIT(...)' a 'fMOIT(...)' suite a l'introduction du nouveau programme */
/* 'v $xrs/cube.11$I PI_SUR_2' et de problemes de derivation formelle de 'FRAn(...)' */
/* via 'DIVn(...)'. */
-define PI_SUR_3 \
-_-_-_- fTIER(PI)
/* Valeur en radians d'un sixieme du cercle trigonometrique. Ceci fut introduit le */
/* 20070213092213 pour 'v $xiii/di_album$FON PI_SUR_3'... */
-define PI_SUR_4 \
-_-_-_- fQUAR(PI)
/* Valeur en radians d'un huitieme du cercle trigonometrique. On notera le passage de la */
/* fonction 'QUAR(...)' a 'fQUAR(...)' suite a l'introduction du nouveau programme */
/* 'v $xrs/cube.11$I PI_SUR_4' et de problemes de derivation formelle de 'FRAn(...)' */
/* via 'DIVn(...)'. */
-define PI_SUR_5 \
-_-_-_- fFRAn(PI,CINQ)
-define PI_SUR_6 \
-_-_-_- fFRAn(PI,SIX)
-define PI_SUR_7 \
-_-_-_- fFRAn(PI,SEPT)
-define PI_SUR_8 \
-_-_-_- fFRAn(PI,HUIT)
-define PI_SUR_9 \
-_-_-_- fFRAn(PI,NEUF)
-define PI_SUR_10 \
-_-_-_- fFRAn(PI,DIX)
-define PI_SUR_11 \
-_-_-_- fFRAn(PI,ONZE)
-define PI_SUR_12 \
-_-_-_- fFRAn(PI,DOUZE)
/* Definitions introduites le 20230722115035... */
#define RAYON_DU_CERCLE_TRIGONOMETRIQUE \
FU \
/* Rayon du cercle trigonometrique (introduit le 20120522151842)... */
#define CERCLE_TRIGONOMETRIQUE \
DOUB(PI) \
/* Valeur en radians d'un tour complet du cercle trigonometrique... */
#define CERCLE_TRIGONOMETRIQUE_EN_DEGRES \
FLOT(360) \
/* Valeur en degres d'un tour complet du cercle trigonometrique... */ \
/* */ \
/* Le 20050111160612, 'PARE(...)' a ete remplace par 'FLOT(...)' afin de permettre une */ \
/* edition correcte dans 'v $xig/edite$vv$FON CERCLE_TRIGONOMETRIQUE_EN_DEGRES'... */
#define CONVERSION_DEGRES_EN_RADIANS(angle) \
SCAL(angle,CERCLE_TRIGONOMETRIQUE_EN_DEGRES,CERCLE_TRIGONOMETRIQUE)
#define CONVERSION_RADIANS_EN_DEGRES(angle) \
SCAL(angle,CERCLE_TRIGONOMETRIQUE,CERCLE_TRIGONOMETRIQUE_EN_DEGRES)
/* Conversion d'un angle exprime en degres en sa valeur en radians et inverse (introduit */
/* le 20050710123536). */
#define CERCLE_TRIGONOMETRIQUE_EN_GRADES \
FLOT(400) \
/* Valeur en grades d'un tour complet du cercle trigonometrique... */ \
/* */ \
/* Le 20050111160612, 'PARE(...)' a ete remplace par 'FLOT(...)' afin de permettre une */ \
/* edition correcte dans 'v $xig/edite$vv$FON CERCLE_TRIGONOMETRIQUE_EN_GRADES'... */
#define CONVERSION_GRADES_EN_RADIANS(angle) \
SCAL(angle,CERCLE_TRIGONOMETRIQUE_EN_GRADES,CERCLE_TRIGONOMETRIQUE)
#define CONVERSION_RADIANS_EN_GRADES(angle) \
SCAL(angle,CERCLE_TRIGONOMETRIQUE,CERCLE_TRIGONOMETRIQUE_EN_GRADES)
/* Conversion d'un angle exprime en grades en sa valeur en radians et inverse (introduit */
/* le 20050710123536). */
#define CERC(x) \
ATAN(SINX(x),COSX(x)) \
/* Mise d'un angle dans [0,2.PI[... */
#define ACOX(x) \
ACOD(x) \
/* Fonction 'arc-cosinus' definie dans [-1,+1] et a valeurs dans [0,pi], */
#define ASIX(x) \
ASID(x) \
/* Fonction 'arc-sinus' definie dans [-1,+1] et a valeurs dans [-pi/2,+pi/2]. */
#define gATAN(y,x) \
COND(IZGE(ARTG(y,x)),ARTG(y,x),ADD2(ARTG(y,x),CERCLE_TRIGONOMETRIQUE))
#define ATAN(y,x) \
Farc_tangente(FLOT(y),FLOT(x))
/* Arc-tangente de l'argument y/x dans [0,2xPI]. */
/* */
/* La fonction 'Farc_tangente(...)' a introduite le 20161202134722 pour accelerer la */
/* compilation de 'v $xrs/huit.11$I ATAN'... */
-define COHX(x) \
-_-_-_- DIVI(ADD2(EXPX(NEUT(x)),EXPX(NEGA(x))),DEUX)
/* Fonction 'cosinus' hyperbolique. ATTENTION, autrefois, il y avait la definition : */
/* */
/* -define COHX(x) \ */
/* -_-_-_- MOIT(ADD2(EXPX(NEUT(x)),EXPX(NEGA(x)))) */
/* */
/* mais a cause de la derivation formelle, et de l'operateur tres special 'FRAn(...)' qui */
/* sert a definir 'MOIT(...)', il vaut mieux expliciter la division par 2... */
-define SIHX(x) \
-_-_-_- DIVI(SOUS(EXPX(NEUT(x)),EXPX(NEGA(x))),DEUX)
/* Fonction 'sinus' hyperbolique. ATTENTION, autrefois, il y avait la definition : */
/* */
/* -define SIHX(x) \ */
/* -_-_-_- MOIT(SOUS(EXPX(NEUT(x)),EXPX(NEGA(x)))) */
/* */
/* mais a cause de la derivation formelle, et de l'operateur tres special 'FRAn(...)' qui */
/* sert a definir 'MOIT(...)', il vaut mieux expliciter la division par 2... */
-define SIHC(x) \
-_-_-_- COND(IZNE(x),DIVI(SIHX(x),x),FU)
/* Fonction 'sinus' hyperbolique 'Cardinal' (introduite le 20230206104233)... */
-define TAHX(x) \
-_-_-_- DIVI(SIHX(x),COHX(x))
/* Fonction 'tangente' hyperbolique dans [-1,+1]... */
/* */
/* ATTENTION, cette definition presente un certain danger. En effet, bien que sa valeur */
/* soit dans [-1,+1], le fait que l'on passe par des calculs de 'EXPX(...)' implique que si */
/* la valeur de l'argument est trop grande (par exemple 1000), les calculs intermediaires */
/* sont en "overflow", alors que le resultat encore une fois ne devrait pas l'etre... */
/* Ceci s'est vu dans 'v $xrv/map_ND_2D.11$K TAHX' le 19970616184033. */
/* */
/* On notera que l'on ne teste pas la non nullite de 'COHX(x)' car, en effet, par */
/* definition le cosinus hyperbolique, en tant que somme d'exponentielles, ne peut */
/* etre nul... */
-define CSHX(x) \
-_-_-_- INVE(COHX(x))
/* Fonction 'secante' hyperbolique (introduite le 20201017115142)... */
-define SSHX(x) \
-_-_-_- fINVZ(SIHX(x))
/* Fonction 'cosecante' hyperbolique (introduite le 20201017115142)... */
-define CTHX(x) \
-_-_-_- fDIVZ(COHX(x),SIHX(x))
/* Fonction 'cotangente' hyperbolique (introduite le 20070713185306)... */
/* */
/* On notera que l'on ne la definit pas par : */
/* */
/* 1 */
/* coth(theta) = ----------- */
/* th(theta) */
/* */
/* afin d'alleger l'ecriture et simplifier la gestion du cas ou 'SIHX(x)' est nul... */
-define ATAH(x) \
-_-_-_- MOIT(LOGX(DIVI(ADD2(FU,x),SOUS(FU,x))))
/* Fonction 'arc-tangente' hyperbolique (introduite le 20120519173050)... */
-define gCOHX_SIHX(ex,ax,x,bx,ey,ay,y,by,t) \
-_-_-_- LIN2(ex,EXPX(AXPB(ax,x,bx)),ey,EXPX(AXPB(ay,y,by)),t)
/* Fonction 'cosinus/sinus' hyperbolique generalisee (introduite le 20180820172821). */
/* */
/* On notera que : */
/* */
/* gCOHX_SIHX(+1/2,+1,x,0,+1/2,-1,x,0,0) = COHX(x) */
/* gCOHX_SIHX(+1/2,+1,x,0,-1/2,-1,x,0,0) = SIHX(x) */
/* */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N S " V I S I B L E S " D E S F O N C T I O N S M A T H E M A T I Q U E S */
/* U T I L E S P O U R L E S R E S E A U X D E N E U R O N N E S : */
/* */
/*************************************************************************************************************************************/
-define HEAV(x) \
-_-_-_- COND(IZLT(x),FZERO,COND(IZGT(x),FU,FLOT__UNDEF))
/* Fonction de Heaviside ou "fonction echelon unite" (introduite le 20230603135732)... */
-define SIGM(x) \
-_-_-_- INVE(ADD2(FU,EXPX(NEGA(x))))
/* Fonction 'sigmoide' dans [0,1] (introduite le 20230603135732)... */
-define RELU(x) \
-_-_-_- MAX2(FZERO,x)
/* Fonction 'ReLU' ou "Rectified Linear Unit" (introduite le 20230603135732)... */
-define TAHX01(x) \
-_-_-_- AXPB(FDU,TAHX(x),FDU)
/* Fonction 'tangente' hyperbolique dans [0,1] (introduite le 20220509134706)... */
-define TANH01(x) \
-_-_-_- AXPB(FDU,TANH(x),FDU)
/* Fonction 'tangente' hyperbolique dans [0,1] (introduite le 20230605142323), version qui */
/* ne craint pas les debordements contrairement a 'TAHX01(...)' a cause de la definition */
/* de 'TAHX(...)' via des exponentielles 'EXPX(...)'... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N S " V I S I B L E S " D E S F O N C T I O N S M A T H E M A T I Q U E S : */
/* P O S A N T D E S P R O B L E M E S : */
/* */
/*************************************************************************************************************************************/
#define TROP_PETIT(x,epsilon) \
COND(IFGT(ABSO(x),epsilon),x,ZERO) \
/* Fonction ramenant les petites valeurs a 0 pour eviter les 'underflow's... */
#define TROP_GRAND(x,anti_epsilon) \
COND(IFLT(ABSO(x),anti_epsilon),x,MEME_SIGNE_QUE(x,anti_epsilon)) \
/* Fonction ramenant les grandes valeurs au seuil de test ('anti_epsilon')... */
#if (PRECISION_DU_Float==SIMPLE_PRECISION)
# define PETI(x) \
TROP_PETIT(x,pEPSILON) \
/* Fonction ramenant les petites valeurs a 0 pour eviter les 'underflow's lors des passages */ \
/* de double en simple precision... */
#Aif (PRECISION_DU_Float==SIMPLE_PRECISION)
#Eif (PRECISION_DU_Float==SIMPLE_PRECISION)
#if (PRECISION_DU_Float==DOUBLE_PRECISION)
# define PETI(x) \
NEUT(x) \
/* Cette fonction est inutile en double precision... */
#Aif (PRECISION_DU_Float==DOUBLE_PRECISION)
#Eif (PRECISION_DU_Float==DOUBLE_PRECISION)
/* ATTENTION, jusqu'au 20000918172204, il y avait systematiquement ci-apres : */
/* */
/* ((defined(SYSTEME_SG..._IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) */
/* */
/* or il apparait (grace a 'v $Dbugs/SGIND424$D/IRIX$D/CC$D/exp.01$c' ou encore a */
/* 'v $Dbugs/SGO200A2$D/IRIX$D/CC$D/exp.01$c') que toutes les releases subissent ce */
/* mechant "bug", d'ou la modification... */
#if ( (defined(SYSTEME_SG4D20G_IRIX_CC)) \
|| (defined(SYSTEME_SG4D25TG_IRIX_CC)) \
|| (defined(SYSTEME_SG4D310VGX_IRIX_CC)) \
|| (defined(SYSTEME_SG4D35TG_IRIX_CC)) \
|| (defined(SYSTEME_SG4D85GT_IRIX_CC)) \
|| (defined(SYSTEME_SGIND308_IRIX_CC)) \
|| (defined(SYSTEME_SGIND324_IRIX_CC)) \
|| (defined(SYSTEME_SGIND3GA_IRIX_CC)) \
|| (defined(SYSTEME_SGIND408_IRIX_CC)) \
|| (defined(SYSTEME_SGIND424_IRIX_CC)) \
|| (defined(SYSTEME_SGIND4GA_IRIX_CC)) \
|| (defined(SYSTEME_SGIND508_IRIX_CC)) \
|| (defined(SYSTEME_SGIND524_IRIX_CC)) \
|| (defined(SYSTEME_SGIND5GA_IRIX_CC)) \
|| (defined(SYSTEME_SGIND808_IRIX_CC)) \
|| (defined(SYSTEME_SGIND824_IRIX_CC)) \
|| (defined(SYSTEME_SGIND8GA_IRIX_CC)) \
|| (defined(SYSTEME_SGINDA08_IRIX_CC)) \
|| (defined(SYSTEME_SGINDA24_IRIX_CC)) \
|| (defined(SYSTEME_SGINDAGA_IRIX_CC)) \
|| (defined(SYSTEME_SGO200A1_IRIX_CC)) \
|| (defined(SYSTEME_SGO200A2_IRIX_CC)) \
|| (defined(SYSTEME_SGO200A4_IRIX_CC)) \
|| (defined(SYSTEME_SGO25224_IRIX_CC)) \
|| (defined(SYSTEME_SGO252VA_IRIX_CC)) \
|| (defined(SYSTEME_SGO252VN_IRIX_CC)) \
|| (defined(SYSTEME_SGPCM801_IRIX_CC)) \
|| (defined(SYSTEME_SGPCMA01_IRIX_CC)) \
)
# TestADef BUG_SYSTEME_SG_C_pow \
/* 'pow(...)' peut faire un UNDERFLOW ('v $Dbugs/SGIND424$D/IRIX$D/CC$D/exp.01$c'). */
#Aif ( (defined(SYSTEME_SG4D20G_IRIX_CC)) \
|| (defined(SYSTEME_SG4D25TG_IRIX_CC)) \
|| (defined(SYSTEME_SG4D310VGX_IRIX_CC)) \
|| (defined(SYSTEME_SG4D35TG_IRIX_CC)) \
|| (defined(SYSTEME_SG4D85GT_IRIX_CC)) \
|| (defined(SYSTEME_SGIND308_IRIX_CC)) \
|| (defined(SYSTEME_SGIND324_IRIX_CC)) \
|| (defined(SYSTEME_SGIND3GA_IRIX_CC)) \
|| (defined(SYSTEME_SGIND408_IRIX_CC)) \
|| (defined(SYSTEME_SGIND424_IRIX_CC)) \
|| (defined(SYSTEME_SGIND4GA_IRIX_CC)) \
|| (defined(SYSTEME_SGIND508_IRIX_CC)) \
|| (defined(SYSTEME_SGIND524_IRIX_CC)) \
|| (defined(SYSTEME_SGIND5GA_IRIX_CC)) \
|| (defined(SYSTEME_SGIND808_IRIX_CC)) \
|| (defined(SYSTEME_SGIND824_IRIX_CC)) \
|| (defined(SYSTEME_SGIND8GA_IRIX_CC)) \
|| (defined(SYSTEME_SGINDA08_IRIX_CC)) \
|| (defined(SYSTEME_SGINDA24_IRIX_CC)) \
|| (defined(SYSTEME_SGINDAGA_IRIX_CC)) \
|| (defined(SYSTEME_SGO200A1_IRIX_CC)) \
|| (defined(SYSTEME_SGO200A2_IRIX_CC)) \
|| (defined(SYSTEME_SGO200A4_IRIX_CC)) \
|| (defined(SYSTEME_SGO25224_IRIX_CC)) \
|| (defined(SYSTEME_SGO252VA_IRIX_CC)) \
|| (defined(SYSTEME_SGO252VN_IRIX_CC)) \
|| (defined(SYSTEME_SGPCM801_IRIX_CC)) \
|| (defined(SYSTEME_SGPCMA01_IRIX_CC)) \
)
#Eif ( (defined(SYSTEME_SG4D20G_IRIX_CC)) \
|| (defined(SYSTEME_SG4D25TG_IRIX_CC)) \
|| (defined(SYSTEME_SG4D310VGX_IRIX_CC)) \
|| (defined(SYSTEME_SG4D35TG_IRIX_CC)) \
|| (defined(SYSTEME_SG4D85GT_IRIX_CC)) \
|| (defined(SYSTEME_SGIND308_IRIX_CC)) \
|| (defined(SYSTEME_SGIND324_IRIX_CC)) \
|| (defined(SYSTEME_SGIND3GA_IRIX_CC)) \
|| (defined(SYSTEME_SGIND408_IRIX_CC)) \
|| (defined(SYSTEME_SGIND424_IRIX_CC)) \
|| (defined(SYSTEME_SGIND4GA_IRIX_CC)) \
|| (defined(SYSTEME_SGIND508_IRIX_CC)) \
|| (defined(SYSTEME_SGIND524_IRIX_CC)) \
|| (defined(SYSTEME_SGIND5GA_IRIX_CC)) \
|| (defined(SYSTEME_SGIND808_IRIX_CC)) \
|| (defined(SYSTEME_SGIND824_IRIX_CC)) \
|| (defined(SYSTEME_SGIND8GA_IRIX_CC)) \
|| (defined(SYSTEME_SGINDA08_IRIX_CC)) \
|| (defined(SYSTEME_SGINDA24_IRIX_CC)) \
|| (defined(SYSTEME_SGINDAGA_IRIX_CC)) \
|| (defined(SYSTEME_SGO200A1_IRIX_CC)) \
|| (defined(SYSTEME_SGO200A2_IRIX_CC)) \
|| (defined(SYSTEME_SGO200A4_IRIX_CC)) \
|| (defined(SYSTEME_SGO25224_IRIX_CC)) \
|| (defined(SYSTEME_SGO252VA_IRIX_CC)) \
|| (defined(SYSTEME_SGO252VN_IRIX_CC)) \
|| (defined(SYSTEME_SGPCM801_IRIX_CC)) \
|| (defined(SYSTEME_SGPCMA01_IRIX_CC)) \
)
/* ATTENTION, je conserve la definition 'EXPX(...)' qui suit, en la rebaptisant 'EXEX(...)', */
/* simplement parce que je n'aime pas jeter les choses sophistiquees... */
#if ( (! defined(MODE_TEST_OVERFLOW_ET_UNDERFLOW)) \
|| ( (! defined(BUG_SYSTEME_SG_C_pow)) \
) \
)
# define EXEX(x) \
PUIX(EN,x) \
/* Exponentielle de 'x'. */ \
/* */ \
/* ATTENTION, on notera que la conditionnalite de la definition de 'EXEX(...)' empeche */ \
/* (provisoirement ?) d'en definir la derivee puisque l'extraction des definitions faite */ \
/* lors de '$PASSE_D' par '$xcc/cpp$Z' ne prend pas en compte les conditionnalites... */
#Aif ( (! defined(MODE_TEST_OVERFLOW_ET_UNDERFLOW)) \
|| ( (! defined(BUG_SYSTEME_SG_C_pow)) \
) \
)
/* ATTENTION, la methode actuellement implementee ne corrige le defaut que lorsque la */
/* fonction 'pow(...)' est appelee via 'EXEX(...)'. Dans le cas ou elle est appelee via */
/* 'PUIX(...)' rien n'est fait, car en effet, je ne vois pas comment faire, si ce n'est */
/* en la reprogrammant... */
# define BORNE_INFERIEURE_DE_L_ARGUMENT_D_UNE_EXPONENTIELLE \
FLOT(NEGA(708)) \
/* Voir le programme 'v $Dbugs/SGIND424$D/IRIX$D/CC$D/exp.01$c' pour plus de commentaires... */
# define EXEX(x) \
COND(IFGE(x,BORNE_INFERIEURE_DE_L_ARGUMENT_D_UNE_EXPONENTIELLE),PUIX(EN,x),FZERO) \
/* Exponentielle de 'x'. ATTENTION, il ne faut surtout pas ecrire : */ \
/* */ \
/* fCOND(IFGE(x,...),PUIX(EN,x),FZERO) */ \
/* */ \
/* car, en effet, 'fCOND(...)' etant une "vraie" fonction, ses trois arguments sont evalues */ \
/* et en particulier 'PUIX(EN,x)' l'est systematiquement, quel que soit le resultat du test */ \
/* 'IFGE(...)', ce que l'on souhaite precisemment eviter... */ \
/* */ \
/* ATTENTION, on notera que la conditionnalite de la definition de 'EXEX(...)' empeche */ \
/* (provisoirement ?) d'en definir la derivee puisque l'extraction des definitions faite */ \
/* lors de '$PASSE_D' par '$xcc/cpp$Z' ne prend pas en compte les conditionnalites... */
#Eif ( (! defined(MODE_TEST_OVERFLOW_ET_UNDERFLOW)) \
|| ( (! defined(BUG_SYSTEME_SG_C_pow)) \
) \
)
#if ( ((defined(SYSTEME_SG4D20G_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SG4D25TG_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SG4D310VGX_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SG4D35TG_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SG4D85GT_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGIND308_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGIND324_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGIND3GA_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGIND408_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGIND424_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGIND4GA_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGIND508_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGIND524_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGIND5GA_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGIND808_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGIND824_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGIND8GA_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGINDA08_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGINDA24_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGINDAGA_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGO200A1_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGO200A2_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGO200A4_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGO25224_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGO252VA_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGO252VN_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGPCM801_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGPCMA01_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
)
# TestADef BUG_SYSTEME_SG_C_exp \
/* 'exp(...)' peut faire un UNDERFLOW ('v $Dbugs/SGIND424$D/IRIX$D/CC$D/exp.01$c'). */
#Aif ( ((defined(SYSTEME_SG4D20G_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SG4D25TG_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SG4D310VGX_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SG4D35TG_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SG4D85GT_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGIND308_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGIND324_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGIND3GA_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGIND408_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGIND424_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGIND4GA_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGIND508_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGIND524_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGIND5GA_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGIND808_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGIND824_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGIND8GA_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGINDA08_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGINDA24_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGINDAGA_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGO200A1_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGO200A2_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGO200A4_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGO25224_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGO252VA_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGO252VN_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGPCM801_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGPCMA01_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
)
#Eif ( ((defined(SYSTEME_SG4D20G_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SG4D25TG_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SG4D310VGX_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SG4D35TG_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SG4D85GT_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGIND308_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGIND324_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGIND3GA_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGIND408_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGIND424_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGIND4GA_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGIND508_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGIND524_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGIND5GA_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGIND808_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGIND824_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGIND8GA_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGINDA08_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGINDA24_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGINDAGA_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGO200A1_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGO200A2_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGO200A4_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGO25224_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGO252VA_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGO252VN_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGPCM801_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
|| ((defined(SYSTEME_SGPCMA01_IRIX_CC)) && (nSYSTEM_RELEASE < 503000000)) \
)
#if ( (! defined(MODE_TEST_OVERFLOW_ET_UNDERFLOW)) \
|| ( (! defined(BUG_SYSTEME_SG_C_exp)) \
) \
)
# define EXPB(x) \
EXPX(x) \
/* Exponentielle de 'x'. */ \
/* */ \
/* ATTENTION, on notera que la conditionnalite de la definition de 'EXPB(...)' empeche */ \
/* (provisoirement ?) d'en definir la derivee puisque l'extraction des definitions faite */ \
/* lors de '$PASSE_D' par '$xcc/cpp$Z' ne prend pas en compte les conditionnalites... */
#Aif ( (! defined(MODE_TEST_OVERFLOW_ET_UNDERFLOW)) \
|| ( (! defined(BUG_SYSTEME_SG_C_exp)) \
) \
)
# define EXPB(x) \
EXEX(x) \
/* Exponentielle de 'x'. */ \
/* */ \
/* ATTENTION, on notera que la conditionnalite de la definition de 'EXPB(...)' empeche */ \
/* (provisoirement ?) d'en definir la derivee puisque l'extraction des definitions faite */ \
/* lors de '$PASSE_D' par '$xcc/cpp$Z' ne prend pas en compte les conditionnalites... */
#Eif ( (! defined(MODE_TEST_OVERFLOW_ET_UNDERFLOW)) \
|| ( (! defined(BUG_SYSTEME_SG_C_exp)) \
) \
)
#define EXba(base,x) \
PUIX(base,x) \
/* Exponentielle de 'x' en base quelconque (introduite le 20230321184059). */
#define EX10(x) \
EXba(FBASE10,x) \
/* Exponentielle de 'x' en base 10. */
#define EX02(x) \
EXba(FBASE2,x) \
/* Exponentielle de 'x' en base 2 (introduite le 20171129104549). */
#define GAUS(x,esperance,ecart_type) \
EXPB(NEGA(DIVI(EXP2(SOUS(x,esperance)),DOUB(EXP2(ecart_type)))))
#define DGAUS(x,esperance,ecart_type) \
DIVI(GAUS(x,esperance,ecart_type) \
,MUL2(ecart_type,RACX(CERCLE_TRIGONOMETRIQUE)) \
)
/* Distribution normale dite "gaussienne" (introduite le 20091116160705). Au passage, */
/* 'esperance' est la moyenne de 'x' et 'EXP2(ecart_type)' est la 'variance' (quand */
/* cette derniere augmente, la courbe en cloche s'aplatit et s'elargit...). La 'variance' */
/* est egale a la somme des carres des ecarts a la moyenne ponderes par les probabilites */
/* correspondantes. */
/* */
/* En resume : */
/* */
/* i=N */
/* ----- */
/* 1 \ */
/* M = --- / X Esperance (Moyenne) */
/* N ----- i */
/* i=1 */
/* */
/* */
/* i=N */
/* ----- */
/* 1 \ 2 */
/* V = --- / (X - M) Variance */
/* N ----- i */
/* i=1 */
/* */
/* */
/* ___ */
/* / */
/* S = \/ V Sigma (EcartType) */
/* */
/* */
/* 2 */
/* (x-M) */
/* - -------- */
/* 2 */
/* 1 2.S */
/* P(x) = -------------.e DensiteProbabilite */
/* ______ */
/* / */
/* S.\/ 2.pi */
/* */
/* */
/* Pour une raison mysterieuse, jusqu'au 20110325100259 etait utilisee 'SQRT(...)' ci-dessus */
/* (qui n'a jamais existe me semble-t-il...) a la place de 'RACX(...)'. */
/* */
/* On notera que 'GAUS(...)' donne une valeur dans [0,1] contrairement a 'DGAUS(...)'... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* A N A L Y S E C O M B I N A T O I R E : */
/* */
/*************************************************************************************************************************************/
#define ARnm(n,m) \
DIVI(INTE(FACT(n)),INTE(FACT(SOUS(n,m)))) \
/* Nombre d'ARrangements de 'n' objets 'm' a 'm' (introduit le 20090426121205) avec */ \
/* evidemment n<=m... */ \
/* */ \
/* Exemple (m=2, n=3) : */ \
/* */ \
/* arrangements 2 a 2 des 3 elements {a,b,c} = {ab,ac,bc,ba,ca,cb} */ \
/* */ \
/* en notant donc que l'ordre intervient. */ \
/* */ \
/* On rappelle que : */ \
/* */ \
/* m n! */ \
/* A = -------- */ \
/* n (n-m)! */ \
/* */
#define PERn(n) \
ARnm(n,n) \
/* Nombre de PERmutations de 'n' objets (introduit le 20090426121205). */ \
/* */ \
/* Exemple : */ \
/* */ \
/* permutations des 3 elements {a,b,c} = {abc,bca,cab,cba,bac,acb} */ \
/* */ \
/* en notant donc que l'ordre intervient. */
#define COnm(n,m) \
DIVI(ARnm(n,m),PERn(m)) \
/* Nombre de COmbinaisons de 'n' objets 'm' a 'm' (introduit le 20090426121205). */ \
/* */ \
/* Exemple (m=2, n=3) : */ \
/* */ \
/* combinaisons 2 a 2 des 3 elements {a,b,c} = {ab,ac,bc} */ \
/* */ \
/* en notant donc que l'ordre n'intervient pas. */ \
/* */ \
/* On rappelle que : */ \
/* */ \
/* m */ \
/* A */ \
/* m | n | n n! */ \
/* C = | | = ---- = ---------- */ \
/* n | m | m! m!(n-m)! */ \
/* */ \
/* */ \
/* Le 20200321111808, je rappelle de plus que : */ \
/* */ \
/* */ \
/* n 0 n-0 0 1 n-1 1 2 n-2 2 n n-n n */ \
/* (a+b) = C .a .b + C .a .b + C .a .b + (...) + C .a .b */ \
/* n n n n */ \
/* */ \
/* */ \
/* C'est le binome de Newton... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* A P P R O X I M A T I O N D E C E R T A I N E S F O N C T I O N S M A T H E M A T I Q U E S : */
/* */
/*************************************************************************************************************************************/
-define COSA(x) \
-_-_-_- SOUS(DIVI(EXP0(x),MUL0(FZERO)) \
-_-_-_- ,DIVI(EXP2(x),MUL2(FU,FDEUX)) \
-_-_-_- )
/* Approximation du cosinus de 'x' par un developpement limite a 2 termes : */
/* */
/* 0 2 */
/* x x */
/* cos(x) = ---- - ---- */
/* 0! 2! */
/* */
/* mais ATTENTION, cela n'ayant de sens que pour les faibles valeurs de 'x' (devant 1)... */
-define SINA(x) \
-_-_-_- SOUS(DIVI(EXP1(x),MUL1(FU)) \
-_-_-_- ,DIVI(EXP3(x),MUL3(FU,FDEUX,FTROIS)) \
-_-_-_- )
/* Approximation du sinus de 'x' par un developpement limite a 2 termes : */
/* */
/* 1 3 */
/* x x */
/* sin(x) = ---- - ---- */
/* 1! 3! */
/* */
/* mais ATTENTION, cela n'ayant de sens que pour les faibles valeurs de 'x' (devant 1)... */
#define RACA(x) \
DIVI(GRO1(HORNER_1_02(x,UN,SIX,UN)) \
,GRO4(HORNER_1_01(x,UN,UN)) \
) \
/* Approximation de la racine carree de 'x' par la methode de Newton : */ \
/* */ \
/* 1 x */ \
/* U = ---.(U + ---) */ \
/* n+1 2 n U */ \
/* n */ \
/* avec : */ \
/* */ \
/* U = 1. */ \
/* 0 */ \
/* */ \
/* logarithme base 2 de 'x' en double-precision. */
#define FACA(x) \
MUL2(SPUIX(DIVI(x,EN),x),SRACX(MUL3(FDEUX,PI,x))) \
/* Approximation de la fonction 'factorielle' par la formule de Stirling (ceci fut introduit */ \
/* le 20180826093441 juste pour voir...). On notera le traitement du cas ou 'x' est negatif. */ \
/* */ \
/* Le 20180827093316, le nom 'FACT_Stirling(...)' a ete remplace par 'FACA(...)' qui */ \
/* correspond mieux aux noms des fonctions "Approchees"... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N D E S D E R I V E E S D E S F O N C T I O N S M A T H E M A T I Q U E S : */
/* */
/*************************************************************************************************************************************/
#define d_F_de_G(derivee_de_F,G) \
MUL2(derivee_de_F,d#G) \
/* Derivee d'une fonction de fonction : */ \
/* */ \
/* d(F(G(x)) d(F(u)) du */ \
/* ---------- = -------- .---- */ \
/* dx du dx */ \
/* */ \
/* avec : */ \
/* */ \
/* u = G(x) */ \
/* */
#define d_RACX(x) \
d_F_de_G(INVE(GRO2(RACX(x))),x) \
/* Derivee de la fonction racine carree : */ \
/* */ \
/* _ 1 */ \
/* d(\/x ) = ------- .dx */ \
/* _ */ \
/* 2.\/x */ \
/* */
#define d_LOGX(x) \
d_F_de_G(INVZ(x),x)
#define d_LO1X(x) \
DIVI(d_LOGX(x),LOGX(FBASE10))
/* Derivee de la fonction logarithme : */
/* */
/* 1 */
/* d(log(x)) = ---.dx */
/* x */
/* */
#define d_PUIX(x,y) \
d_F_de_G(PUIX(x,y),MUL2(y,LOGX(x))) \
/* Derivee de la fonction exponentielle generalisee : */ \
/* */ \
/* y */ \
/* f(x,y) = x */ \
/* */ \
/* log(f(x,y)) = y.log(x) */ \
/* */ \
/* d(log(f(x,y))) = d(y.log(x)) */ \
/* */ \
/* or : */ \
/* */ \
/* d(f(x,y)) */ \
/* d(log(f(x,y))) = ----------- */ \
/* f(x,y) */ \
/* */ \
/* d'ou : */ \
/* */ \
/* d(f(x,y)) */ \
/* ----------- = d(y.log(x)) */ \
/* f(x,y) */ \
/* */ \
/* et donc : */ \
/* */ \
/* d(f(x,y)) = f(x,y).d(y.log(x)) */ \
/* */ \
/* Mais ATTENTION, il faut : */ \
/* */ \
/* x > 0 */ \
/* */ \
/* puisque l'on prend son logarithme, d'ou l'introduction de la fonction 'MONX(...)' pour */ \
/* traiter simplement le cas des exponentiations entieres... */ \
/* */
#define d_MONX(x,n) \
d_F_de_G(COND(IZNE(n),MUL2(n,MONX(x,PRED(n))),ZERO),x) \
/* Derivee de la fonction puissance entiere : */ \
/* */ \
/* n n-1 */ \
/* d(x ) = n.x .dx */ \
/* */ \
/* ATTENTION, on notera bien que la fonction 'MONX(...)' n'a ete introduite que pour */ \
/* resoudre le cas ou 'x' est negatif dans 'PUIX(...)', malheureusement uniquement lorsque */ \
/* 'y' est entier ('n'). Enfin, le test de nullite de l'exposant 'n' est destine a eviter */ \
/* alors l'execution de : */ \
/* */ \
/* MONX(x,PRED(n)) */ \
/* */ \
/* soit : */ \
/* */ \
/* MONX(x,PRED(0)) */ \
/* */ \
/* ou encore : */ \
/* */ \
/* MONX(x,-1) */ \
/* */ \
/* ce qui serait problematique dans le cas ou 'x' serait nul, puisque cela reviendrait a */ \
/* diviser par 0... */ \
/* */
#define d_EXPX(x) \
d_F_de_G(EXPX(x),x) \
/* Derivee de la fonction exponentielle : */ \
/* */ \
/* d(exp(x)) = exp(x).dx */ \
/* */
#define d_COSX(x) \
d_F_de_G(NEGA(SINX(x)),x) \
/* Derivee de la fonction cosinus : */ \
/* */ \
/* d(cos(x)) = -sin(x).dx */ \
/* */
#define d_SINX(x) \
d_F_de_G(NEUT(COSX(x)),x) \
/* Derivee de la fonction sinus : */ \
/* */ \
/* d(sin(x)) = +cos(x).dx */ \
/* */
#define d_ATAN(y,x) \
ADD2(d_F_de_G(INVE(ADD2(FU,EXP2(DIVI(y,x)))),x),d_F_de_G(INVE(ADD2(FU,EXP2(DIVI(y,x)))),y)) \
/* Derivee de la fonction arc-tangente : */ \
/* */ \
/* 1 */ \
/* d(arctg(y,x)) = ---------- */ \
/* 2 */ \
/* y */ \
/* 1 + ---- */ \
/* 2 */ \
/* x */ \
/* */ \
/* Elle a ete introduite le 20161202134722... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* Q U E L Q U E S P R I M I T I V E S : */
/* */
/*************************************************************************************************************************************/
#define p_PUIX(x,n) \
MUL2(INVE(SUCC(INTE(n))),MUL2(x,PUIX(x,INTE(n)))) \
/* Primitive de 'x' a la puissance entiere 'n' (introduite le 20200321112442), en notant */ \
/* que l'on neglige le "+constante" evidemment... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* O P T M I S A T I O N " S P A T I A L E " E T " T E M P O R E L L E " */
/* D E C E R T A I N S O P E R A T E U R S : */
/* */
/*************************************************************************************************************************************/
/* Introduit le 20190730152917 suite a des tests avec 'v $xtc/BlocInstructions.03$c' (par */
/* exemple). Le but etant donc de ne calculer qu'une seule fois les arguments {a,b,...} ce */
/* qui Optimise donc a la fois spatialement (en nombre d'instructions) et temporellement */
/* l'operateur correspondant. En contre-partie, il faut fixer un type a priori et c'est */
/* 'Float', le plus "general", qui a ete choisi... Un autre inconvenient est qu'il est */
/* impossible de deriver formellement... */
#define oDIV0(a,b,c,d) \
PARE( \
Bblock \
DEFV(Float,INIT(a_optimise,FLOT(a))); \
DEFV(Float,INIT(b_optimise,FLOT(b))); \
DEFV(Float,INIT(c_optimise,FLOT(c))); \
DEFV(Float,INIT(d_optimise,FLOT(d))); \
/* Calcul une seule fois des quatre arguments {a,b,c,d}. */ \
\
DIV0(a_optimise,b_optimise,c_optimise,d_optimise); \
/* Division Optimisee... */ \
Eblock \
) \
/* Introduit le 20190730152917... */
#define oMIN2(a,b) \
PARE( \
Bblock \
DEFV(Float,INIT(a_optimise,FLOT(a))); \
DEFV(Float,INIT(b_optimise,FLOT(b))); \
/* Calcul une seule fois des deux arguments {a,b}. */ \
\
MIN2(a_optimise,b_optimise); \
/* Minimum Optimise... */ \
Eblock \
) \
/* Introduit le 20190731093101... */
#define oMAX2(a,b) \
PARE( \
Bblock \
DEFV(Float,INIT(a_optimise,FLOT(a))); \
DEFV(Float,INIT(b_optimise,FLOT(b))); \
/* Calcul une seule fois des deux arguments {a,b}. */ \
\
MAX2(a_optimise,b_optimise); \
/* Maximum Optimise... */ \
Eblock \
) \
/* Introduit le 20190731093101... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* B A S E S D E N U M E R A T I O N : */
/* */
/*************************************************************************************************************************************/
#define BASE2 \
DEUX \
/* Definition de la base binaire. */
-define FBASE2 \
-_-_-_- FLOT(BASE2)
/* Definition de la base binaire (en flottant...). */
#define BASE10 \
DIX \
/* Definition de la base decimale. */
#define FBASE10 \
FLOT(BASE10) \
/* Definition de la base decimale (en flottant...). Elle fut introduite le 20171129104549... */
#define BASE16 \
SLLS(BIT,NBITHX) \
/* Definition de la base hexa-decimale. */
#define DEUXp2 \
EXP2(BASE2)
#define DEUXp3 \
EXP3(BASE2)
#define DEUXp4 \
bMUL(DEUXp3,BASE2)
#define DEUXp5 \
bMUL(DEUXp4,BASE2)
#define DEUXp6 \
bMUL(DEUXp5,BASE2)
#define DEUXp7 \
bMUL(DEUXp6,BASE2)
#define DEUXp8 \
bMUL(DEUXp7,BASE2)
#define DEUXp9 \
bMUL(DEUXp8,BASE2)
#define DEUXp10 \
bMUL(DEUXp9,BASE2)
#define DEUXp15 \
bMUL(DEUXp8,DEUXp7) \
/* Definition de 2 a la puissance 15 (en entier), */
#define DEUXp16 \
EXP2(DEUXp8) \
/* Definition de 2 a la puissance 16 (en entier), */
#define DEUXp31M1 \
PRED(bMUL(DEUXp16,DEUXp15)) \
/* Definition de 2 a la puissance 31 moins 1 (en entier) qui est notons le un */ \
/* nombre premier du type "de Mersenne". ATTENTION, l'ecriture : */ \
/* */ \
/* VINTE(DEUXp31M1) */ \
/* */ \
/* est fausse car 'DEUXp31M1' est vu alors comme un nombre entier negatif, et la valeur */ \
/* renvoyee est egale a 'DEUXp31M1 - 2'... */
#define FDEUXp2 \
bMUL(FBASE2,FBASE2)
#define FDEUXp3 \
bMUL(FDEUXp2,FBASE2)
#define FDEUXp4 \
bMUL(FDEUXp3,FBASE2)
#define FDEUXp7 \
bMUL(FDEUXp4,FDEUXp3) \
/* Definition de 2 a la puissance 7 (en flottant), */
#define FDEUXp8 \
bMUL(FDEUXp7,FBASE2) \
/* Definition de 2 a la puissance 8 (en flottant), */
#define FDEUXp15 \
bMUL(FDEUXp8,FDEUXp7) \
/* Definition de 2 a la puissance 15 (en flottant), */
#define FDEUXp16 \
bMUL(FDEUXp15,FBASE2) \
/* Definition de 2 a la puissance 16 (en flottant), */
#define k___FDEUXp30 \
bMUL(FDEUXp15,FDEUXp15) \
/* Definition de 2 a la puissance 30 (en flottant), */ \
/* */ \
/* ATTENTION : la constante 'FDEUXp30' est pre-generee dans '$xcp/Konstantes$K'. */ \
/* */ \
/* Cette pre-generation a ete introduite pour lutter contre le bug rencontre la premiere */ \
/* fois dans la fonction 'chain_numero(...)' de '$xig/fonct$vv$FON' via la commande */ \
/* '$xci/nombres$K'. Ce bug est decrit dans 'v $Dbugs/SGIND424$D/IRIX$D/CC$D/log10.01$c' de */ \
/* facon synthetique... Mais ATTENTION, elle avait ete introduite pour 'FDEUXp31' ; or cela */ \
/* a pose deux problemes : d'une part la procedure 'DEFINEF(...)' de '$xig/definit.2$DEF' */ \
/* utilisee par '$xcp/Konstantes$K' utilise 'VINTE(...)' ce qui ne convient pas pour la */ \
/* constante 'FDEUXp31' qui peut etre vue comme une constante entiere negative ; d'autre */ \
/* part dans le fonction 'chain_numero(...)' il vaut mieux utiliser la constante 'FDEUXp30' */ \
/* que 'FDEUXp31' pour connaitre la capacite d'un mot... */
#define FDEUXp31 \
bMUL(FDEUXp16,FDEUXp15) \
/* Definition de 2 a la puissance 31 (en flottant), */
#define FDEUXp32 \
bMUL(FDEUXp31,FBASE2) \
/* Definition de 2 a la puissance 32 (en flottant). */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* " P R E - G E N E R A T I O N " D E S C O N S T A N T E S F O N D A M E N T A L E S : */
/* */
/*************************************************************************************************************************************/
#TestADef FDEUXp30 \
k___FDEUXp30
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* C O N S T A N T E S M A T H E M A T I Q U E S D E B A S E : */
/* */
/*************************************************************************************************************************************/
#define VERITABLE_PREMIER_NOMBRE_PREMIER \
DEUX \
/* Definition du premier nombre premier, qui est pair (introduit le 20130112102534)... */
-define PI \
-_-_-_- PARE(3.14159265358979323846)
/* Fabuleuse constante universelle qui me fait rever... */
#if ( (defined(SYSTEME_CRAY2_UNICOS_CC)) \
|| (defined(SYSTEME_CRAYC98_UNICOS_CC)) \
|| (defined(SYSTEME_CRAYC916_UNICOS_CC)) \
|| (defined(SYSTEME_CRAYYMP1_UNICOS_CC)) \
|| (defined(SYSTEME_CRAYYMP2_UNICOS_CC)) \
|| (defined(SYSTEME_CRAYYMP4_UNICOS_CC)) \
|| (defined(SYSTEME_SG4D20G_IRIX_CC)) \
|| (defined(SYSTEME_SG4D25TG_IRIX_CC)) \
|| (defined(SYSTEME_SG4D310VGX_IRIX_CC)) \
|| (defined(SYSTEME_SG4D35TG_IRIX_CC)) \
|| (defined(SYSTEME_SG4D85GT_IRIX_CC)) \
|| (defined(SYSTEME_SGIND308_IRIX_CC)) \
|| (defined(SYSTEME_SGIND324_IRIX_CC)) \
|| (defined(SYSTEME_SGIND3GA_IRIX_CC)) \
|| (defined(SYSTEME_SGIND408_IRIX_CC)) \
|| (defined(SYSTEME_SGIND424_IRIX_CC)) \
|| (defined(SYSTEME_SGIND4GA_IRIX_CC)) \
|| (defined(SYSTEME_SGIND508_IRIX_CC)) \
|| (defined(SYSTEME_SGIND524_IRIX_CC)) \
|| (defined(SYSTEME_SGIND5GA_IRIX_CC)) \
|| (defined(SYSTEME_SGIND808_IRIX_CC)) \
|| (defined(SYSTEME_SGIND824_IRIX_CC)) \
|| (defined(SYSTEME_SGIND8GA_IRIX_CC)) \
|| (defined(SYSTEME_SGINDA08_IRIX_CC)) \
|| (defined(SYSTEME_SGINDA24_IRIX_CC)) \
|| (defined(SYSTEME_SGINDAGA_IRIX_CC)) \
|| (defined(SYSTEME_SGO200A1_IRIX_CC)) \
|| (defined(SYSTEME_SGO200A2_IRIX_CC)) \
|| (defined(SYSTEME_SGO200A4_IRIX_CC)) \
|| (defined(SYSTEME_SGO25224_IRIX_CC)) \
|| (defined(SYSTEME_SGO252VA_IRIX_CC)) \
|| (defined(SYSTEME_SGO252VN_IRIX_CC)) \
|| (defined(SYSTEME_SGPCM801_IRIX_CC)) \
|| (defined(SYSTEME_SGPCMA01_IRIX_CC)) \
|| (defined(SYSTEME_VAX8600_ULTRIX_CC)) \
|| (defined(SYSTEME_VAX9000_ULTRIX_CC)) \
)
/* Pour les compilateurs ne supportant pas dans les dimensionnements de tableaux de */
/* constantes flottantes (meme castees en entier...), la solution sera de passer pour */
/* les dimensions qui contiennent des valeurs flottantes, par des constantes "pre-generees" */
/* via le programme '$xcp/constantes$K' ; on verra par exemple 'LONGUEUR_DE_L_ONDELETTE_1D' */
/* avec profit... */
# TestADef BUG_SYSTEME_C_dimensions_flottantes \
/* Le compilateur 'cc' ne supporte pas, dans les dimensionnements de tableaux, de */ \
/* constantes flottantes (meme castees en entier...). ATTENTION, ce bug est defini, mais */ \
/* n'est pas utilise (car je ne sais pas comment le prendre en compte automatiquement). */
#Aif ( (defined(SYSTEME_CRAY2_UNICOS_CC)) \
|| (defined(SYSTEME_CRAYC98_UNICOS_CC)) \
|| (defined(SYSTEME_CRAYC916_UNICOS_CC)) \
|| (defined(SYSTEME_CRAYYMP1_UNICOS_CC)) \
|| (defined(SYSTEME_CRAYYMP2_UNICOS_CC)) \
|| (defined(SYSTEME_CRAYYMP4_UNICOS_CC)) \
|| (defined(SYSTEME_SG4D20G_IRIX_CC)) \
|| (defined(SYSTEME_SG4D25TG_IRIX_CC)) \
|| (defined(SYSTEME_SG4D310VGX_IRIX_CC)) \
|| (defined(SYSTEME_SG4D35TG_IRIX_CC)) \
|| (defined(SYSTEME_SG4D85GT_IRIX_CC)) \
|| (defined(SYSTEME_SGIND308_IRIX_CC)) \
|| (defined(SYSTEME_SGIND324_IRIX_CC)) \
|| (defined(SYSTEME_SGIND3GA_IRIX_CC)) \
|| (defined(SYSTEME_SGIND408_IRIX_CC)) \
|| (defined(SYSTEME_SGIND424_IRIX_CC)) \
|| (defined(SYSTEME_SGIND4GA_IRIX_CC)) \
|| (defined(SYSTEME_SGIND508_IRIX_CC)) \
|| (defined(SYSTEME_SGIND524_IRIX_CC)) \
|| (defined(SYSTEME_SGIND5GA_IRIX_CC)) \
|| (defined(SYSTEME_SGIND808_IRIX_CC)) \
|| (defined(SYSTEME_SGIND824_IRIX_CC)) \
|| (defined(SYSTEME_SGIND8GA_IRIX_CC)) \
|| (defined(SYSTEME_SGINDA08_IRIX_CC)) \
|| (defined(SYSTEME_SGINDA24_IRIX_CC)) \
|| (defined(SYSTEME_SGINDAGA_IRIX_CC)) \
|| (defined(SYSTEME_SGO200A1_IRIX_CC)) \
|| (defined(SYSTEME_SGO200A2_IRIX_CC)) \
|| (defined(SYSTEME_SGO200A4_IRIX_CC)) \
|| (defined(SYSTEME_SGO25224_IRIX_CC)) \
|| (defined(SYSTEME_SGO252VA_IRIX_CC)) \
|| (defined(SYSTEME_SGO252VN_IRIX_CC)) \
|| (defined(SYSTEME_SGPCM801_IRIX_CC)) \
|| (defined(SYSTEME_SGPCMA01_IRIX_CC)) \
|| (defined(SYSTEME_VAX8600_ULTRIX_CC)) \
|| (defined(SYSTEME_VAX9000_ULTRIX_CC)) \
)
#Eif ( (defined(SYSTEME_CRAY2_UNICOS_CC)) \
|| (defined(SYSTEME_CRAYC98_UNICOS_CC)) \
|| (defined(SYSTEME_CRAYC916_UNICOS_CC)) \
|| (defined(SYSTEME_CRAYYMP1_UNICOS_CC)) \
|| (defined(SYSTEME_CRAYYMP2_UNICOS_CC)) \
|| (defined(SYSTEME_CRAYYMP4_UNICOS_CC)) \
|| (defined(SYSTEME_SG4D20G_IRIX_CC)) \
|| (defined(SYSTEME_SG4D25TG_IRIX_CC)) \
|| (defined(SYSTEME_SG4D310VGX_IRIX_CC)) \
|| (defined(SYSTEME_SG4D35TG_IRIX_CC)) \
|| (defined(SYSTEME_SG4D85GT_IRIX_CC)) \
|| (defined(SYSTEME_SGIND308_IRIX_CC)) \
|| (defined(SYSTEME_SGIND324_IRIX_CC)) \
|| (defined(SYSTEME_SGIND3GA_IRIX_CC)) \
|| (defined(SYSTEME_SGIND408_IRIX_CC)) \
|| (defined(SYSTEME_SGIND424_IRIX_CC)) \
|| (defined(SYSTEME_SGIND4GA_IRIX_CC)) \
|| (defined(SYSTEME_SGIND508_IRIX_CC)) \
|| (defined(SYSTEME_SGIND524_IRIX_CC)) \
|| (defined(SYSTEME_SGIND5GA_IRIX_CC)) \
|| (defined(SYSTEME_SGIND808_IRIX_CC)) \
|| (defined(SYSTEME_SGIND824_IRIX_CC)) \
|| (defined(SYSTEME_SGIND8GA_IRIX_CC)) \
|| (defined(SYSTEME_SGINDA08_IRIX_CC)) \
|| (defined(SYSTEME_SGINDA24_IRIX_CC)) \
|| (defined(SYSTEME_SGINDAGA_IRIX_CC)) \
|| (defined(SYSTEME_SGO200A1_IRIX_CC)) \
|| (defined(SYSTEME_SGO200A2_IRIX_CC)) \
|| (defined(SYSTEME_SGO200A4_IRIX_CC)) \
|| (defined(SYSTEME_SGO25224_IRIX_CC)) \
|| (defined(SYSTEME_SGO252VA_IRIX_CC)) \
|| (defined(SYSTEME_SGO252VN_IRIX_CC)) \
|| (defined(SYSTEME_SGPCM801_IRIX_CC)) \
|| (defined(SYSTEME_SGPCMA01_IRIX_CC)) \
|| (defined(SYSTEME_VAX8600_ULTRIX_CC)) \
|| (defined(SYSTEME_VAX9000_ULTRIX_CC)) \
)
#define k___COSINUS_DE_0 \
COSX(FZERO) \
/* Constante 'cos(0)'. */ \
/* */ \
/* ATTENTION : la constante 'COSINUS_DE_0' est pre-generee dans '$xcp/Konstantes$K'. */
#define k___COSINUS_DE_PI \
COSX(PI) \
/* Constante 'cos(pi)'. */ \
/* */ \
/* ATTENTION : la constante 'COSINUS_DE_PI' est pre-generee dans '$xcp/Konstantes$K'. */
#define k___SINUS_DE_PI_SUR_2 \
SINX(PI_SUR_2) \
/* Constante 'sin(pi/2)'. */ \
/* */ \
/* ATTENTION : la constante 'SINUS_DE_PI_SUR_2' est pre-generee dans '$xcp/Konstantes$K'. */
#define k___SINUS_DE_3_PI_SUR_2 \
SINX(bADD(PI_SUR_2,PI)) \
/* Constante 'sin(3.pi/2)'. */ \
/* */ \
/* ATTENTION : la constante 'SINUS_DE_3_PI_SUR_2' est pre-generee dans '$xcp/Konstantes$K'. */
#define EULER \
PARE(0.57721566490) \
/* Constante d'Euler (ou d'Euler-Mascheroni) definie comme la limite de : */ \
/* */ \
/* 1 1 1 1 */ \
/* --- + --- + --- + ... + --- - log(m) */ \
/* 1 2 3 m */ \
/* */ \
/* lorsque 'm' tend vers l'infini... */
#define EN \
PARE(2.7182818284590452354) \
/* Base des logarithmes neperiens. */
#define k___NOMBRE_D_OR \
RACINE_REELLE_p_DE_L_EQUATION_DU_SECOND_DEGRE(NEUT(UN),NEGA(UN),NEGA(UN))
#define k___INVERSE_DU_NOMBRE_D_OR \
INVE(k___NOMBRE_D_OR)
/* Nombre d'or et son inverse (introduit le 20120501080412). Rappelons que le Nombre d'Or */
/* est solution de l'equation : */
/* */
/* 2 */
/* x = x + 1 */
/* */
/* soit : */
/* */
/* 2 */
/* x - x - 1 = 0 */
/* */
/* dont la solution positive : */
/* */
/* ____________________ ___ */
/* / 2 / */
/* -(-1) + \/ (-1) - 4x(+1)x(-1) 1 + \/ 5 */
/* --------------------------------- = ------------ */
/* 2x(+1) 2 */
/* */
/* est le Nombre d'Or... */
/* */
/* Une bonne approximation qui m'a ete indiquee par Nicolas Witkowski le 20140120 est 8/5. */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* C O N S T A N T E S P H Y S I Q U E S D E B A S E : */
/* */
/*************************************************************************************************************************************/
#define VITESSE_DE_LA_LUMIERE \
PARE(299792458.0) \
/* Definition de la vitesse de la lumiere dans le vide (page 546 du dictionnaire de la */ \
/* physique) exprimee en metres par seconde. */
#define CONSTANTE_DE_LA_GRAVITATION \
PARE(6.6720e-11) \
/* Definition de la constante de la gravitation (page 92 du dictionnaire de la physique) */ \
/* exprimee en : */ \
/* */ \
/* 2 -2 */ \
/* Nm kg */ \
/* */
#define CONSTANTE_DE_PLANCK \
PARE(6.626176e-34) \
/* Definition de la vitesse de la constante de Planck 'h' (page 92 du dictionnaire de la */ \
/* physique) exprimee en Joule par Hertz. */
#define CONSTANTE_DE_BOLTZMANN \
PARE(1.38066e-23) \
/* Constante de Boltzmann (page 40 du dictionnaire de la physique) exprimee en : */ \
/* */ \
/* 1 -1 */ \
/* J K */ \
/* */
#define CHARGE_ELECTRIQUE_ELEMENTAIRE \
PARE(1.6021892e-19) \
/* Charge electrique elementaire 'q' (en Coulomb) ; il s'agit de celle de l'electron qui */ \
/* est utilisee lors du calcul de la force de Lorentz. Dans les autres circonstances, */ \
/* ce sont des valeurs du type '1' ou '1/3' (...) qui seront utilisees afin de permettre, */ \
/* par exemple, de prendre en compte le fait que la charge electrique est la somme de la */ \
/* charge faible et de la charge 'U(1)'... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* " P R E - G E N E R A T I O N " D E S C O N S T A N T E S F O N D A M E N T A L E S : */
/* */
/*************************************************************************************************************************************/
#TestADef COSINUS_DE_0 \
k___COSINUS_DE_0
#TestADef COSINUS_DE_PI \
k___COSINUS_DE_PI
#TestADef SINUS_DE_PI_SUR_2 \
k___SINUS_DE_PI_SUR_2
#TestADef SINUS_DE_3_PI_SUR_2 \
k___SINUS_DE_3_PI_SUR_2
#TestADef NOMBRE_D_OR \
k___NOMBRE_D_OR
#TestADef INVERSE_DU_NOMBRE_D_OR \
k___INVERSE_DU_NOMBRE_D_OR
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* P O U R C O N S E R V E R D E S D E F I N T I O N S E T D E S S E Q U E N C E S A R C H A I Q U E S */
/* S A N S L E S D E T R U I R E : */
/* */
/*************************************************************************************************************************************/
#define DEFINITION_ARCHAIQUE(definition) \
BLOC(VIDE) \
/* Pour ne pas generer une definition archaique ou l'on notera bien l'absence du couple */ \
/* {Bblock,Eblock} et de tous les ";" afin de permettre son utilisation sans probleme, */ \
/* par exemple dans 'v $xig/fonct$vv$FON DEFINITION_ARCHAIQUE'. Ceci fut introduit le */ \
/* 20061116120230... */
#define SEQUENCE_ARCHAIQUE(sequence) \
Bblock \
BLOC(VIDE;); \
Eblock \
/* Pour ne pas generer une sequence de code archaique... */ \
/* */ \
/* Le 20061116120230 'ARCHAIQUE(...)' a ete rebaptisee 'SEQUENCE_ARCHAIQUE(...)' afin de */ \
/* permettre l'introduction de 'DEFINITION_ARCHAIQUE(...)'. */ \
/* */ \
/* On n'oubliera pas aussi l'existence de 'SUPPRIMER(...)', de 'AAAAMMJJhhmmss(...)' (ou */ \
/* 'AAAAMMJJhhmmss' est une date a laquelle fut supprimee une certaine sequence...) ainsi */
/* que de 'SUPPRIME_LE_AAAAMMJJhhmmss(...)'. */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* A P P E L D E T Y P E " S O U S - P R O G R A M M E " D ' U N E F O N C T I O N : */
/* */
/*************************************************************************************************************************************/
#define nCALS(fonction) \
Bblock \
SEQUENCE_ARCHAIQUE(CALS(fonction);); \
Eblock \
/* Pour ne pas effectuer l'appel d'une fonction... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* M O T S C L E F S P O U R L E S F O N C T I O N S : */
/* */
/*************************************************************************************************************************************/
/* Permet d'introduire le nom d'une fonction et son type ("Logical", "CHAR", */
/* "Int", "Float", "Double" ou "genere_p") ce qui permet de retrouver rapidement */
/* toutes les fonctions definies dans un fichier. */
/* */
/* Le 20040514101701, j'ai introduit les 'gFonction...' ; elles permettent dorenavant de */
/* definir les 'E___Fonction...' non plus a partir de 'Fonction...', mais a partir de */
/* 'gFonction...'. L'avantage est le suivant : il est alors possible d'introduire dans la */
/* definition des 'Fonction...' un marqueur de "debut de definition de fonction", sans que */
/* cela ne perturbe les definitions des 'E___Fonction...'. L'idee en cours a cette date */
/* etant de remplacer les : */
/* */
/* type Fonction(arg1,arg2,...) */
/* type1 arg1; */
/* type2 arg2; */
/* (...) */
/* { */
/* */
/* par des : */
/* */
/* type Fonction(type1 arg1,type2 arg2,...) */
/* { */
/* */
/* qui possedent l'avantage de faire verifier la concordance des types des arguments d'une */
/* fonction entre sa definition et ses utilisations. */
/* */
/* Ainsi, pouvoir marquer le "debut de definition d'une fonction", connaissant sa fin, */
/* constituee par la premiere "{" rencontree, permettrait d'automatiser cela sans avoir */
/* a modifier les codes sources... */
/* */
/* Evidemment, si cette solution etait utilisee, cela demanderait d'agir aussi de facon */
/* importante au niveau de 'v $xcg/gen$ARG$Z' et de 'v $xcg/gen$EXT$Z'... */
#define VraiBeginFonction(type) \
/* Le 20111201110158 je note que l'argument 'type' ne sert qu'a generer ci-apres le */ \
/* symbole 'ValidationDesCouples_____VraiBeginFonction__EndFonction``type&&&' qui lui-meme */ \
/* fait ensuite l'objet d'un 'undef' dans 'EndFonction(type)' afin de bien verifier que */ \
/* c'est le meme type que l'on trouve dans 'VraiBeginFonction(...)' et 'EndFonction(...)'. */ \
&define ValidationDesCouples_____VraiBeginFonction__EndFonction``type&&& \
\
%ifdef LISTE_DES_ARGUMENTS_IMPLICITES \
_____FORCER_UN_CHANGEMENT_DE_LIGNE_EN_PASSE_2_____ \
Bblock ERREUR_SINS_SINT LISTE_DES_ARGUMENTS_IMPLICITES ERREUR_SINS_SINT Eblock \
%Aifdef LISTE_DES_ARGUMENTS_IMPLICITES \
%Eifdef LISTE_DES_ARGUMENTS_IMPLICITES \
\
INITIALISATION_DE_LA_RESTAURATION_DE_LA_VALEUR_PAR_DEFAUT_DES_ARGUMENTS_IMPLICITES \
/* Pour marquer le debut de la definition d'une fonction (introduit le 20071114152817) */ \
/* dans le but de gerer automatiquement la reinitialisation des arguments implicites */ \
/* ('v $xil/defi_c1$vv$DEF 20071114104738'), ceci etant inutilise a cette date... */ \
/* */ \
/* On notera la difference entre 'VraiBeginFonction' et 'BeginFonction' : la premiere */ \
/* precede tout y compris les 'SINS(...)' et les 'SINT(...)' (ou du moins cela devra */ \
/* etre vrai lors de l'utilisation de 'v $xil/defi_c1$vv$DEF 20071114104738'), alors que */ \
/* la seconde apparait au point d'entree... */ \
/* */ \
/* Le 20071115131928 a ete introduite la validation, via un {&define,&undef}, du couple */ \
/* {VraiBeginFonction,EndFonction}. On notera la "brievete" du symbole 'ValBEF' (sachant */ \
/* que j'ai cherche a utiliser 'ValidationDesCouples_____VraiBeginFonction__EndFonction'). */ \
/* Celle-ci est actuellement rendue necessaire a cause d'interferences entre cette longueur */ \
/* et le processus de decoupage ('v $xcc/cpp$Z .xcp.decoupage.X') qui donne alors une valeur */ \
/* vide a 'NomDeLaFonctionCourante'. Ce probleme est particulirement lie aux definitions */ \
/* de fonctions via des procedures ('v $xig/fonct$vv$FON GENERE__FonctionC_FconversionC' */ \
/* par exemple) car, alors on rencontre ensuite des choses du type : */ \
/* */ \
/* DEFV(Common,GENERE__Fonction...(...)) */ \
/* */ \
/* ce qui donne des lignes de grandes longueur et donc decoupees... */ \
/* */ \
/* Le 20071116174926, le symbole 'ValidationDesCouples_____VraiBeginFonction__EndFonction' */ \
/* a pu etre retabli a la place de l'insignifiant 'ValBEF' suite a un changement de */ \
/* "philosophie" concernant la generation automatique des fonctions. A compter de cette */ \
/* date, on trouvera : */ \
/* */ \
/* BFonctionX */ \
/* DEFV(Common,GENERE__FonctionX...(...)) */ \
/* EFonctionX */ \
/* */ \
/* pour generer automatiquement une fonction de type 'X' (soit {C,I,F,L,...}) et cela */ \
/* exactement comme pour les fonctions "normales" pour lesquelles on trouvait deja : */ \
/* */ \
/* BFonctionX */ \
/* DEFV(Common,DEFV(...,SINT(...))); */ \
/* (...) */ \
/* DEFV(Common,DEFV(...,SINT(...))); */ \
/* */ \
/* DEFV(Common,DEFV(FonctionX,...)) */ \
/* EFonctionX */ \
/* */ \
/* et le tour est joue... */ \
/* */ \
/* Le 20071117085132 fut introduite la gestion des arguments implicites... */ \
/* */ \
/* Le 20100521154239 fut introduite un test sur 'LISTE_DES_ARGUMENTS_IMPLICITES' afin de */ \
/* s'assurer que {SINS,SINT} ne sont utilisees qu'entre {BFonction,...,EFonction...}. Ceux */ \
/* qui sont localises a l'exterieur de {BFonction,...,EFonction...} doivent etre remplaces */ \
/* par {ZINS,ZINT}. Malheureusement, je ne sais pas localiser le defaut dans le fichier */ \
/* argument, si ce n'est en generant 'ERREUR_SINS_SINT' qui cause une erreur avec '$Cc' */ \
/* (on notera que la ligne 'Bblock ... Eblock' doit etre ainsi et ne peut utiliser qu'un */ \
/* seul '_____FORCER_UN_CHANGEMENT_DE_LIGNE_EN_PASSE_2_____' sous peine d'avoir le message : */ \
/* */ \
/* 'undef' d'un symbole ('NomDeLaFonctionCourante') non defini */ \
/* */ \
/* lors de la compilation d'un '$K'). */
#define BFonctionV \
VraiBeginFonction(TypeV)
#define BFonctionC \
VraiBeginFonction(TypeC)
#define BFonctionP \
VraiBeginFonction(TypeP)
#define BPointeurFonctionP \
VraiBeginFonction(TypeP)
#define BFonctionIB \
VraiBeginFonction(TypeIB)
#define BFonctionI \
VraiBeginFonction(TypeI)
#define BFonctionUB \
VraiBeginFonction(TypeUB)
#define BFonctionU \
VraiBeginFonction(TypeU)
#define BFonctionL \
VraiBeginFonction(TypeL)
#define BFonctionF \
VraiBeginFonction(TypeF)
#define BFonctionD \
VraiBeginFonction(TypeD)
#define BFonctionJ \
VraiBeginFonction(TypeJ)
#define BFonctionHJ \
VraiBeginFonction(TypeHJ)
#define BFonctionHHJ \
VraiBeginFonction(TypeHHJ)
#define BFonctionE \
VraiBeginFonction(TypeE)
/* Introduits le 20071114152817... */
/* */
/* Avant le 20071116213833, les types ci-dessus etaient {V,C,P,I,U,L,F,D,J,HJ,E}. Mais */
/* a cause de 'v $xrk/rdn_walk.52$K .define...F.fonction.coordonnees.', le type 'F' de */
/* cette liste etait remplace par la definition de 'F(...)' dans '$xrk/rdn_walk.52$K', */
/* d'ou ces extensions 'Type...'. Notons au passage qu'il en etait de meme de 'I' (qui */
/* vaut 1 ('v $xil/defi_K1$vv$DEF .define...I') et d'autres peut-etre... */
/* */
/* Le 20100317142723 fut introduit 'FonctionIB' afin d'acceder a 'vrai_Int_de_base'... */
/* */
/* Le 20111201105002 fut introduit 'FonctionHHJ'... */
/* */
/* Le 20180425154540 fut introduit 'PointeurFonctionP' (cela a demande la modification */
/* 'v $xcg/LArgTypFo$vv$Z Pointeur..Fonction.'). */
@define DebutDeDefinitionDeFonction VIDE
/* ATTENTION : on notera l'absence de ligne suite ci-dessus ('\') du a l'utilisation de la */
/* '$PASSE_5' pour la definition 'DebutDeDefinitionDeFonction'... */
@define NomDeLaFonctionCourante "FonctionInconnue"
/* Introduit le 20051124105521 au cas ou... */
/* */
/* ATTENTION : on notera l'absence de ligne suite ci-dessus ('\') du a l'utilisation de la */
/* '$PASSE_5' pour la definition 'DebutDeDefinitionDeFonction'... */
#ifdef DEFINITION_DE__BeginFonction__RETU_VERSION_01
# define BeginFonction \
&define NomDeLaFonctionCourante&&&DebutDeDefinitionDeFonction
# define BeginPointeurFonction \
BeginFonction
#Aifdef DEFINITION_DE__BeginFonction__RETU_VERSION_01
#Eifdef DEFINITION_DE__BeginFonction__RETU_VERSION_01
#ifdef DEFINITION_DE__BeginFonction__RETU_VERSION_02
# define BeginFonction_1 \
&define CompteurDeLaFonctionCourante DEFV(Common,DEFV(Positive,INIT(NomDeLaFonctionCourante QD@@__ NbreAcces,ZERO)));
# define BeginFonction_2 \
&define NomDeLaFonctionCourante&&&DebutDeDefinitionDeFonction
# define BeginFonction \
BeginFonction_1 \
BeginFonction_2
# define BeginPointeurFonction \
BeginFonction_2 \
/* Introduit le 20180425154540 pour 'v $xiipf/fonction.2$FON Fvariable' par exemple... */
#Aifdef DEFINITION_DE__BeginFonction__RETU_VERSION_02
#Eifdef DEFINITION_DE__BeginFonction__RETU_VERSION_02
/* Pour marquer le debut de la definition d'une fonction (introduit le 20040515111509). */
/* */
/* Le 20040603103829, la definition : */
/* */
/* #define BeginFonction \ */
/* VIDE */
/* */
/* a evolue dans le but de pouvoir detecter sans ambiguite le debut de la definition d'une */
/* fonction et de ses arguments grace a 'DebutDeDefinitionDeFonction' qui sera ensuite */
/* efface (grace a '$PASSE_5' avant la compilation...). */
/* */
/* Le 20051124091012, la definition : */
/* */
/* #define BeginFonction \ */
/* DebutDeDefinitionDeFonction */
/* */
/* a evolue dans le but de pouvoir memoriser le nom de la fonction courante... */
/* */
/* On notera bien que la valeur de 'NomDeLaFonctionCourante' est une chaine de caracteres */
/* et qu'elle est donc "double-quotee". C'est cela qui justifie l'usage qui en est fait */
/* dans 'v $ximcf/conformes$FON NomDeLaFonctionCourante.QD@@__.'... */
/* */
/* La "VERSION_02" a ete introduite le 20180411104621 et on notera l'ordre "illogique" : */
/* */
/* &define CompteurDeLaFonctionCourante (...) */
/* &define NomDeLaFonctionCourante */
/* */
/* impose par le fait que 'NomDeLaFonctionCourante' doit etre imperativement la derniere */
/* procedure appelee avant la declaration de la fonction. L'ordre correct : */
/* */
/* &define NomDeLaFonctionCourante */
/* &define CompteurDeLaFonctionCourante (...) */
/* CompteurDeLaFonctionCourante; */
/* */
/* est retabli par 'v $xcc/cpp$Z 20180411121208'... */
TypedefP(gFonction,VIDE)
TypedefS(Fonction,BeginFonction gFonction)
TypedefS(E___Fonction,gFonction)
/* Pour introduire une fausse fonction dans un fichier de type "defines". */
/* ATTENTION : seules les 'FonctionP' seront declarables en type 'POINTERp', */
/* afin d'eviter des erreurs de type lorsqu'une fonction "image" est argument */
/* d'une autre fonction... */
TypedefT(gFonctionV,Void)
TypedefS(FonctionV,BeginFonction gFonctionV)
TypedefS(E___FonctionV,gFonctionV)
TypedefT(gFonctionC,CHAR)
TypedefS(FonctionC,BeginFonction gFonctionC)
TypedefS(E___FonctionC,gFonctionC)
TypedefS(gFonctionP,genere_p)
TypedefS(FonctionP,BeginFonction gFonctionP)
TypedefS(E___FonctionP,gFonctionP)
TypedefS(PointeurFonctionP,BeginPointeurFonction gFonctionP)
TypedefS(E___PointeurFonctionP,gFonctionP)
/* Pour 'v $xiipf/fonction.2$FON Fvariable' par exemple, le 20180425154540, le type */
/* 'PointeurFonctionP' a ete introduit (cela a demande la modification */
/* 'v $xcg/LArgTypFo$vv$Z Pointeur..Fonction.'). */
TypedefS(gFonctionIB,vrai_Int_de_base)
TypedefS(FonctionIB,BeginFonction gFonctionIB)
TypedefS(E___FonctionIB,gFonctionIB)
/* Introduit le 20100317142723 en particulier pour 'Main(...)' et 'print_defaut(...)'. */
TypedefS(gFonctionI,Int)
TypedefS(FonctionI,BeginFonction gFonctionI)
TypedefS(E___FonctionI,gFonctionI)
TypedefS(gFonctionUB,vrai_Positive_de_base)
TypedefS(FonctionUB,BeginFonction gFonctionUB)
TypedefS(E___FonctionUB,gFonctionUB)
TypedefS(gFonctionU,LPositive)
TypedefS(FonctionU,BeginFonction gFonctionU)
TypedefS(E___FonctionU,gFonctionU)
/* ATTENTION, jusqu'au 1996080100, il y avait : */
/* */
/* TypedefS(FonctionU,Positive) */
/* */
/* mais il faut etre homogene avec 'imageU'... */
TypedefS(gFonctionL,Logical)
TypedefS(FonctionL,BeginFonction gFonctionL)
TypedefS(E___FonctionL,gFonctionL)
TypedefS(gFonctionF,Float)
TypedefS(FonctionF,BeginFonction gFonctionF)
TypedefS(E___FonctionF,gFonctionF)
TypedefS(gFonctionD,Double)
TypedefS(FonctionD,BeginFonction gFonctionD)
TypedefS(E___FonctionD,gFonctionD)
TypedefS(gFonctionJ,complexe)
TypedefS(FonctionJ,BeginFonction gFonctionJ)
TypedefS(E___FonctionJ,gFonctionJ)
TypedefS(gFonctionHJ,hyper_complexe)
TypedefS(FonctionHJ,BeginFonction gFonctionHJ)
TypedefS(E___FonctionHJ,gFonctionHJ)
TypedefS(gFonctionHHJ,hyper_hyper_complexe)
TypedefS(FonctionHHJ,BeginFonction gFonctionHHJ)
TypedefS(E___FonctionHHJ,gFonctionHHJ)
/* Introduit le 20111201105002... */
TypedefS(gFonctionE,l_element)
TypedefS(FonctionE,BeginFonction gFonctionE)
TypedefS(E___FonctionE,gFonctionE)
/* Introduit le 20040529121807 suite a la creation de 'v $xcg/LArgTypFo$vv$Z'... */
#ifdef DEFV_CAST_VERSION_01
# message "La version 'DEFV_CAST_VERSION_01' n'est plus disponible."
#Aifdef DEFV_CAST_VERSION_01
#Eifdef DEFV_CAST_VERSION_01
#ifdef DEFV_CAST_VERSION_02
# message "La version 'DEFV_CAST_VERSION_02' n'est plus disponible."
#Aifdef DEFV_CAST_VERSION_02
#Eifdef DEFV_CAST_VERSION_02
#ifdef DEFV_CAST_VERSION_03
# define FonctionX(type) \
type \
/* Pour introduire une fausse fonction d'un type quelconque. */
#Aifdef DEFV_CAST_VERSION_03
#Eifdef DEFV_CAST_VERSION_03
#define EndFonction(type) \
&undef NomDeLaFonctionCourante&&& \
INITIALISATION_DE_LA_RESTAURATION_DE_LA_VALEUR_PAR_DEFAUT_DES_ARGUMENTS_IMPLICITES \
&undef ValidationDesCouples_____VraiBeginFonction__EndFonction``type&&& \
/* Pour marquer la fin de la definition d'une fonction (introduit le 20040515111509). */ \
/* */ \
/* Le 20051124091012, la definition : */ \
/* */ \
/* #define BeginFonction \ */ \
/* VIDE */ \
/* */ \
/* a evolue dans le but de pouvoir memoriser le nom de la fonction courante... */ \
/* */ \
/* Le 20071115131928 a ete introduite la validation, via un {&define,&undef}, du couple */ \
/* {VraiBeginFonction,EndFonction}. */ \
/* */ \
/* Le 20071117085132 fut introduite la gestion des arguments implicites... */
#define EFonctionV \
EndFonction(TypeV)
#define EFonctionC \
EndFonction(TypeC)
#define EFonctionP \
EndFonction(TypeP)
#define EPointeurFonctionP \
EndFonction(TypeP)
#define EFonctionIB \
EndFonction(TypeIB)
#define EFonctionI \
EndFonction(TypeI)
#define EFonctionUB \
EndFonction(TypeUB)
#define EFonctionU \
EndFonction(TypeU)
#define EFonctionL \
EndFonction(TypeL)
#define EFonctionF \
EndFonction(TypeF)
#define EFonctionD \
EndFonction(TypeD)
#define EFonctionJ \
EndFonction(TypeJ)
#define EFonctionHJ \
EndFonction(TypeHJ)
#define EFonctionHHJ \
EndFonction(TypeHHJ)
#define EFonctionE \
EndFonction(TypeE)
/* Introduit le 20040529121807 suite a la creation de 'v $xcg/LArgTypFo$vv$Z'... */
/* */
/* Avant le 20071116213833, les types ci-dessus etaient {V,C,P,I,U,L,F,D,J,HJ,E}. Mais */
/* a cause de 'v $xrk/rdn_walk.52$K .define...F.fonction.coordonnees.', le type 'F' de */
/* cette liste etait remplace par la definition de 'F(...)' dans '$xrk/rdn_walk.52$K', */
/* d'ou ces extensions 'Type...'. Notons au passage qu'il en etait de meme de 'I' (qui */
/* vaut 1 ('v $xil/defi_K1$vv$DEF .define...I') et d'autres peut-etre... */
/* */
/* Le 20100317142723 fut introduit 'FonctionIB' afin d'acceder a 'vrai_Int_de_base'... */
/* */
/* Le 20111201105002 fut introduit 'FonctionHHJ'... */
/* */
/* Le 20180425154540 fut introduit 'PointeurFonctionP' (cela a demande la modification */
/* 'v $xcg/LArgTypFo$vv$Z Pointeur..Fonction.'). */
#define EFonction(type) \
EndFonction(type) \
/* Permet de definir la fin d'une fonction. Le 'EndFonction' a ete introduit par symetrie */
/* avec 'BeginFonction' le 20040515111509. */
#define ARGUMENT_FACULTATIF(argument) \
argument \
/* Permet d'indiquer visuellement dans les arguments d'appels d'une fonction */ \
/* que l'un de ceux-ci (entre parentheses) est facultatif ; bien entendu, cela */ \
/* n'a de sens que pour le dernier... */
#define ARGUMENT_INUTILE \
ADRESSE_NON_DEFINIE \
/* Permet d'indiquer visuellement un argument inutile (on ne peut utiliser 'VIDE' a cause */ \
/* du compilateur qui n'accepte pas une zone argument vide...). Ceci est utilise par exemple */ \
/* dans '$xiidX/fonct.vA$FON' pour compatibilite avec '$xiidX/fonct$vv$FON'... */ \
/* */ \
/* ATTENTION, le 19990816153437, la valeur est passee de 'UNDEF' a 'ADRESSE_NON_DEFINIE' */ \
/* qui semble plus general, et surtout plus astucieux car cela peut correspondre a un */ \
/* pointeur nul comme cela s'est vu dans 'v $xil/defi_c1$vv$DEF gettimeofday'... */
#define FLOT__ARGUMENT_INUTILE \
FLOT(ARGUMENT_INUTILE) \
/* Permet d'indiquer visuellement un argument flottant inutile... */
#define ARGUMENT_INDIFFERENT(argument) \
argument \
/* Permet d'indiquer visuellement un argument inutile dans les cas ou l'on ne peut utiliser */ \
/* 'UNDEF' ('v $xiii/di_image$FON SPIRALE_CIRCULAIRE_DEPLACEMENT_ET_PARCOURS'). */
#define ARGUMENT_ABSENT \
ADRESSE_NON_DEFINIE \
/* Permet d'indiquer visuellement un argument absent (on ne peut utiliser 'VIDE' a cause */ \
/* du compilateur qui n'accepte pas une zone argument vide...). */ \
/* */ \
/* ATTENTION, le 19990816153437, la valeur est passee de 'UNDEF' a 'ADRESSE_NON_DEFINIE' */ \
/* qui semble plus general, et surtout plus astucieux car cela peut correspondre a un */ \
/* pointeur nul comme cela s'est vu dans 'v $xil/defi_c1$vv$DEF gettimeofday'... */
#define FLOT__ARGUMENT_ABSENT \
FLOT(ARGUMENT_ABSENT) \
/* Permet d'indiquer visuellement un argument flottant absent (on ne peut utiliser 'VIDE' */ \
/* a cause du compilateur qui n'accepte pas une zone argument vide...). On notera que */ \
/* 'FLOT__ARGUMENT_ABSENT' et 'FLOT(ARGUMENT_ABSENT)' ont le meme nombre de caracteres, et */ \
/* afin de simplifier les mises a jour... ; cette definition a ete rajoutee a cause de */ \
/* 'SYSTEME_ES9000_AIX_CC' dans le fichier '$ximf/aleatoires$FON'... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N D E S A R G U M E N T S D ' U N E F O N C T I O N : */
/* */
/*************************************************************************************************************************************/
TypedefAES(Argument,A___ <><> )
/* Ce mot clef doit etre mis devant toutes les definitions des arguments d'une fonction. On */
/* notera la syntaxe tres particuliere 'A___ <><> ' destinee a obtenir la concatenation du */
/* prefixe 'A___' des arguments d'une fonction a un type quelconque ('Int', 'Float',...). */
/* Avant d'introduire cette notion, on trouvait 'TypedefP(Argument,VIDE)'... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N D E P O I N T E U R S D O N T L A V A L E U R */
/* N E P E U T E T R E C O N N U E Q U ' A L ' E X E C U T I O N : */
/* */
/*************************************************************************************************************************************/
#define NoMalloc \
Argument \
/* Ceci a ete introduit le 20150227141829 afin de pouvoir, par exemple, declarer des */ \
/* images sans leur allouer de memoire (dans le cas ou {dimX,dimY} ne sont pas encore */ \
/* connus). On ecrira ainsi (avec une syntaxe un peu speciale : 'INIS(DEFV(...))') : */ \
/* */ \
/* DEFV(Common,DEFV(NoMalloc,INIS(DEFV(image,ImageADefinirUlterieurement) */ \
/* ,ADRESSE_NON_ENCORE_DEFINIE */ \
/* ) */ \
/* ) */ \
/* ); */ \
/* */ \
/* puis, on ecrira ensuite (et ailleurs...) : */ \
/* */ \
/* DEFV(image,ImageDefinition); */ \
/* (...) */ \
/* EGAL(ImageADefinirUlterieurement,ImageDefinition); */ \
/* (...) */ \
/* EGAL(ImageADefinirUlterieurement,ADRESSE_PLUS_DEFINIE); */ \
/* */ \
/* qui definira proprement 'ImageADefinirUlterieurement' (grace a 'ImageDefinition' pour */ \
/* laquelle il y a eu allocation memoire...). */
#define BMalloc(pointeur_non_encore_defini,type) \
BblockV \
BDEFV(type,PointeurTemporaire_____`pointeur_non_encore_defini); \
/* Ceci doit etre inconditionnel a cause du 'BblockV' de 'BDEFV'... */ \
\
Test(IFOU(IFEQ(pointeur_non_encore_defini,ADRESSE_NON_ENCORE_DEFINIE) \
,IFEQ(pointeur_non_encore_defini,ADRESSE_PLUS_DEFINIE) \
) \
) \
Bblock \
EGAL(pointeur_non_encore_defini,PointeurTemporaire_____`pointeur_non_encore_defini); \
Eblock \
ATes \
Bblock \
PRINT_ERREUR("un pointeur est deja defini alors qu'on veut le definir"); \
Eblock \
ETes
#define EMalloc(pointeur_a_dereferencer,type) \
Test(IFET(IFNE(pointeur_a_dereferencer,ADRESSE_NON_ENCORE_DEFINIE) \
,IFNE(pointeur_a_dereferencer,ADRESSE_PLUS_DEFINIE) \
) \
) \
Bblock \
EGAL(pointeur_a_dereferencer,ADRESSE_PLUS_DEFINIE); \
Eblock \
ATes \
Bblock \
PRINT_ERREUR("un pointeur a dereferencer n'est pas defini"); \
Eblock \
ETes \
\
EDEFV(type,PointeurTemporaire_____`pointeur_a_dereferencer); \
/* Ceci doit etre inconditionnel a cause du 'EblockV' de 'EDEFV'... */ \
EblockV
/* Gestion (definition et dereferencement) d'un pointeur defini via 'NoMalloc'. Ceci a ete */
/* introduit le 20150227185652... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* G E S T I O N D E S R E T O U R S E T D E S C O D E S D ' E R R E U R : */
/* */
/*************************************************************************************************************************************/
#define RETU_VIDE \
RETU_comptage_acces_eventuel; \
VIDE \
/* Retour d'une 'FonctionV' (introduit le 20071130134247 afin que ces fonctions disposent */ \
/* malgre tout d'un 'RETU'...). */
#define INIT_ERROR \
DEFV(Int,INIT(CODE_ERREUR,OK)) \
/* Implantation de l'indicateur d'erreur local a chaque fonction, initialise sur */ \
/* "pas d'erreurs". ATTENTION : on aura interet a placer 'INIT_ERROR' en tete des variables */ \
/* locales, et ce au cas ou des couples ('BDEFV','EDEFV') suivraient. Enfin, on ne peut */ \
/* faire preceder 'INIT_ERROR' de 'BblockV', et faire suivre 'RETU_ERROR' de 'EblockV' car */ \
/* en effet, certaines procedures (telle 'ATTENDRE_AU_FEU_ROUGE(...)' contenue dans le */ \
/* fichier 'v $xiii/files$DEF') utilisent 'INIT_ERROR' sans 'RETU_ERROR'... */
#define CODE_ERROR(code_d_erreur) \
EGAL(CODE_ERREUR,gestion_de_la_liste_des_CODE_ERREUR_rencontres(code_d_erreur)) \
/* Positionnement du code d'erreur ; on notera l'absence de ";" a la fin de l'affectation, */ \
/* afin de permettre l'insertion de 'CODE_ERROR' dans un 'Test' par exemple, de meme que */ \
/* l'absence de : */ \
/* */ \
/* Bblock */ \
/* (...) */ \
/* Eblock */ \
/* */ \
/* pour la meme raison... */ \
/* */ \
/* La fonction 'gestion_de_la_liste_des_CODE_ERREUR_rencontres(...)' a ete introduite */ \
/* le 20110224151649. Elle est programmee de facon que : */ \
/* */ \
/* gestion_de_la_liste_des_CODE_ERREUR_rencontres(code_d_erreur)=code_d_erreur */ \
/* */ \
/* et ainsi, cette fonction semble neutre, alors qu'elle fait des "choses" (elle empile */ \
/* le code d'erreur courant...). */
#define RETU_ERROR \
RETU(CODE_ERREUR) \
/* Renvoi du code d'erreur courant pour chaque fonction. ATTENTION : on ne peut faire */ \
/* preceder 'INIT_ERROR' de 'BblockV', et faire suivre 'RETU_ERROR' de 'EblockV' car, en */ \
/* effet, certaines procedures (telle 'ATTENDRE_AU_FEU_ROUGE(...)' contenue dans le fichier */ \
/* 'v $xiii/files$DEF') utilisent 'INIT_ERROR' sans 'RETU_ERROR'... */
#define ABORT_Commande \
Bblock \
CALS(desallocation_memoire_des_format_EGAr()); \
/* Dedefinition des 'format_EGAr' utiles (introduit le 20180330132318)... */ \
\
EDITION_DE_LA_VALEUR_DES_COMPTEURS_DE_REFERENCE_LORS_DU__RETU_Commande; \
\
Exit(CODE_ERREUR); \
Eblock \
/* Introduit le 20180316104639 afin de remplacer des 'Exit(OK);'... */
#define CHECK_CODE_ERREUR \
Bblock \
Test(IFEXff(CODE_ERREUR,VALEUR_MINIMALE_DANS_UN_OCTET,VALEUR_MAXIMALE_DANS_UN_OCTET)) \
/* Le 19990930144100, j'ai decouvert un phenomene inattendu : 'RETU(...)' est donc utilise */ \
/* en sortie de toutes les 'BCommande(...)' ; l'argument de 'RETU(...)' devient lors du */ \
/* retour au 'C-Shell' la variable '$status'. Mais en fait alors que cet argument est un */ \
/* 'vrai_int_de_base', la variable '$status' n'en recupere que l'octet de poids le plus */ \
/* faible et suivant les SYSTEMEs celui est signe (sur 'SYSTEME_HP???_HPUX_CC' par exemple) */ \
/* et donc dans [-128,+127], ou non signe (sur 'SYSTEME_SG.*_CC' par exemple) et donc dans */ \
/* [0,255]. */ \
Bblock \
PRINT_ATTENTION("le 'CODE_ERREUR' est incompatible avec la gestion de la variable '$status'"); \
CAL1(Prer1("CODE_ERREUR.................... = %d\n",CODE_ERREUR)); \
CAL1(Prer0("la variable '$status' vaudra suivant les 'SYSTEME's :\n")); \
CAL1(Prer1("$status (cas non signe)........ = %d\n" \
,ETLO(CODE_ERREUR,MOCD) \
) \
); \
CAL1(Prer1("$status (cas signe)............ = %d\n" \
,SARS(SCRS(ETLO(CODE_ERREUR,MOCD),NBITOC),bSOU(NBITMO,NBITOC)) \
) \
); \
CAL1(Prer1("VALEUR_MINIMALE_DANS_UN_OCTET.. = %d\n",VALEUR_MINIMALE_DANS_UN_OCTET)); \
CAL1(Prer1("VALEUR_MAXIMALE_DANS_UN_OCTET.. = %d\n",VALEUR_MAXIMALE_DANS_UN_OCTET)); \
/* L'edition des parametres {VALEUR_MINIMALE_DANS_UN_OCTET,VALEUR_MAXIMALE_DANS_UN_OCTET} */ \
/* a ete introduite le 20041208115524 pour '$LACT17'... */ \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
/* Introduit le 20230405181904 pour 'v $xil/defi_c1$vv$DEF CHECK_CODE_ERREUR', mais plus */ \
/* utilise dans ce contexte le 20230406093923... */
#define RETU_Commande \
Bblock \
Eclock("Duree d'execution totale",chronometrer_la_commande_courante); \
/* Edition eventuelle de la duree d'execution de la commande courante (introduite le */ \
/* 20170518115823)... */ \
/* */ \
/* ATTENTION : on notera que ce 'Eclock(...)' n'est pas au meme niveau de {Bblock,Eblock} */ \
/* que le 'Bclock(...)' associe ('v $xil/defi_c1$vv$DEF Bclock') associe : */ \
/* */ \
/* BCommande(...) <-- Bclock(...) */ \
/* Bblock */ \
/* (....) */ \
/* RETU_Commande; <-- Eclock(...) */ \
/* Eblock */ \
/* ECommande */ \
/* */ \
/* Cela parait donc quasiment impossible de les mettre au meme niveau. Au passage, c'est */ \
/* cela qui explique la suppression d'un 'Bblock' en tete de 'Bclock(...)' et d'un 'Eblock' */ \
/* en queue de 'Eclock(...)'. */ \
\
CALS(desallocation_memoire_des_format_EGAr()); \
/* Dedefinition des 'format_EGAr' utiles (introduit le 20180330132318)... */ \
\
EDITION_DE_LA_VALEUR_DES_COMPTEURS_DE_REFERENCE_LORS_DU__RETU_Commande; \
/* Introduit le 20130518213351... */ \
\
Test(IL_FAUT(editer_____liste_des_CODE_ERREUR_rencontres)) \
Bblock \
CALS(Fsauts_de_lignes(UN)); \
CAL3(Prme1("Liste des codes d'erreur rencontres (dans l'ordre d'apparition)={%s}\n" \
,liste_des_CODE_ERREUR_rencontres \
) \
); \
CALS(Fsauts_de_lignes(UN)); \
/* Edition optionnelle introduite le 20110224151649... */ \
/* */ \
/* On notera que dans la liste peuvent apparaitre des codes d'erreur "intermediaire" */ \
/* qui sont normaux et qui n'on pas de consequences quant au comportement de la commande. */ \
/* Ainsi, la commande '$xci/acces$X' voit la liste suivante editee : */ \
/* */ \
/* {0 0 0 0 0 0 0 8 8 8 0 0 0 0} */ \
/* */ \
/* alors que tout marche bien. Cela montre donc que l'on ne peut pas faire, par exemple, */ \
/* une recherche du maximum des valeurs contenues dans cette liste, puis donner a la */ \
/* variable 'CODE_ERREUR' la valeur de ce maximum afin de definir en retour '$status'. En */ \
/* effet dans ce cas, nous serions toujours en erreur, meme lorsque tout s'est bien passe, */ \
/* comme c'est le cas ici... */ \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
\
CHECK_CODE_ERREUR; \
/* Mis sous cette forme le 20230405181904... */ \
\
CALZ_FreCC(nom_de_la_commande_courante); \
/* Introduit le 20180407103647 meme si cela ne sert pas a grand chose... */ \
\
RETU_ERROR; \
Eblock \
/* Renvoi du code d'erreur courant d'une 'Commande'. Ceci a ete introduit le 19990930144100. */ \
/* et le 19991001090449 en ce qui concerne le 'PRINT_ATTENTION(...)'. */ \
/* */ \
/* Je rappelle le 20221115160404 que ce 'CODE_ERREUR' renvoye par 'RETU_ERROR' doit tenir */ \
/* sur un octet et donc etre dans [0,255]... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N D E S C O D E S D ' E R R E U R : */
/* */
/*************************************************************************************************************************************/
Den36(
/* On notera le 20170622135106 que l'on ne peut pas utiliser 'DeT36(...)' a cause de */
/* l'usage de 'INIS(...)' en tant que premier argument... */
INIS(_OK,ZERO)
/* Lorsqu'une operation s'est bien terminee. */
,_ERREUR01
/* Lors d'un "load_fichier", le fichier demande n'existe pas. */
,_ERREUR02
/* Lors d'un "load_fichier", on ne peut acceder a l'etat du fichier. */
,_ERREUR03
/* Lors d'un "load_fichier", le format (taille) n'est pas correct. */
,_ERREUR04
/* Lors d'un "store_fichier", le fichier a creer existe deja. */
,_ERREUR05
/* Lors d'un "store_fichier", le fichier a creer n'existe pas, */
/* et on ne peut le creer. */
,_ERREUR06
/* Lors d'un "store_point", le point argument {X,Y} est hors-image. */
,_ERREUR07
/* Lors d'une entree "STANDARD", le fichier recupere est vide (c'est-a-dire */
/* qu'il contient 'FICHIER_VIDE' octets). */
,_ERREUR08
/* Lors d'un "size_fichier", le fichier demande n'existe pas. */
,_ERREUR09
/* Lors d'un "size_fichier", on ne peut acceder a l'etat du fichier. */
,_ERREUR10
/* Lors d'un "Fliste_Pelement", les chainages sont mauvais. */
,_ERREUR11
/* Lors d'un "Fliste_Delement", le bloc a detruire n'est pas "auto-chaine". */
,_ERREUR12
/* Lors d'un acces a un element (quelqu'il soit) d'une liste (ou d'une pile), */
/* l'adresse fournie est indefinie. */
,_ERREUR13
/* Lors d'une lecture d'un fichier-image sur l'entree standard ("pipe"), */
/* le nombre d'octets lus est mauvais. */
,_ERREUR14
/* Lors d'un acces en lecture/ecriture aux listes de substitution, la */
/* liste demandee n'est pas 'L_SUBSTITUTION_VARIABLE', 'L_SUBSTITUTION_ROUGE', */
/* 'L_SUBSTITUTION_VERTE' ou 'L_SUBSTITUTION_BLEUE'. */
,_ERREUR15
/* Dans une transformee de Fourier mono-dimensionnelle, la dimension du */
/* vecteur definissant la fonction et sa transformee est erronee. */
,_ERREUR16
/* Lors d'un "Fdelete_fichier", le fichier est en mode "lecture seule". */
,_ERREUR17
/* Lors d'un "Fdelete_fichier", on ne peut acceder a l'etat. */
,_ERREUR18
/* Une commande non implementee, ou incomplete est referencee. */
,_ERREUR19
/* Dans une commande (par exemple 'v $xci/feu_attendre$K') un "time-out" a ete detecte. */
,_ERREUR20
/* Le format d'un fichier 'SGI' est mauvais, ou ce fichier n'existe pas... */
,_ERREUR21
/* Lors du pilotage d'un disque video, le code d'erreur mis en place dans deux situations */
/* differentes ; la premiere lorsque : */
/* */
/* CODE_ERROR(PREMIER_CARACTERE_ITb1(buffer_de_reception)); */
/* */
/* dans '$xiidP/fonct$vv$FON' est nul ; on lui substitue cette valeur arbitraire. La */
/* seconde, lorsque le nombre de caracteres recus du disque n'est pas le nombre attendu */
/* (a savoir 'LONGUEUR_DE_L_ACQUITTEMENT_DU_DISQUE')... */
,_ERREUR22
/* Une commande (par exemple '$xci/Sdisplay_RVB$X' n'est pas disponible sur un certain */
/* SYSTEME -par exemple 'SYSTEME_SGO200A2_IRIX_CC'-). */
,_ERREUR23
/* Code d'abort brutal d'un programme apres la detection d'une anomalie d'allocation */
/* memoire dans 'v $xiii/mono_image$FON ERREUR23' (ajoute le 19991129083831). */
,_ERREUR24
/* Code d'abort brutal d'un programme apres la detection d'une anomalie d'allocation */
/* memoire dans 'v $xig/fonct$vv$FON allocation_memoire_avec_validation' (ceci a ete */
/* ajoute le 20000224152926). */
,_ERREUR25
/* Une commande n'a pas fait correctement son travail (ceci a ete ajoute le 20000906101952 */
/* principalement pour 'v $xcg/remote.01$K ERREUR25'). */
,_ERREUR26
/* Lors de 'Fstore_non_securise_fichier_non_formatte(...)' le nombre d'octets ecrits n'est */
/* pas correct (introduit le 20020522163359). */
,_ERREUR27
/* Lors de 'IGload_image_au_format_SGI(...)' les dimensions de l'image au format 'SGI' */
/* n'est pas compatible avec '$formatI' (introduit le 20020909093225). */
,_ERREUR28
/* Lors de 'IXpalette(...)' le mode demande n'est pas disponible (introduit pour '$LACT15' */
/* le 20021223110345). */
,_ERREUR29
/* Code d'abort brutal d'un programme apres la detection d'une anomalie d'allocation */
/* memoire dans 'v $xig/fonct$vv$FON ERREUR29' lors de l'entree interactive d'une valeur */
/* (ceci a ete ajoute le 20051111130738). */
,_ERREUR30
/* Code d'abort brutal d'un programme apres la detection d'une anomalie d'allocation */
/* memoire dans 'v $xig/fonct$vv$FON ERREUR30' lors de la detection des eventuels */
/* caracteres parasites apparaissant derriere la valeur des parametres (ceci a ete ajoute */
/* le 20051114142932). */
,_ERREUR31
/* Un (le ?) "pipe" d'entree semble absent (introduit le 20110224094349). */
,_ERREUR32
/* Le "pipe" de sortie semble absent (introduit le 20110224094349). */
,_ERREUR33
/* Un ou plusieurs arguments non reconnus sont presents dans l'appel a une commande */
/* (introduit le 20110224110203). */
,_ERREUR34
/* Un descripteur d'image 'X-Window' n'est pas valide et le '$K' appelant est donc aborte */
/* afin d'eviter que l'anomalie se propage (introduit le 20170620094311). */
,DERNIERE_ERREUR
,codes_d_erreurs
);
#define k___OK \
ENUM(_OK) \
/* ATTENTION : la constante 'OK' est pre-generee dans '$xcp/Konstantes$K'. */
#define ERREUR01 \
ENUM(_ERREUR01)
#define ERREUR02 \
ENUM(_ERREUR02)
#define ERREUR03 \
ENUM(_ERREUR03)
#define ERREUR04 \
ENUM(_ERREUR04)
#define ERREUR05 \
ENUM(_ERREUR05)
#define ERREUR06 \
ENUM(_ERREUR06)
#define ERREUR07 \
ENUM(_ERREUR07)
#define ERREUR08 \
ENUM(_ERREUR08)
#define ERREUR09 \
ENUM(_ERREUR09)
#define ERREUR10 \
ENUM(_ERREUR10)
#define ERREUR11 \
ENUM(_ERREUR11)
#define ERREUR12 \
ENUM(_ERREUR12)
#define ERREUR13 \
ENUM(_ERREUR13)
#define ERREUR14 \
ENUM(_ERREUR14)
#define ERREUR15 \
ENUM(_ERREUR15)
#define ERREUR16 \
ENUM(_ERREUR16)
#define ERREUR17 \
ENUM(_ERREUR17)
#define ERREUR18 \
ENUM(_ERREUR18)
#define ERREUR19 \
ENUM(_ERREUR19)
#define ERREUR20 \
ENUM(_ERREUR20)
#define ERREUR21 \
ENUM(_ERREUR21)
#define ERREUR22 \
ENUM(_ERREUR22)
#define ERREUR23 \
ENUM(_ERREUR23)
#define ERREUR24 \
ENUM(_ERREUR24)
#define ERREUR25 \
ENUM(_ERREUR25)
#define ERREUR26 \
ENUM(_ERREUR26)
#define ERREUR27 \
ENUM(_ERREUR27)
#define ERREUR28 \
ENUM(_ERREUR28)
#define ERREUR29 \
ENUM(_ERREUR29)
#define ERREUR30 \
ENUM(_ERREUR30)
#define ERREUR31 \
ENUM(_ERREUR31)
#define ERREUR32 \
ENUM(_ERREUR32)
#define ERREUR33 \
ENUM(_ERREUR33)
#define ERREUR34 \
ENUM(_ERREUR34)
#define PROBLEMES \
PRED(OK) \
/* Ce que renvoie une fonction lorsqu'il y a des problemes. */
#define CANNOT_OPEN \
PROBLEMES \
/* Valeur d'un "file_pointer" lorsqu'un "open" ne peut avoir lieu... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* " P R E - G E N E R A T I O N " D E S C O N S T A N T E S F O N D A M E N T A L E S : */
/* */
/*************************************************************************************************************************************/
#TestADef OK \
k___OK
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* F O N C T I O N S D E G E S T I O N D E L ' E S P A C E M E M O I R E : */
/* */
/*************************************************************************************************************************************/
#define EGAp(pointeur,chaine_allouee) \
EGAL(pointeur,chaine_allouee) \
/* Introduit le 20180321091304 pour initialiser un Pointeur et deplace le 20180323090738 */ \
/* depuis 'v $xil/defi_c1$vv$DEF'... */
#nodefine EGAq_VERSION_01(chaine_allouee) \
NEUT(chaine_allouee)
#nodefine EGAq_VERSION_02(chaine_allouee) \
EGAL(pointeur_provisoire,chaine_allouee)
#nodefine EGAq(chaine_allouee) \
EGAq_VERSION_01(chaine_allouee)
/* Introduit le 20180323090929 afin de reperer dans un premier temps les chaines allouees */
/* qui ne sont pas attribuees explicitement a un pointeur... On notera le "q" qui suit dans */
/* l'alphabet le "p" de 'EGAp(...)'. */
/* */
/* La possibilite de changer de version a ete introduite le 20180323175430, en particulier */
/* a des fins de test (voir si ' EGAL(pointeur_provisoire,chaine_allouee)' etait compatible */
/* avec "tout le reste"...). */
/* */
/* A compter du 20180328144130, ces definitions n'ont plus d'interet... */
#nodefine EGAr_VERSION_01(chaine_allouee) \
NEUT(chaine_allouee)
#nodefine EGAr_VERSION_02(chaine_allouee) \
EGAL(pointeur_provisoire,chaine_allouee)
#nodefine EGAr(chaine_allouee) \
EGAr_VERSION_01(chaine_allouee)
/* Introduit le 20180327104313 afin de poursuivre le traitement des chaines allouees qui */
/* ne sont pas attribuees explicitement a un pointeur... On notera le "r" qui suit dans */
/* l'alphabet le "q" de 'EGAq(...)'. */
/* */
/* Le 20180328112026, je note qu'il semble difficile d'aller plus loin dans cette operation */
/* ainsi qu'on le voit avec la tentative 'v $xig/fonct$vv$FON 20180328110513'... */
#define EGAs_VERSION_01(chaine_allouee) \
NEUT(chaine_allouee)
#define EGAs_VERSION_02(chaine_allouee) \
EGAL(pointeur_provisoire,chaine_allouee)
#define EGAs(chaine_allouee) \
EGAs_VERSION_01(chaine_allouee)
/* Introduit le 20180331074153 afin de poursuivre le traitement des chaines allouees qui */
/* ne sont pas attribuees explicitement a un pointeur... On notera le "s" qui suit dans */
/* l'alphabet le "r" de 'EGAr(...)'. */
#define cMalo(taille_en_octets) \
tMalo(taille_en_octets,Char) \
/* Definition de l'allocateur memoire sur des caracteres 'Char'. */
#define ctMalo(chaine,taille_en_octets,type,compteur) \
Bblock \
EGAp(chaine,tMalo(taille_en_octets,type)); \
INCK(compteur); \
Eblock \
/* Definition de l'allocateur memoire sur des caracteres 'CHAR' avec comptage (introduit */ \
/* le 20180316130210)... */
#define kMalo(taille_en_octets) \
tMalo(taille_en_octets,CHAR) \
/* Definition de l'allocateur memoire sur des caracteres 'CHAR' (introduit le 20051026144002 */ \
/* lors des tests du probleme 'v $xig/fonct$vv$FON 20051019113924'...). */
#define ckMalo(chaine,taille_en_octets,compteur) \
Bblock \
EGAp(chaine,kMalo(taille_en_octets)); \
INCK(compteur); \
Eblock \
/* Definition de l'allocateur memoire sur des caracteres 'CHAR' avec comptage (introduit */ \
/* le 20180316130210)... */
#define iMalo(taille_en_octets) \
tMalo(taille_en_octets,Int) \
/* Definition de l'allocateur memoire sur des nombres entiers 'Int'. */
#define ciMalo(chaine,taille_en_octets,compteur) \
Bblock \
EGAp(chaine,iMalo(taille_en_octets)); \
INCK(compteur); \
Eblock \
/* Definition de l'allocateur memoire sur des caracteres 'Int' avec comptage (introduit */ \
/* le 20180317090215)... */
#define pMalo(taille_en_octets) \
tMalo(taille_en_octets,PointerInt) \
/* Definition de l'allocateur memoire sur des nombres entiers de type pointeur 'PointerInt'. */
#define cpMalo(chaine,taille_en_octets,compteur) \
Bblock \
EGAp(chaine,pMalo(taille_en_octets)); \
INCK(compteur); \
Eblock \
/* Definition de l'allocateur memoire sur des caracteres 'PointerInt' avec comptage */ \
/* (introduit le 20180317090215)... */
#define lMalo(taille_en_octets) \
tMalo(taille_en_octets,Logical) \
/* Definition de l'allocateur memoire sur des nombres logiques 'Logical'. */
#define clMalo(chaine,taille_en_octets,compteur) \
Bblock \
EGAp(chaine,lMalo(taille_en_octets)); \
INCK(compteur); \
Eblock \
/* Definition de l'allocateur memoire sur des caracteres 'Logical' avec comptage (introduit */ \
/* le 20180317090215)... */
#define fMalo(taille_en_octets) \
tMalo(taille_en_octets,Float) \
/* Definition de l'allocateur memoire sur des nombres flottants 'Float'. */
#define cfMalo(chaine,taille_en_octets,compteur) \
Bblock \
EGAp(chaine,fMalo(taille_en_octets)); \
INCK(compteur); \
Eblock \
/* Definition de l'allocateur memoire sur des caracteres 'Float' avec comptage (introduit */ \
/* le 20180317090215)... */
#define AllocIn(dimension,type) \
tMalo(bMUL(dimension,SIZE(type)),type) \
/* Allocation de 'dimension' unites de type 'type'. On notera que cette fonction sera */ \
/* probablement utilisee sur les SYSTEMEs, tel 'SYSTEME_SUN4NCUBE2S_SUNOS_NCC', qui ont */ \
/* une memoire distribuee et pour lesquels, bien evidemment, les grandes structures (telles */ \
/* les images...) doivent etre reparties sur plusieurs processeurs... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* F O N C T I O N S D E G E S T I O N D E S P R O C E S S U S : */
/* */
/*************************************************************************************************************************************/
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* M O T S C L E F S P O U R L E S C O M M A N D E S : */
/* */
/*************************************************************************************************************************************/
#define PREMIERE_ENTREE_DANS_LE_PROGRAMME_PRINCIPAL \
ZERO \
/* Indicateur de premiere entree dans le programme principal ; cela est utilise au cas ou */ \
/* il y aurait une "rerentree" (voir 'Iload_image_avec_redimensionnement_eventuel(...)'). */
#define NUMERO_ARGUMENT_COMMANDE \
INDEX0 \
/* Numero de l'argument contenant le nom de la commande. */
#define NOM_DE_LA_COMMANDE \
ITb0(arguments,NUMERO_ARGUMENT_COMMANDE) \
/* Nom de la commande. */
#define NUMERO_PREMIER_ARGUMENT \
SUCC(NUMERO_ARGUMENT_COMMANDE) \
/* Numero de l'argument contenant le premier argument. */
#define ARGUMENT_1 \
ITb0(arguments,NUMERO_PREMIER_ARGUMENT) \
/* Premier argument, */
#define ARGUMENT_2 \
ITb0(arguments,SUCC(NUMERO_PREMIER_ARGUMENT)) \
/* Deuxieme argument, */
#define ARGUMENT_3 \
ITb0(arguments,SUCC(SUCC(NUMERO_PREMIER_ARGUMENT))) \
/* Troisieme argument, */
#define ARGUMENT_4 \
ITb0(arguments,SUCC(SUCC(SUCC(NUMERO_PREMIER_ARGUMENT)))) \
/* Quatrieme argument. */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N S D E S T I N E E S A N E P L U S V A L I D E R L E N O M B R E */
/* D E S A R G U M E N T S D E S C O M M A N D E S , S A U F D E C E L L E S Q U I */
/* N ' E N O N T P A S ( C ' E S T - A - D I R E Q U I E N O N T ' 0 ' ) : */
/* */
/*************************************************************************************************************************************/
/* Autrefois, il y avait ici des definitions du type : */
/* */
/* #define _____1 _____BEAUCOUP */
/* (...) */
/* #define _____nm _____BEAUCOUP */
/* (...) */
/* #define _____90 _____BEAUCOUP */
/* */
/* qui, elles-memes, remplacaient des definitions du type : */
/* */
/* #define _____nm nm */
/* */
/* avec : */
/* */
/* nm > 0 */
/* */
/* En fait, ces definitions etaient inutiles puisque le nombre d'arguments des commandes */
/* n'est plus valide (sauf lorsqu'il est nul). D'autre part, cela pouvait faire croire a */
/* certains que je definissais ici les nombres entiers d'une maniere "unique", tel ces */
/* peuplades primitives qui comptent : 1, 2, 3, beaucoup... */
#define _____0 \
ZERO \
/* On notera que '_____0' est le seul a avoir sa vraie valeur... */
#define _____BEAUCOUP \
CENT \
/* Des qu'il y a au moins un argument. On notera qu'avant, il y avait la definition */ \
/* suivante : */ \
/* */ \
/* #define _____BEAUCOUP \ */ \
/* MOIT(INFINI) */ \
/* */ \
/* en fait, cela a cree des difficultes considerables dans : */ \
/* */ \
/* #define BCommande(nombre_d_arguments,arguments) \ */ \
/* (...) \ */ \
/* & define NOMBRE`D`ARGUMENTS _____BEAUCOUP \ */ \
/* (...) */ \
/* */ \
/* car en effet, lors de 'PASSE_1', le '_____BEAUCOUP' ci-dessus est expanse, et fait alors */ \
/* beaucoup d'octets. Or a la fin de 'PASSE_3', il y a un appel a '$xcp/decoupage$X' dans */ \
/* '$xcc/cpp$Z'. L'expansion de '_____BEAUCOUP' se trouve alors decoupe en plusieurs lignes */ \
/* et ce sans le caractere de suite pour la definition de 'NOMBRE`D`ARGUMENTS' a prendre en */ \
/* compte lors de 'PASSE_4'. La seule solution (provisoire ?) que j'ai trouve a ce probleme */ \
/* delicat, est de raccourcir l'expansion de '_____BEAUCOUP', et donc de simplifier sa */ \
/* definition ; d'ou ce qu'il y a ci-dessus... */ \
/* */ \
/* Enfin, on notera que la valeur 'DIX_MILLE' choisie est tres superieure (volontairement) */ \
/* a ce que tolere le 'C-Shell' au niveau des arguments d'une commande (quelques milliers */ \
/* d'octets au maximum, ce qui correspond donc a quelques centaines d'arguments...). */ \
/* Le 1995072500, cette valeur a ete reduite a 'MILLE' pour des raisons de decoupage... */ \
/* */ \
/* Le 20230406122329, lors de la compilation de 'v $xcp/Konstantes$K', il a fallu de */ \
/* nouveau et pour les memes raisons d'expansion reduire la valeur de '_____BEAUCOUP' */ \
/* a 'CENT'. Cela est apparu apres 'v $xil/defi_c1$vv$DEF 20050905162854' qui a provoque */ \
/* l'augmentation de la longueur de certaines lignes precedant la definition de */ \
/* 'v $xil/defi_c1$vv$DEF NOMBRE.D.ARGUMENTS', la definition de 'NOMBRE_D_ARGUMENTS' se */ \
/* trouvant alors sur une ligne trop longue devant donc etre (mal...) decoupee... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N D ' U N E C O M M A N D E I N E X I S T A N T E : */
/* */
/*************************************************************************************************************************************/
#define COMMANDE_UNDEF \
CHAINE_UNDEF \
/* Est l'equivalent de 'UNDEF' pour les commandes. */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* F O N C T I O N S D ' A C C E S A L ' E N V I R O N N E M E N T : */
/* */
/*************************************************************************************************************************************/
#define Gvar(variable) \
GvarDefaut(variable,VALEUR_D_UNE_VARIABLE_UNDEF) \
/* Recuperation d'une variable definie par 'setenv'... */
#define GvalDefaut(variable,valeur_par_defaut) \
COND(IFNE_chaine(Gvar(variable),VALEUR_D_UNE_VARIABLE_UNDEF) \
,Conversion_Int(Gvar(variable)) \
,valeur_par_defaut \
) \
/* Recuperation de la valeur entiere d'une variable definie par 'setenv' avec valeur par */ \
/* defaut... */
#define Gval(variable) \
GvalDefaut(variable,NEXIST) \
/* Recuperation de la valeur entiere d'une variable definie par 'setenv'... */
#define Pvar(variable,valeur) \
PvarDefaut(variable,valeur) \
/* Mise d'une variable "chaine de caracteres" dans l'environnement (introduit le */ \
/* 20120214091937)... */
#define Pval(variable,valeur) \
PvarDefaut(variable,EGAs(chain_numero_exact(valeur))) \
/* Mise d'une variable "numerique" dans l'environnement (introduit le 20120214091937)... */
#define GIntDefaut(variable,valeur_par_defaut) \
GvalDefaut(variable,valeur_par_defaut) \
/* Recuperation de la valeur entiere d'une variable definie par 'setenv' avec valeur par */ \
/* defaut (introduite le 20180218191252...). */
#define GLogDefaut(variable,valeur_par_defaut) \
COND(IFNE_chaine(Gvar(variable),VALEUR_D_UNE_VARIABLE_UNDEF) \
,Conversion_Logical(Gvar(variable)) \
,valeur_par_defaut \
) \
/* Recuperation de la valeur logique d'une variable definie par 'setenv' avec valeur par */ \
/* defaut (introduite le 20180218111846...). */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* I N T E R F A C E U N I X ( C O M M A N D E S S Y S T E M E ) : */
/* */
/*************************************************************************************************************************************/
#TestADef BUG_SYSTEME_COMMANDE_SYSTEM_1 \
/* Malheureusement, la commande 'SYSTEM(...)' envoie son argument a 'sh' et non pas a 'csh'. */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N D E L ' I M P R E S S I O N : */
/* */
/* */
/* Utilisation standard : */
/* */
/* CAL1(Prer?(...)); */
/* CAL2(Prin?(...)); */
/* CAL3(Prme?(...)); */
/* */
/* */
/* Verification du bon usage par : */
/* */
/* trouve 'CAL[^1]\(Prer|CAL[^2]\(Prin|CAL[^3]\(Prme' */
/* */
/* */
/*************************************************************************************************************************************/
#define NOMBRE_DE_CHIFFRES_DECIMAUX(nombre) \
bADD(POSI(LO1X(MAX2(nombre,UN))),UN) \
/* Nombre de chiffres necessaires pour representer en decimal le nombre argument. Ceci fut */ \
/* introduit le 20051210181429... */ \
/* */ \
/* Avant le 20060104162911, la definition precedente etait : */ \
/* */ \
/* bADD(INTE(LO1X(nombre)),UN) */ \
/* */ \
/* mais la nouvelle est plus prudente... */
#define PARAMETRER_LES_FORMATS_DES_EDITIONS_FLOTTANTES \
VRAI \
/* Introduit le 20060105120240... */
#define DEBUT_DES_Prin_ET_DES_Prer \
Bblock \
EGAL(PRINT_DEFAUT_____vient_d_apparaitre,FAUX); \
/* Dans tous les cas, on reinitialise 'PRINT_DEFAUT_____vient_d_apparaitre'... */
#define FIN_DES_Prin_ET_DES_Prer \
Eblock
#define stream_Prin \
COND(IL_NE_FAUT_PAS(Prin_____changer_le_stream),STREAM_OUT,STREAM_ERREUR) \
/* Introduit le 20001105121808... */
#define DEBUT_DES_Prin(format) \
Bblock \
DEBUT_DES_Prin_ET_DES_Prer; \
PRINT_EN_TETE_Prin_Prer_Prme(Prin_____editer_les_messages_d_en_tete);
#define FIN_DES_Prin(format) \
FIN_DES_Prin_ET_DES_Prer; \
Eblock
/* Introduit le 20060105114747... */
#define fastPrin0(format) \
Bblock \
DEBUT_DES_Prin(format); \
CALZ(FPrin0(stream_Prin,NE_PAS_FLUSHER_LE_FILE,format)); \
FIN_DES_Prin(format); \
Eblock
#define fastPrin1(format,x1) \
Bblock \
DEBUT_DES_Prin(format); \
CALZ(FPrin1(stream_Prin,NE_PAS_FLUSHER_LE_FILE,format,x1)); \
FIN_DES_Prin(format); \
Eblock
#define fastPrin2(format,x1,x2) \
Bblock \
DEBUT_DES_Prin(format); \
CALZ(FPrin2(stream_Prin,NE_PAS_FLUSHER_LE_FILE,format,x1,x2)); \
FIN_DES_Prin(format); \
Eblock
#define fastPrin3(format,x1,x2,x3) \
Bblock \
DEBUT_DES_Prin(format); \
CALZ(FPrin3(stream_Prin,NE_PAS_FLUSHER_LE_FILE,format,x1,x2,x3)); \
FIN_DES_Prin(format); \
Eblock
#define fastPrin4(format,x1,x2,x3,x4) \
Bblock \
DEBUT_DES_Prin(format); \
CALZ(FPrin4(stream_Prin,NE_PAS_FLUSHER_LE_FILE,format,x1,x2,x3,x4)); \
FIN_DES_Prin(format); \
Eblock
#define Prin0(format) \
Bblock \
DEBUT_DES_Prin(format); \
CALZ(FPrin0(stream_Prin,FLUSHER_LE_FILE,format)); \
FIN_DES_Prin(format); \
Eblock
#define Prin1(format,x1) \
Bblock \
DEBUT_DES_Prin(format); \
CALZ(FPrin1(stream_Prin,FLUSHER_LE_FILE,format,x1)); \
FIN_DES_Prin(format); \
Eblock
#define Prin2(format,x1,x2) \
Bblock \
DEBUT_DES_Prin(format); \
CALZ(FPrin2(stream_Prin,FLUSHER_LE_FILE,format,x1,x2)); \
FIN_DES_Prin(format); \
Eblock
#define Prin3(format,x1,x2,x3) \
Bblock \
DEBUT_DES_Prin(format); \
CALZ(FPrin3(stream_Prin,FLUSHER_LE_FILE,format,x1,x2,x3)); \
FIN_DES_Prin(format); \
Eblock
#define Prin4(format,x1,x2,x3,x4) \
Bblock \
DEBUT_DES_Prin(format); \
CALZ(FPrin4(stream_Prin,FLUSHER_LE_FILE,format,x1,x2,x3,x4)); \
FIN_DES_Prin(format); \
Eblock
#define Prin5(format,x1,x2,x3,x4,x5) \
Bblock \
DEBUT_DES_Prin(format); \
CALZ(FPrin5(stream_Prin,FLUSHER_LE_FILE,format,x1,x2,x3,x4,x5)); \
FIN_DES_Prin(format); \
Eblock
#define Prin6(format,x1,x2,x3,x4,x5,x6) \
Bblock \
DEBUT_DES_Prin(format); \
CALZ(FPrin6(stream_Prin,FLUSHER_LE_FILE,format,x1,x2,x3,x4,x5,x6)); \
FIN_DES_Prin(format); \
Eblock
#define Prin7(format,x1,x2,x3,x4,x5,x6,x7) \
Bblock \
DEBUT_DES_Prin(format); \
CALZ(FPrin7(stream_Prin,FLUSHER_LE_FILE,format,x1,x2,x3,x4,x5,x6,x7)); \
FIN_DES_Prin(format); \
Eblock
#define Prin8(format,x1,x2,x3,x4,x5,x6,x7,x8) \
Bblock \
DEBUT_DES_Prin(format); \
CALZ(FPrin8(stream_Prin,FLUSHER_LE_FILE,format,x1,x2,x3,x4,x5,x6,x7,x8)); \
FIN_DES_Prin(format); \
Eblock
#define Prin9(format,x1,x2,x3,x4,x5,x6,x7,x8,x9) \
Bblock \
DEBUT_DES_Prin(format); \
CALZ(FPrin9(stream_Prin,FLUSHER_LE_FILE,format,x1,x2,x3,x4,x5,x6,x7,x8,x9)); \
FIN_DES_Prin(format); \
Eblock
#define Prin10(format,x1,x2,x3,x4,x5,x6,x7,x8,x9,xA) \
Bblock \
DEBUT_DES_Prin(format); \
CALZ(FPrin10(stream_Prin,FLUSHER_LE_FILE,format,x1,x2,x3,x4,x5,x6,x7,x8,x9,xA)); \
FIN_DES_Prin(format); \
Eblock
#define Prin11(format,x1,x2,x3,x4,x5,x6,x7,x8,x9,xA,xB) \
Bblock \
DEBUT_DES_Prin(format); \
CALZ(FPrin11(stream_Prin,FLUSHER_LE_FILE,format,x1,x2,x3,x4,x5,x6,x7,x8,x9,xA,xB)); \
FIN_DES_Prin(format); \
Eblock
#define Prin12(format,x1,x2,x3,x4,x5,x6,x7,x8,x9,xA,xB,xC) \
Bblock \
DEBUT_DES_Prin(format); \
CALZ(FPrin12(stream_Prin,FLUSHER_LE_FILE,format,x1,x2,x3,x4,x5,x6,x7,x8,x9,xA,xB,xC)); \
FIN_DES_Prin(format); \
Eblock
#define Prin13(format,x1,x2,x3,x4,x5,x6,x7,x8,x9,xA,xB,xC,xD) \
Bblock \
DEBUT_DES_Prin(format); \
CALZ(FPrin13(stream_Prin,FLUSHER_LE_FILE,format,x1,x2,x3,x4,x5,x6,x7,x8,x9,xA,xB,xC,xD)); \
FIN_DES_Prin(format); \
Eblock
#define Prin14(format,x1,x2,x3,x4,x5,x6,x7,x8,x9,xA,xB,xC,xD,xE) \
Bblock \
DEBUT_DES_Prin(format); \
CALZ(FPrin14(stream_Prin,FLUSHER_LE_FILE,format,x1,x2,x3,x4,x5,x6,x7,x8,x9,xA,xB,xC,xD,xE)); \
FIN_DES_Prin(format); \
Eblock
#define Prin15(format,x1,x2,x3,x4,x5,x6,x7,x8,x9,xA,xB,xC,xD,xE,xF) \
Bblock \
DEBUT_DES_Prin(format); \
CALZ(FPrin15(stream_Prin,FLUSHER_LE_FILE,format,x1,x2,x3,x4,x5,x6,x7,x8,x9,xA,xB,xC,xD,xE,xF)); \
FIN_DES_Prin(format); \
Eblock
#define Prin16(format,x1,x2,x3,x4,x5,x6,x7,x8,x9,xA,xB,xC,xD,xE,xF,xG) \
Bblock \
DEBUT_DES_Prin(format); \
CALZ(FPrin16(stream_Prin,FLUSHER_LE_FILE,format,x1,x2,x3,x4,x5,x6,x7,x8,x9,xA,xB,xC,xD,xE,xF,xG)); \
FIN_DES_Prin(format); \
Eblock
/* Definition des fonctions d'impression externe sur 'stdout' avec nombre d'arguments... */
/* ATTENTION : on notera l'introduction de la fonction 'Fflush(...)' ; elle est destinee */
/* a garantir que lors de sequences du type : */
/* */
/* Prin?(...); */
/* Prer?(...); */
/* Prin?(...); */
/* Prer?(...); */
/* Prin?(...); */
/* */
/* l'ordre des sorties (quelles que soient les redirections et les "pipes") soit le meme que */
/* celui qui est donne par cette sequence... */
&define GPrin0(format) \
FPrint(stream_Prin,format)
&define GPrin1(format,x1) \
FPrint(stream_Prin,format,x1)
&define GPrin2(format,x1,x2) \
FPrint(stream_Prin,format,x1,x2)
&define GPrin3(format,x1,x2,x3) \
FPrint(stream_Prin,format,x1,x2,x3)
&define GPrin4(format,x1,x2,x3,x4) \
FPrint(stream_Prin,format,x1,x2,x3,x4)
&define GPrin5(format,x1,x2,x3,x4,x5) \
FPrint(stream_Prin,format,x1,x2,x3,x4,x5)
&define GPrin6(format,x1,x2,x3,x4,x5,x6) \
FPrint(stream_Prin,format,x1,x2,x3,x4,x5,x6)
&define GPrin7(format,x1,x2,x3,x4,x5,x6,x7) \
FPrint(stream_Prin,format,x1,x2,x3,x4,x5,x6,x7)
&define GPrin8(format,x1,x2,x3,x4,x5,x6,x7,x8) \
FPrint(stream_Prin,format,x1,x2,x3,x4,x5,x6,x7,x8)
&define GPrin9(format,x1,x2,x3,x4,x5,x6,x7,x8,x9) \
FPrint(stream_Prin,format,x1,x2,x3,x4,x5,x6,x7,x8,x9)
&define GPrin10(format,x1,x2,x3,x4,x5,x6,x7,x8,x9,xA) \
FPrint(stream_Prin,format,x1,x2,x3,x4,x5,x6,x7,x8,x9,xA)
&define GPrin11(format,x1,x2,x3,x4,x5,x6,x7,x8,x9,xA,xB) \
FPrint(stream_Prin,format,x1,x2,x3,x4,x5,x6,x7,x8,x9,xA,xB)
&define GPrin12(format,x1,x2,x3,x4,x5,x6,x7,x8,x9,xA,xB,xC) \
FPrint(stream_Prin,format,x1,x2,x3,x4,x5,x6,x7,x8,x9,xA,xB,xC)
&define GPrin13(format,x1,x2,x3,x4,x5,x6,x7,x8,x9,xA,xB,xC,xD) \
FPrint(stream_Prin,format,x1,x2,x3,x4,x5,x6,x7,x8,x9,xA,xB,xC,xD)
&define GPrin14(format,x1,x2,x3,x4,x5,x6,x7,x8,x9,xA,xB,xC,xD,xE) \
FPrint(stream_Prin,format,x1,x2,x3,x4,x5,x6,x7,x8,x9,xA,xB,xC,xD,xE)
&define GPrin15(format,x1,x2,x3,x4,x5,x6,x7,x8,x9,xA,xB,xC,xD,xE,xF) \
FPrint(stream_Prin,format,x1,x2,x3,x4,x5,x6,x7,x8,x9,xA,xB,xC,xD,xE,xF)
&define GPrin16(format,x1,x2,x3,x4,x5,x6,x7,x8,x9,xA,xB,xC,xD,xE,xF,xG) \
FPrint(stream_Prin,format,x1,x2,x3,x4,x5,x6,x7,x8,x9,xA,xB,xC,xD,xE,xF,xG)
/* Definition des fonctions d'impression externe sur 'stdout' avec nombre d'arguments */
/* introduites le 20071228094627 specialement pour 'v $xci/genere$I GPrin'... */
/* */
/* On notera que l'on ne peut utiliser {Prin0(...),...,Prin16(...)} ci-dessus et ce a cause */
/* de 'v $xcc/cpp$Z .xcp.expressions.X' qui decoupe les lignes derriere les ";"s. Or les */
/* definitions des 'GPrin*(...)'s ci-dessus contiennent de nombreux ";"s. Il faut donc */
/* que ces definitions soient les plus breves possibles. D'ou evidemment de plus l'absence */
/* de {Bblock,Eblock}, de 'CALS(...)' et de ";" en bout de ligne... */
#define stream_Prer \
COND(IL_NE_FAUT_PAS(Prer_____changer_le_stream),STREAM_ERREUR,STREAM_OUT) \
/* Introduit le 20001105121808... */
#define DEBUT_DE_COMPACTAGE_DES_K_LF_DES_Prer(format) \
Bblock \
DEFV(CHAR,INIT(POINTERc(format_utilise) \
,chain_Acopie_avec_suppression_d_un_eventuel_K_LF_en_tete(format \
,PRINT_DEFAUT_____vient_d_apparaitre \
) \
) \
); \
/* Format reellement utilise dans les impressions. Dans le cas ou il vient d'y avoir un */ \
/* 'PRINT_DEFAUT(...)' et ou en plus le format courant commence par un 'K_LF', on le */ \
/* supprime en decalant le format d'un caractere car, en effet, 'PRINT_DEFAUT(...)' vient */ \
/* d'en faire un. Dans les cas contraires, le format demande est copie tel quel... */ \
/* */ \
/* ATTENTION : reference dans 'v $xcc/cpp$Z format_utilise'. */ \
\
DEBUT_DES_Prin_ET_DES_Prer;
#define FIN_DE_COMPACTAGE_DES_K_LF_DES_Prer(format) \
FIN_DES_Prin_ET_DES_Prer; \
CALZ_FreCC(format_utilise); \
Eblock
#define DEBUT_DES_Prer(format) \
Bblock \
DEBUT_DE_COMPACTAGE_DES_K_LF_DES_Prer(format); \
PRINT_EN_TETE_Prin_Prer_Prme(Prer_____editer_les_messages_d_en_tete);
#define FIN_DES_Prer(format) \
FIN_DE_COMPACTAGE_DES_K_LF_DES_Prer(format); \
Eblock
/* Introduit le 20060105114747... */
#define fastPrer0(format) \
Bblock \
DEBUT_DES_Prer(format); \
CALZ(FPrin0(stream_Prer,NE_PAS_FLUSHER_LE_FILE,format_utilise)); \
FIN_DES_Prer(format); \
Eblock
#define fastPrer1(format,x1) \
Bblock \
DEBUT_DES_Prer(format); \
CALZ(FPrin1(stream_Prer,NE_PAS_FLUSHER_LE_FILE,format_utilise,x1)); \
FIN_DES_Prer(format); \
Eblock
#define fastPrer2(format,x1,x2) \
Bblock \
DEBUT_DES_Prer(format); \
CALZ(FPrin2(stream_Prer,NE_PAS_FLUSHER_LE_FILE,format_utilise,x1,x2)); \
FIN_DES_Prer(format); \
Eblock
#define fastPrer3(format,x1,x2,x3) \
Bblock \
DEBUT_DES_Prer(format); \
CALZ(FPrin3(stream_Prer,NE_PAS_FLUSHER_LE_FILE,format_utilise,x1,x2,x3)); \
FIN_DES_Prer(format); \
Eblock
#define fastPrer4(format,x1,x2,x3,x4) \
Bblock \
DEBUT_DES_Prer(format); \
CALZ(FPrin4(stream_Prer,NE_PAS_FLUSHER_LE_FILE,format_utilise,x1,x2,x3,x4)); \
FIN_DES_Prer(format); \
Eblock
/* Definition des fonctions d'impression externe sur 'stderr' avec nombre d'arguments */
/* et dans leur version "rapide" (c'est-a-dire sans "flush"). */
#define Prer0(format) \
Bblock \
DEBUT_DES_Prer(format); \
CALZ(FPrin0(stream_Prer,FLUSHER_LE_FILE,format_utilise)); \
FIN_DES_Prer(format); \
Eblock
#define Prer1(format,x1) \
Bblock \
DEBUT_DES_Prer(format); \
CALZ(FPrin1(stream_Prer,FLUSHER_LE_FILE,format_utilise,x1)); \
FIN_DES_Prer(format); \
Eblock
#define Prer2(format,x1,x2) \
Bblock \
DEBUT_DES_Prer(format); \
CALZ(FPrin2(stream_Prer,FLUSHER_LE_FILE,format_utilise,x1,x2)); \
FIN_DES_Prer(format); \
Eblock
#define Prer3(format,x1,x2,x3) \
Bblock \
DEBUT_DES_Prer(format); \
CALZ(FPrin3(stream_Prer,FLUSHER_LE_FILE,format_utilise,x1,x2,x3)); \
FIN_DES_Prer(format); \
Eblock
#define Prer4(format,x1,x2,x3,x4) \
Bblock \
DEBUT_DES_Prer(format); \
CALZ(FPrin4(stream_Prer,FLUSHER_LE_FILE,format_utilise,x1,x2,x3,x4)); \
FIN_DES_Prer(format); \
Eblock
#define Prer5(format,x1,x2,x3,x4,x5) \
Bblock \
DEBUT_DES_Prer(format); \
CALZ(FPrin5(stream_Prer,FLUSHER_LE_FILE,format_utilise,x1,x2,x3,x4,x5)); \
FIN_DES_Prer(format); \
Eblock
#define Prer6(format,x1,x2,x3,x4,x5,x6) \
Bblock \
DEBUT_DES_Prer(format); \
CALZ(FPrin6(stream_Prer,FLUSHER_LE_FILE,format_utilise,x1,x2,x3,x4,x5,x6)); \
FIN_DES_Prer(format); \
Eblock
#define Prer7(format,x1,x2,x3,x4,x5,x6,x7) \
Bblock \
DEBUT_DES_Prer(format); \
CALZ(FPrin7(stream_Prer,FLUSHER_LE_FILE,format_utilise,x1,x2,x3,x4,x5,x6,x7)); \
FIN_DES_Prer(format); \
Eblock
#define Prer8(format,x1,x2,x3,x4,x5,x6,x7,x8) \
Bblock \
DEBUT_DES_Prer(format); \
CALZ(FPrin8(stream_Prer,FLUSHER_LE_FILE,format_utilise,x1,x2,x3,x4,x5,x6,x7,x8)); \
FIN_DES_Prer(format); \
Eblock
#define Prer9(format,x1,x2,x3,x4,x5,x6,x7,x8,x9) \
Bblock \
DEBUT_DES_Prer(format); \
CALZ(FPrin9(stream_Prer,FLUSHER_LE_FILE,format_utilise,x1,x2,x3,x4,x5,x6,x7,x8,x9)); \
FIN_DES_Prer(format); \
Eblock
#define Prer10(format,x1,x2,x3,x4,x5,x6,x7,x8,x9,xA) \
Bblock \
DEBUT_DES_Prer(format); \
CALZ(FPrin10(stream_Prer,FLUSHER_LE_FILE,format_utilise,x1,x2,x3,x4,x5,x6,x7,x8,x9,xA)); \
FIN_DES_Prer(format); \
Eblock
#define Prer11(format,x1,x2,x3,x4,x5,x6,x7,x8,x9,xA,xB) \
Bblock \
DEBUT_DES_Prer(format); \
CALZ(FPrin11(stream_Prer,FLUSHER_LE_FILE,format_utilise,x1,x2,x3,x4,x5,x6,x7,x8,x9,xA,xB)); \
FIN_DES_Prer(format); \
Eblock
#define Prer12(format,x1,x2,x3,x4,x5,x6,x7,x8,x9,xA,xB,xC) \
Bblock \
DEBUT_DES_Prer(format); \
CALZ(FPrin12(stream_Prer,FLUSHER_LE_FILE,format_utilise,x1,x2,x3,x4,x5,x6,x7,x8,x9,xA,xB,xC)); \
FIN_DES_Prer(format); \
Eblock
#define PrerD(format,x1,x2,x3,x4,x5,x6,x7,x8,x9,xA,xB,xC,xD) \
Bblock \
DEBUT_DES_Prer(format); \
CALZ(FPrin13(stream_Prer,FLUSHER_LE_FILE,format_utilise,x1,x2,x3,x4,x5,x6,x7,x8,x9,xA,xB,xC,xD)); \
FIN_DES_Prer(format); \
Eblock
/* Definition des fonctions d'impression externe sur 'stderr' avec nombre d'arguments... */
/* */
/* ATTENTION : on notera l'introduction de la fonction 'Fflush(...)' ; elle est destinee */
/* a garantir que lors de sequences du type : */
/* */
/* Prin?(...); */
/* Prer?(...); */
/* Prin?(...); */
/* Prer?(...); */
/* Prin?(...); */
/* */
/* l'ordre des sorties (quelles que soient les redirections et les "pipes") soit le meme que */
/* celui qui est donne par cette sequence... */
/* */
/* La procedure 'Prer10(...)' a ete introduite le 20051124111202... */
/* */
/* La procedure 'Prer11(...)' a ete introduite le 20070420113158... */
/* */
/* La procedure 'PrerD(...)' a ete introduite le 20181227121112... */
#define stream_Prme \
COND(IL_NE_FAUT_PAS(Prme_____changer_le_stream),STREAM_ERREUR,STREAM_OUT) \
/* Introduit le 20001105121808 afin de faciliter des ecritures du type : */ \
/* */ \
/* set VARIABLE=`COMMANDE$X Prme=VRAI` */ \
/* */ \
/* ou 'COMMANDE$X' est une commande sortant des messages via 'Prme?(...)'. */
/* ATTENTION, jusqu'au 20010319153838, les definitions de 'Prme?(...)' etaient du type : */
/* */
/* DEBUT_DE_COMPACTAGE_DES_K_LF_DES_Prer(format); */
/* CALS(FPrin?(stream_Prme,FLUSHER_LE_FILE,format_utilise...)); */
/* FIN_DE_COMPACTAGE_DES_K_LF_DES_Prer(format); */
/* */
/* mais, contrairement aux 'Prer?(...)', ici il est necessaire de conserver la mise en page. */
#define DEBUT_DES_Prme(format) \
Bblock \
PRINT_EN_TETE_Prin_Prer_Prme(Prme_____editer_les_messages_d_en_tete);
#define FIN_DES_Prme(format) \
Eblock
/* Introduit le 20060105114747... */
#define Prme0(format) \
Bblock \
DEBUT_DES_Prme(format); \
CALZ(FPrin0(stream_Prme,FLUSHER_LE_FILE,format)); \
FIN_DES_Prme(format); \
Eblock
#define Prme1(format,x1) \
Bblock \
DEBUT_DES_Prme(format); \
CALZ(FPrin1(stream_Prme,FLUSHER_LE_FILE,format,x1)); \
FIN_DES_Prme(format); \
Eblock
#define Prme2(format,x1,x2) \
Bblock \
DEBUT_DES_Prme(format); \
CALZ(FPrin2(stream_Prme,FLUSHER_LE_FILE,format,x1,x2)); \
FIN_DES_Prme(format); \
Eblock
#define Prme3(format,x1,x2,x3) \
Bblock \
DEBUT_DES_Prme(format); \
CALZ(FPrin3(stream_Prme,FLUSHER_LE_FILE,format,x1,x2,x3)); \
FIN_DES_Prme(format); \
Eblock
#define Prme4(format,x1,x2,x3,x4) \
Bblock \
DEBUT_DES_Prme(format); \
CALZ(FPrin4(stream_Prme,FLUSHER_LE_FILE,format,x1,x2,x3,x4)); \
FIN_DES_Prme(format); \
Eblock
#define Prme5(format,x1,x2,x3,x4,x5) \
Bblock \
DEBUT_DES_Prme(format); \
CALZ(FPrin5(stream_Prme,FLUSHER_LE_FILE,format,x1,x2,x3,x4,x5)); \
FIN_DES_Prme(format); \
Eblock
#define Prme6(format,x1,x2,x3,x4,x5,x6) \
Bblock \
DEBUT_DES_Prme(format); \
CALZ(FPrin6(stream_Prme,FLUSHER_LE_FILE,format,x1,x2,x3,x4,x5,x6)); \
FIN_DES_Prme(format); \
Eblock
#define Prme7(format,x1,x2,x3,x4,x5,x6,x7) \
Bblock \
DEBUT_DES_Prme(format); \
CALZ(FPrin7(stream_Prme,FLUSHER_LE_FILE,format,x1,x2,x3,x4,x5,x6,x7)); \
FIN_DES_Prme(format); \
Eblock
#define Prme8(format,x1,x2,x3,x4,x5,x6,x7,x8) \
Bblock \
DEBUT_DES_Prme(format); \
CALZ(FPrin8(stream_Prme,FLUSHER_LE_FILE,format,x1,x2,x3,x4,x5,x6,x7,x8)); \
FIN_DES_Prme(format); \
Eblock
#define Prme9(format,x1,x2,x3,x4,x5,x6,x7,x8,x9) \
Bblock \
DEBUT_DES_Prme(format); \
CALZ(FPrin9(stream_Prme,FLUSHER_LE_FILE,format,x1,x2,x3,x4,x5,x6,x7,x8,x9)); \
FIN_DES_Prme(format); \
Eblock
#define Prme10(format,x1,x2,x3,x4,x5,x6,x7,x8,x9,xA) \
Bblock \
DEBUT_DES_Prme(format); \
CALZ(FPrin10(stream_Prme,FLUSHER_LE_FILE,format,x1,x2,x3,x4,x5,x6,x7,x8,x9,xA)); \
FIN_DES_Prme(format); \
Eblock
#define Prme11(format,x1,x2,x3,x4,x5,x6,x7,x8,x9,xA,xB) \
Bblock \
DEBUT_DES_Prme(format); \
CALZ(FPrin11(stream_Prme,FLUSHER_LE_FILE,format,x1,x2,x3,x4,x5,x6,x7,x8,x9,xA,xB)); \
FIN_DES_Prme(format); \
Eblock
#define Prme12(format,x1,x2,x3,x4,x5,x6,x7,x8,x9,xA,xB,xC) \
Bblock \
DEBUT_DES_Prme(format); \
CALZ(FPrin12(stream_Prme,FLUSHER_LE_FILE,format,x1,x2,x3,x4,x5,x6,x7,x8,x9,xA,xB,xC)); \
FIN_DES_Prme(format); \
Eblock
/* Definition des fonctions d'impression externe sur 'stderr' avec nombre d'arguments mais */
/* qui ne sont pas des sorties d'erreur. Il s'agira de sortie de messages qui ne doivent */
/* pas interferer avec 'stdout'. */
/* */
/* ATTENTION : j'ai decouvert le 19990603190104 que ces procedures 'Prme?(...)' ont un */
/* inconvenient relativement important. En effet, utilisees dans un certain programme, */
/* l'ecriture : */
/* */
/* set VARIABLE=`PROGRAMME ARGUMENTS` */
/* */
/* ne fonctionne pas s'il s'agit de recuperer des objets edites par 'Prme?(...)' car, en */
/* effet, l'utilisation des '$K_QA' ne permet de recuperer que ce qui sort sur 'stdout'. */
/* Or, les procedures 'Prme?(...)' utilisent 'stderr'. Donc leur utilisation ne pourra */
/* qu'etre faite qu'avec precaution et en fonction d'une utilisation ulterieure. On pourra */
/* voir a ce propos 'v $xci/extrema$K Prin' utilise dans 'v $xci/acces_RVB.12$Z extrema'. */
/* */
/* Le 19990607090645, j'ai trouve la solution ; il suffit d'ecrire : */
/* */
/* set VARIABLE=`PROGRAMME ARGUMENTS |& $CA` */
/* */
/* pour recuperer ce qui sort de 'Prme?(...)'... */
/* */
/* Le 20001105121808, j'ai trouve une autre solution qui a consiste a introduire l'option */
/* */
/* Prme=VRAI */
/* */
/* via 'v $xig/fonct$vv$DEF Prme='. */
/* */
/* ATTENTION, jusqu'au 20010319153838, les definitions de 'Prme?(...)' etaient du type : */
/* */
/* DEBUT_DE_COMPACTAGE_DES_K_LF_DES_Prer(format); */
/* CALS(FPrin?(stream_Prme,FLUSHER_LE_FILE,format_utilise...)); */
/* FIN_DE_COMPACTAGE_DES_K_LF_DES_Prer(format); */
/* */
/* mais, contrairement aux 'Prer?(...)', ici il est necessaire de conserver la mise en page. */
/* */
/* Le 20081002143733 furent introduits 'Prme10(...)' (pour 'v $xci/histogramme$K Prme10' a */
/* priori...) et 'Prme11(...)'. */
/* */
/* Le 20090602082251 furent introduits 'Prme12(...)' (pour 'v $xci/histogramme$K Prme12' a */
/* priori...). */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* G E S T I O N D E L ' U T I L I S A T I O N O P T I M I S E E E T O P T I O N N E L L E D U ' GooF ' : */
/* */
/*************************************************************************************************************************************/
/* Le nom 'UTILISER_A_PRIORI__LE_GooF(...)', trop long, fut change en 'USE_GooF(...)' */
/* le 20080106084802... */
/* */
/* Le 20080106183801, fut "subdivisee" en deux 'USe_GooF(...)' et 'USs_GooF(...)' suivant */
/* l'usage qui en est fait... */
#ifdef PRAGMA_CPP_____AUTORISER_LE_GooF
# define USe_GooF(expression) \
ACTIVER__S_IL_EST_ACTIVABLE__ET__SI_UTILE__GooF \
\
expression \
\
DESACTIVER__S_IL_EST_ACTIVABLE__ET__SI_UTILE__GooF \
/* Procedure introduite le 20080105225133 permettant de disposer de l'Expression */ \
/* 'expression' en utilisant le 'GooF'... */
# define USs_GooF(sequence) \
Bblock \
USe_GooF(BLOC(sequence)); \
Eblock \
/* Procedure introduite le 20080105225133 permettant de disposer de la Sequence */ \
/* 'sequence' en utilisant le 'GooF'... */
# define USe_GooF______CONDITIONNEL(utiliser_le_GooF,expression) \
COND(IL_FAUT(utiliser_le_GooF) \
,USe_GooF(expression) \
,expression \
) \
/* Procedure introduite le 20080110082529 et destinee a disposer de deux versions de */ \
/* l'expression 'expression' : la premiere utilisant le 'GooF' et la seconde ne */ \
/* l'utilisant pas. */
# define USs_GooF______CONDITIONNEL(utiliser_le_GooF,sequence) \
Bblock \
Test(IL_FAUT(utiliser_le_GooF)) \
Bblock \
USs_GooF(BLOC(sequence)); \
Eblock \
ATes \
Bblock \
BLOC(sequence); \
Eblock \
ETes \
Eblock \
/* Procedure introduite le 20071103133020 et destinee a disposer de deux versions de la */ \
/* sequence 'sequence' : la premiere utilisant le 'GooF' et la seconde ne l'utilisant pas. */ \
/* Cette optimisation (issue de 'v $xrv/densite.01$K USs_GooF______CONDITIONNEL' a cette */ \
/* date) permet de ne pas etre penalise par la perte de performance impliquee par le 'GooF'. */ \
/* On pourra donc introduire sans aucune difficulte le 'GooF' a l'interieur de nombreuses */ \
/* fonctions et cela sans avoir a dupliquer "manuellement" les suites d'instructions sur */ \
/* lesquelles le 'GooF' portera... */ \
/* */ \
/* Le 20080110082529 le nom 'UTILISER_EN_OPTION_LE_GooF(...)' fut change en le nom */ \
/* 'USs_GooF______CONDITIONNEL(...)' (de meme longueur afin de simplifier la mise a jour */ \
/* au niveau de la mise en page). Cela est d'une part plus "symetrique" avec 'USs_GooF(...)' */ \
/* et permet l'introduction a la meme date de ''USs_GooF______CONDITIONNEL(...)' d'autre */ \
/* part... */ \
/* */ \
/* Le 20080110135837, on notera le rapport de performance entre la non activation du 'GooF' */ \
/* et son activation sur le tests suivant sur '$LACT18' (au format 'Pal') : */ \
/* */ \
/* $xci/gauss$X standard=FAUX gauss_arithmetique_de_base=VRAI */ \
/* */ \
/* qui donne une duree de 0.264 et : */ \
/* */ \
/* $xci/gauss$X standard=FAUX gauss_arithmetique_etendue=VRAI */ \
/* */ \
/* qui donne une duree de 5.016, soit un facteur de ralentissement de pratiquement 20, ce */ \
/* qui n'est pas si dramatique que cela. Grace a 'v $xig/fonct$vv$DEF 20080111092552', cette */ \
/* duree est passee le 20080111100347 a 2.028, d'ou un nouveau facteur de ralentissement */ \
/* de moins de 8, ce qui n'est pas si mauvais que cela. Le 20080111145152, nouvelle */
/* amelioration grace a 'v $xil/defi_K2$vv$DEF 20080111142631' ; la duree de calcul en */
/* mode arithmetique etendue est passee a 1.856, soit un rapport de 7... */
#Aifdef PRAGMA_CPP_____AUTORISER_LE_GooF
# define USe_GooF(expression) \
expression \
/* Procedure introduite le 20080105225133... */ \
/* */ \
/* ATTENTION : il est evidemment impossible de mettre ici un 'PRINT_ATTENTION(...)'... */
# define USs_GooF(sequence) \
Bblock \
USe_GooF(BLOC(sequence)); \
Eblock \
/* Procedure introduite le 20080106183801... */ \
/* */ \
/* Le 20080128100911, le message : */ \
/* */ \
/* PRINT_ATTENTION("le 'GooF' n'est pas autorise ici et n'est donc pas utilisable (1)"); */ \
/* */ \
/* a ete supprime "par symetrie" avec 'USs_GooF______CONDITIONNEL(...)' ci-apres... */
# define USe_GooF______CONDITIONNEL(utiliser_le_GooF,expression) \
expression \
/* Procedure introduite le 20080110082529... */ \
/* */ \
/* ATTENTION : il est evidemment impossible de mettre ici un 'PRINT_ATTENTION(...)'... */
# define USs_GooF______CONDITIONNEL(utiliser_le_GooF,sequence) \
Bblock \
BLOC(sequence); \
Eblock \
/* Procedure introduite le 20071103133020... */ \
/* */ \
/* Le 20080128100911, le message : */ \
/* */ \
/* PRINT_ATTENTION("le 'GooF' n'est pas autorise ici et n'est donc pas utilisable (2)"); */ \
/* */ \
/* a ete supprime a cause de 'v $xrv/champs_5.26$I USs_GooF______CONDITIONNEL' car, en */ \
/* effet, tous les '$K' de '$xr' (et en fait surtout de '$xrs') n'autorisent pas le 'GooF'. */
#Eifdef PRAGMA_CPP_____AUTORISER_LE_GooF
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* A P P E L C O N D I T I O N N E L D E T Y P E " S O U S - P R O G R A M M E " D ' U N E F O N C T I O N : */
/* */
/*************************************************************************************************************************************/
#define gCALC(condition,sequence_si_VRAI,sequence_si_FAUX) \
Bblock \
Test(EST_VRAI(condition)) \
Bblock \
BLOC(sequence_si_VRAI); \
Eblock \
ATes \
Bblock \
BLOC(sequence_si_FAUX); \
Eblock \
ETes \
Eblock \
/* Pour effectuer le choix entre deux appels, et plus generalement entre deux sequences. */
#define EXECUTER_LES_CALC \
VRAI
#define NE_PAS_EXECUTER_LES_CALC \
NOTL(EXECUTER_LES_CALC)
/* Valeurs possibles de l'ensemble des indicateurs 'executer_les_CALi' qui sont definis */
/* dans '$xig/common$STR'. */
#define CALC(fonction,appeler_la_fonction) \
Bblock \
gCALC(IL_FAUT(appeler_la_fonction) \
,BLOC(CALS(fonction);) \
,BLOC(VIDE;) \
); \
Eblock \
/* Pour effectuer l'appel conditionnel d'une fonction comme un sous-programme (type */ \
/* FORTRAN) suivant l'etat d'un indicateur de controle. */
#define CAL1(fonction) \
Bblock \
CALC(fonction,CAL1_____executer); \
Eblock \
/* Appel conditionnel par 'CAL1_____executer' d'une fonction comme un sous-programme. */ \
/* L'utilisation actuelle est la suivante : */ \
/* */ \
/* CAL1(...) : conditionne tous les appels aux fonctions 'Prer?(...)'. */ \
/* */ \
/* Cela concerne donc aussi : */ \
/* */ \
/* PRINT_ATTENTION(...) */ \
/* PRINT_DEFAUT(...) */ \
/* PRINT_ERREUR(...) */ \
/* */
#define CAL2(fonction) \
Bblock \
CALC(fonction,CAL2_____executer); \
Eblock \
/* Appel conditionnel par 'CAL2_____executer' d'une fonction comme un sous-programme. */ \
/* L'utilisation actuelle est la suivante : */ \
/* */ \
/* CAL2(...) : conditionne tous les appels aux fonctions 'Prin?(...)'. */ \
/* */
#define CAL3(fonction) \
Bblock \
CALC(fonction,CAL3_____executer); \
Eblock \
/* Appel conditionnel par 'CAL3_____executer' d'une fonction comme un sous-programme. */ \
/* L'utilisation actuelle est la suivante : */ \
/* */ \
/* CAL3(...) : conditionne tous les appels aux fonctions 'Prme?(...)'. */ \
/* */
#define CAL4(fonction) \
Bblock \
CALC(fonction,CAL4_____executer); \
Eblock \
/* Appel conditionnel par 'CAL4_____executer' d'une fonction comme un sous-programme. */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N D E S M E S S A G E S D ' E R R E U R S : */
/* */
/*************************************************************************************************************************************/
=define MESSAGE_S C_VIDE
/* Ceci est un message Secondaire a editer dans 'PRINT_ERREUR', 'PRINT_ATTENTION' et */
/* 'PRINT_DEBUG' ; il est initialise vide, mais peut etre modifie en permanence par une */
/* suite de deux directives '=undef MESSAGE_S' et '=define MESSAGE_S...' ; de plus, */
/* il est defini par '=define' et non pas '#define' afin de pouvoir etre lui-meme genere */
/* par une macro, il doit donc tenir sur une seule ligne (c'est plus prudent), d'ou le */
/* nom tres court qui lui est donne ('MESSAGE_S')... */
#define MESSAGE_T \
C_VIDE \
/* Ceci est un message Tertiaire a editer dans 'PRINT_ERREUR', 'PRINT_ATTENTION' et */ \
/* 'PRINT_DEBUG' ; il est toujours VIDE, mais a ete introduit a cause de 'PRINT_MESSAGE'. */
#define EDITER_LES_MESSAGES_DE_PRINT_MESSAGE \
VRAI
#define NE_PAS_EDITER_LES_MESSAGES_DE_PRINT_MESSAGE \
NOTL(EDITER_LES_MESSAGES_DE_PRINT_MESSAGE)
/* Valeurs possibles de l'indicateur 'PRINT_MESSAGE_____editer_les_messages' defini */
/* dans 'v $xig/common$STR'. */
#define PRINT_MESSAGE(message1,message2) \
Bblock \
Test(IFNE_chaine(message2,C_VIDE)) \
Bblock \
PRINT_DEFAUT(MESSAGE_DE_MESSAGE,message1,message2,PRINT_MESSAGE_____editer_les_messages); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
/* Macro d'edition de deux messages si 'message2' n'est pas VIDE et inhibable par */ \
/* 'CAL1_____executer' (via 'gPRINT_DEFAUT(...)'). */
#define EDITER_LES_MESSAGES_DE_PRINT_ATTENTION \
VRAI
#define NE_PAS_EDITER_LES_MESSAGES_DE_PRINT_ATTENTION \
NOTL(EDITER_LES_MESSAGES_DE_PRINT_ATTENTION)
/* Valeurs possibles de l'indicateur 'PRINT_ATTENTION_____editer_les_messages' defini */
/* dans 'v $xig/common$STR'. */
#define PRINT_ATTENTION(message) \
Bblock \
PRINT_DEFAUT(MESSAGE_D_ATTENTION,message,MESSAGE_T,PRINT_ATTENTION_____editer_les_messages); \
Eblock \
/* Macro d'edition d'un message d'attention inhibable par 'CAL1_____executer'. */
#define EDITER_LES_MESSAGES_DE_PRINT_AVERTISSEMENT \
VRAI
#define NE_PAS_EDITER_LES_MESSAGES_DE_PRINT_AVERTISSEMENT \
NOTL(EDITER_LES_MESSAGES_DE_PRINT_AVERTISSEMENT)
/* Valeurs possibles de l'indicateur 'PRINT_AVERTISSEMENT_____editer_les_messages' defini */
/* dans 'v $xig/common$STR'. Ce nouvel indicateur a ete ajoute le 19990210110724 afin de */
/* (implicitement) tous les messages du type 'PRINT_ATTENTION(...)' qui sortent avec les */
/* programmes de '$xrv' en particulier, et par exemple : */
/* */
/* "'ne=' doit etre defini avant toute entree de fichiers" */
/* "'saut=' doit etre defini avant toute entree de fichiers" */
/* */
/* et qui sont finalement assez inutiles... */
#define PRINT_AVERTISSEMENT(message) \
Bblock \
PRINT_DEFAUT(MESSAGE_D_AVERTISSEMENT,message,MESSAGE_T,PRINT_AVERTISSEMENT_____editer_les_messages); \
Eblock \
/* Macro d'edition d'un message d'avertissement inhibable par 'CAL1_____executer'. */
#define EDITER_LES_MESSAGES_DE_PRINT_ERREUR \
VRAI
#define NE_PAS_EDITER_LES_MESSAGES_DE_PRINT_ERREUR \
NOTL(EDITER_LES_MESSAGES_DE_PRINT_ERREUR)
/* Valeurs possibles de l'indicateur 'PRINT_ERREUR_____editer_les_messages' defini */
/* dans 'v $xig/common$STR'. */
#define PRINT_ERREUR(message) \
Bblock \
PRINT_DEFAUT(MESSAGE_D_ERREUR,message,MESSAGE_T,PRINT_ERREUR_____editer_les_messages); \
Eblock \
/* Macro d'edition d'un message d'erreur inhibable par 'CAL1_____executer'. */
#define EDITER_LES_MESSAGES_DE_PRINT_DEBUG \
VRAI
#define NE_PAS_EDITER_LES_MESSAGES_DE_PRINT_DEBUG \
NOTL(EDITER_LES_MESSAGES_DE_PRINT_DEBUG)
/* Valeurs possibles de l'indicateur 'PRINT_DEBUG_____editer_les_messages' defini */
/* dans 'v $xig/common$STR'. */
#define PRINT_DEBUG(message) \
Bblock \
DEBU(PRINT_DEFAUT(MESSAGE_DE_DEBUG,message,MESSAGE_T,PRINT_DEBUG_____editer_les_messages);); \
Eblock \
/* Macro d'edition d'un message de debug inhibable par 'CAL1_____executer'. */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* P O U R U T I L I S E R L E C H R O N O M E T R E " C L O C K " E N S E C O N D E S : */
/* */
/*************************************************************************************************************************************/
#define CHRONOMETRAGE_D_UN_BLOC(nom_du_BLOC,BLOC_a_chronometrer,chronometrer_le_BLOC) \
Bblock \
Bclock(nom_du_BLOC,chronometrer_le_BLOC); \
BLOC(BLOC_a_chronometrer); \
Eclock(nom_du_BLOC,chronometrer_le_BLOC); \
Eblock \
/* Chronometrage d'un 'BLOC'... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N D E S U N I T E S D E T E M P S : */
/* */
/*************************************************************************************************************************************/
#define IMAGES_PAR_SECONDE \
VINGT_CINQ \
/* Nombre d'images par seconde. */
#define milli_secondes \
MILLE \
/* Nombre de milli-secondes dans une seconde. */
#define micro_secondes \
MILLION \
/* Nombre de micro-secondes dans une seconde. */
#define nano_secondes \
MILLIARD \
/* Nombre de nano-secondes dans une seconde. */
#define SECONDES_PAR_MINUTE \
SOIXANTE \
/* Nombre de secondes par minute. */
#define MINUTES_PAR_HEURE \
SOIXANTE \
/* Nombre de minutes par heure. */
#define HEURES_PAR_JOUR \
VINGT_QUATRE \
/* Nombre d'heures par jour. */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N D E S L I S T E S ( P R E M I E R T Y P E ) : */
/* */
/* */
/* Definitions : */
/* */
/* On definit ici les structures de */
/* la gestion des listes ; d'une part */
/* l'en-tete (ou "header") qui con- */
/* tient les chainages et la taille */
/* (ou "volume") des octets d'infor- */
/* mation, et d'autre part les infor- */
/* mations utiles memorisees dans cet */
/* element (sous forme d'un tableau */
/* de "CHAR"). Enfin, une clef de */
/* validation est inseree afin de */
/* valider chaque acces a un element */
/* de liste... */
/* */
/* */
/* ATTENTION : */
/* */
/* Ces definitions doivent etre imperativement */
/* ici, et non pas dans '$xig/fonct$vv$DEF', car */
/* les types alors definis sont utilises dans des */
/* fichiers du type '$EXT' avant que le fichier */
/* '$xig/fonct$vv$DEF' ne soit pris en compte... */
/* */
/*************************************************************************************************************************************/
TypedefP(l_header,STRU(liste_header))
TypedefS(A___l_header,l_header)
TypedefS(E___l_header,l_header)
/* 'l_header' permet de definir l'en-tete de chainage d'un element */
/* de liste vers son predecesseur et son successeur respectivement. */
TypedefP(l_element,STRU(list_element))
TypedefS(A___l_element,l_element)
TypedefS(E___l_element,l_element)
/* 'l_element' permet de definir un element de liste, c'est-a-dire l'en-tete */
/* et les informations utiles ; mais il doit preceder la definition de la structure */
/* 'liste_header' pour des raisons de recursivite... */
Dstruct04(liste_header
,DEFV(l_element,POINTERs(precedent_chainage))
/* Pointeur vers l'element precedent ("BACKWARD"). */
,DEFV(l_element,POINTERs(suivant_chainage))
/* Pointeur vers l'element suivant ("FORWARD"). */
,DEFV(Int,clef_validation)
/* Cette entree doit toujours contenir la meme information... */
,DEFV(Positive,volume)
/* Cette entree contient la longueur en octets des informations memorisees */
/* dans cet element de liste. */
,NOM_VIDE
);
#define v_element \
SLLS(BIT,NBITOC) \
/* Nombre d'octets maximal que pourra memoriser un element de liste. */
Dstruct02(list_element
,DEFV(l_header,header)
/* En-tete de chainage d'un element de liste. */
,DEFV(CHAR,DTb1(informations,v_element))
/* Pour contenir les informations que memorise la liste. */
,NOM_VIDE
);
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N D E S L I S T E S ( D E U X I E M E T Y P E ) : */
/* */
/* */
/* Definitions : */
/* */
/* On definit ici des structures et des */
/* procedures de gestion de listes d'emploi */
/* plus generales que celles du premier */
/* type. En particulier il est possible */
/* de definir les chainages, les descripteurs */
/* de liste, les fonctions d'acces, de */
/* creation, de destruction et enfin de */
/* parcours... */
/* */
/*************************************************************************************************************************************/
#define DEFINITION_D_UNE_STRUCTURE_DE_CHAINAGE(liste,structure) \
Dstruct03($liste \
,DEFV(structure,POINTERs(suivant)) \
,DEFV(structure,POINTERs(precedent)) \
,DEFV(Logical,chainage) \
,NOM_VIDE \
); \
Typedef(liste,STRU($liste)) \
/* Definition d'une structure de liste avec chainage avant et arriere. Ce bloc peut bien */ \
/* entendu etre insere dans des structures plus complexes... */ \
/* */ \
/* Le 20031103105541 l'indicateur 'chainage' a ete introduit ; il est a l'etat 'VALIDE' */ \
/* des 'gINSERTION_ELEMENT(...)' et par 'gDESTRUCTION_ELEMENT(...)' a l'etat 'INVALIDE'. */ \
/* Cela signifie de plus que la memoire allouee n'est plus jamais rendue. Cela peut sembler */ \
/* peu economique, mais cela est justifie par certains usages qui est fait de la procedure */ \
/* 'PARCOURS_D_UNE_LISTE(...)'. Ainsi 'v $xrq/nucleon.LH$I STRONG_TRANSFORMATION_GxG___G', */ \
/* par exemple, l'utilise et la sequence d'instruction 'sequence' contient deux ordres de */ \
/* destruction ce qui rend dans certaines circonstances 'element_suivant' non fiable. Soit */ \
/* le cas suivant de liste : */ \
/* */ \
/* */ \
/* element_courant element_suivant */ \
/* */ \
/* | | */ \
/* | | */ \
/* \|/ \|/ */ \
/* */ \
/* --------- --------- --------- --------- */ \
/* | | | | | | | | */ \
/* --> | | --> | gluonD1 | --> | gluonD2 | --> | | -->... */ \
/* | | | | | | | | */ \
/* --------- --------- --------- --------- */ \
/* | | /|\| */ \
/* | | | | */ \
/* | ----------------- | */ \
/* | "D2 voisin de D1" | */ \
/* | | */ \
/* \|/ \|/ */ \
/* */ \
/* 'gluonD1' et 'gluonD2' sont alors detruits */ \
/* */ \
/* */ \
/* Alors, 'element_suivant' n'a plus de sens et donc lors du parcours, le prochain element */ \
/* courant (qui est l'actuel element suivant) ne sera plus valide... */
#define SUIVANT_DANS_UNE_LISTE(element_courant) \
ASD1(element_courant,suivant)
#define PRECEDENT_DANS_UNE_LISTE(element_courant) \
ASD1(element_courant,precedent)
/* Procedures d'acces aux elements suivants et precedents... */
#define VALIDATION_D_UN_ELEMENT_D_UNE_LISTE(element_courant) \
ASD1(element_courant,chainage) \
/* Acces a un element dans une liste. */
#define ACCES_A_UN_ELEMENT_D_UNE_LISTE(element_courant) \
element_courant \
/* Acces a un element dans une liste. */
#define CREATION_D_UNE_LISTE(structure,Tete,Queue,longueur,debordement,indefini) \
DEFV(Local,DEFV(structure,INIT(POINTERs(Tete),indefini))); \
DEFV(Local,DEFV(structure,INIT(POINTERs(Queue),indefini))); \
/* Definition de la tete et de la queue de la liste a creer. */ \
DEFV(Local,DEFV(Positive,INIT(longueur,ZERO))); \
/* Compteur des elements presents dans la liste et 'VALIDE's... */ \
DEFV(Local,DEFV(structure,debordement)); \
/* Au cas ou la liste serait saturee... */ \
/* */ \
/* definition des differentes donnees necessaires a la gestion d'une liste... */
#define gPARCOURS_D_UNE_LISTE(structure,Tete,Queue,longueur,debordement,indefini,Fsucc,Fpred,Fvalid,element_courant,SeqVAL,SeqINVAL) \
Bblock \
DEFV(structure,INIT(POINTERs(element_precedent),indefini)); \
DEFV(structure,INIT(POINTERs(element_courant_precedent),indefini)); \
/* Element precedent de 'element_courant' (introduit le 20031101142304 lors de problemes */ \
/* avec 'v $xrq/vide.L0$K', ces problemes ayant ete resolus le 20031103105541 avec */ \
/* l'introduction de 'chainage' dans 'DEFINITION_D_UNE_STRUCTURE_DE_CHAINAGE(...)'). */ \
DEFV(structure,INIT(POINTERs(element_courant),Tete)); \
/* Structure courante dans la liste... */ \
DEFV(structure,INIT(POINTERs(element_suivant),indefini)); \
/* Et son suivant. Celui-ci doit etre introduit car en effet, au cas ou dans 'sequence' */ \
/* l'element courant serait detruit, faire apres 'sequence' : */ \
/* */ \
/* EGAL(element_courant,Fsucc(element_courant)); */ \
/* */ \
/* serait donc extremement dangereux... */ \
Tant(IFNE(element_courant,indefini)) \
Bblock \
/* Les tests qui suivent ont ete sintroduit le 20031101142304 lors de problemes avec */ \
/* 'v $xrq/vide.L0$K', ces problemes ayant ete resolus le 20031103105541 avec l'introduction */ \
/* de 'chainage' dans 'DEFINITION_D_UNE_STRUCTURE_DE_CHAINAGE(...)'). */ \
EGAL(element_precedent,Fpred(element_courant)); \
\
Test(IFNE(element_precedent,indefini)) \
Bblock \
Test(IFNE(Fsucc(element_precedent),element_courant)) \
Bblock \
PRINT_ERREUR("probleme de chainage 'AVANT' lors du parcours d'une liste"); \
CAL1(Prer1("veritable element precedent....=0x%x\n",element_courant_precedent)); \
CAL1(Prer1("element precedent..............=0x%x\n",element_precedent)); \
CAL1(Prer1("successeur(element precedent)..=0x%x different de :\n",Fsucc(element_precedent))); \
CAL1(Prer1("element courant................=0x%x\n",element_courant)); \
CAL1(Prer1("predecesseur(element precedent)=0x%x\n",Fpred(element_precedent))); \
CAL1(Prer1("tete de la liste...............=0x%x\n",Tete)); \
CAL1(Prer1("queue de la liste..............=0x%x\n",Queue)); \
CAL1(Prer1("indicateur de fin de liste.....=0x%x\n",indefini)); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
\
Test(IFNE(element_precedent,Fpred(element_courant))) \
Bblock \
PRINT_ERREUR("probleme de chainage 'ARRIERE' lors du parcours d'une liste"); \
CAL1(Prer1("element courant................=0x%x\n",element_courant)); \
CAL1(Prer1("predecesseur(element courant)..=0x%x different de :\n",Fpred(element_courant))); \
CAL1(Prer1("veritable element precedent....=0x%x\n",element_courant_precedent)); \
CAL1(Prer1("element precedent..............=0x%x\n",element_precedent)); \
CAL1(Prer1("tete de la liste...............=0x%x\n",Tete)); \
CAL1(Prer1("queue de la liste..............=0x%x\n",Queue)); \
CAL1(Prer1("indicateur de fin de liste.....=0x%x\n",indefini)); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
\
EGAL(element_suivant,Fsucc(element_courant)); \
/* La premiere chose est de recuperer l'eventuel element suivant (au cas, rappelons-le, ou */ \
/* l'element courant serait detruit...). */ \
\
Test(EST_VALIDE(Fvalid(element_courant))) \
Bblock \
/* Cas ou l'element courant est 'VALIDE' : */ \
BLOC(SeqVAL); \
/* Execution de la sequence argument 'SeqVAL' sur chaque element 'VALIDE'... */ \
Eblock \
ATes \
Bblock \
/* Cas ou l'element courant est 'INVALIDE' : cela signifie qu'il a fait l'objet d'un */ \
/* 'DESTRUCTION_ELEMENT(...)' anterieurement... */ \
BLOC(SeqINVAL); \
/* Execution de la sequence argument 'SeqINVAL' sur chaque element 'INVALIDE'... */ \
Eblock \
ETes \
\
EGAL(element_courant_precedent,element_courant); \
EGAL(element_courant,element_suivant); \
/* Enfin, passage a l'element suivant (si il existe...). */ \
\
Test(IFEQ(Fsucc(element_courant),indefini)) \
Bblock \
Test(IFNE(element_courant,Queue)) \
Bblock \
PRINT_ERREUR("probleme de queue lors du parcours d'une liste"); \
CAL1(Prer1("element precedent=0x%x different de :\n",element_courant)); \
CAL1(Prer1("queue............=0x%x\n",Queue)); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
ETan \
Eblock \
/* Repetition d'une certaine sequence sur un ensemble d'elements appartenant a une liste, */ \
/* 'element_courant' definissant l'element courant (introduit le 20031104090749 afin de */ \
/* permettre une passe de nettoyage des elements 'INVALIDE' dans la procedure */ \
/* 'PARCOURS_D_UNE_LISTE(...)'. */
#define PARCOURS_D_UNE_LISTE(structure,Tete,Queue,longueur,debordement,indefini,Fsucc,Fpred,Fvalid,element_courant,sequence) \
Bblock \
gPARCOURS_D_UNE_LISTE(structure \
,Tete,Queue \
,longueur \
,debordement \
,indefini \
,Fsucc,Fpred,Fvalid \
,element_courant \
,BLOC(sequence) \
,BLOC(VIDE;) \
); \
/* Premiere passe sur tous les elements de la liste 'VALIDE' afin d'executer pour eux la */ \
/* sequence 'sequence'. On notera qu'il peut y avoir ici des 'INSERTION_ELEMENT(...)'s */ \
/* et des 'DESTRUCTION_ELEMENT(...)'s, mais qu'il est essentiel de ne surtout pas toucher */ \
/* alors aux elements mis a l'etat 'INVALIDE' pour ne pas perturber les chainages comme */ \
/* cela est explique lors de la definition de l'element 'chainage' de la structure de la */ \
/* liste 'liste'... */ \
\
gPARCOURS_D_UNE_LISTE(structure \
,Tete,Queue \
,longueur \
,debordement \
,indefini \
,Fsucc,Fpred,Fvalid \
,element_courant \
,BLOC(VIDE;) \
,BLOC(Test(IFET(IFEQ(element_courant,Tete),IFEQ(element_courant,Queue))) \
Bblock \
/* Cas ou la liste ne contenait que l'element a detruire : */ \
EGAL(Tete,indefini); \
EGAL(Queue,indefini); \
Eblock \
ATes \
Bblock \
Test(IFEQ(element_courant,Tete)) \
Bblock \
EGAL(Tete,element_suivant); \
\
Test(IFNE(Tete,indefini)) \
Bblock \
/* Cas ou l'element a detruire etait en tete : */ \
EGAL(Fpred(Tete),indefini); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
ATes \
Bblock \
Test(IFEQ(element_courant,Queue)) \
Bblock \
/* Cas ou l'element a detruire etait en queue : */ \
EGAL(Queue,element_precedent); \
\
Test(IFNE(Queue,indefini)) \
Bblock \
EGAL(Fsucc(Queue),indefini); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
ATes \
Bblock \
/* Cas ou l'element a detruire etait "au milieu" de la liste : */ \
Test(IFNE(element_suivant,indefini)) \
Bblock \
EGAL(Fpred(element_suivant),element_precedent); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
\
Test(IFNE(element_precedent,indefini)) \
Bblock \
EGAL(Fsucc(element_precedent),element_suivant); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
ETes \
Eblock \
ETes \
Eblock \
ETes \
\
CALZ_FreLL(element_courant); \
/* Enfin, on libere l'espace memoire alloue a l'element qui disparait... */ \
) \
); \
/* Deuxieme passe sur tous les elements de la liste afin de detruire les eventuels */ \
/* elements 'INVALIDE' qui existent... */ \
Eblock \
/* Repetition d'une certaine sequence sur un ensemble d'elements appartenant a une liste, */ \
/* 'element_courant' definissant l'element courant... */
#define INSERTION_ELEMENT(structure,Tete,Queue,longueur,debordement,indefini,Fsucc,Fpred,Fvalid,element_cree,sequence) \
Bblock \
EGAL(element_cree,tMalo(SIZP($structure),structure)); \
/* Allocation de la memoire necessaire a l'element a creer. */ \
\
Test(IFEQ(element_cree,indefini)) \
Bblock \
PRINT_ERREUR("l'allocation memoire pour l'element a creer n'a pas eu lieu"); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
\
Test(IFEQ(element_cree,PLUS_DE_MEMOIRE_LIBRE)) \
Bblock \
PRINT_ERREUR("la memoire est saturee, on ne peut donc plus inserer d'elements dans une liste"); \
CAL1(Prer1("(%d structures)\n",longueur)); \
EGAL(element_cree,ADRESSE(debordement)); \
/* A priori, on pointe sur la zone de debordement pour eviter les ennuis... */ \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
\
EGAL(Fsucc(element_cree),indefini); \
EGAL(Fpred(element_cree),Queue); \
/* Creation des chainages "avant" et "arriere" de l'element que l'on vient de creer. */ \
\
Test(IFEQ(Tete,indefini)) \
Bblock \
EGAL(Tete,element_cree); \
/* Cas ou la liste etait vide : il faut initialiser sa "tete". */ \
Eblock \
ATes \
Bblock \
/* Cas ou la liste n'etait pas vide : la "tete" ne change pas... */ \
Eblock \
ETes \
\
Test(IFEQ(Queue,indefini)) \
Bblock \
/* Cas ou la liste etait vide : il n'y a donc pas d'ancien element a mettre a jour... */ \
Eblock \
ATes \
Bblock \
EGAL(Fsucc(Queue),element_cree); \
/* Cas ou la liste n'etait pas vide : il faut chainer l'ancien dernier element avec celui */ \
/* que l'on vient de creer... */ \
Eblock \
ETes \
\
EGAL(Queue,element_cree); \
/* L'element cree se trouve en "queue" de la structure. */ \
\
EGAL(Fvalid(element_cree),VALIDE); \
/* L'element cree est 'VALIDE' jusqu'a sa 'DESTRUCTION_ELEMENT(...)'... */ \
\
BLOC(sequence); \
/* Et execution d'une sequence specifique... */ \
\
INCR(longueur,I); \
/* Et comptage global des structures en presence... */ \
Eblock \
/* Connexion d'un element 'element_cree' dans une liste et allocation eventuelle de la */ \
/* memoire... */
#define DESTRUCTION_ELEMENT(structure,Tete,Queue,longueur,debordement,indefini,Fsucc,Fpred,Fvalid,Aelement_a_detruire,sequence) \
Bblock \
DEFV(structure,INIT(POINTERs(element_a_detruire),Aelement_a_detruire)); \
/* Il est imperatif de dupliquer ici le pointeur de l'element a detruire si l'on ne veut */ \
/* pas d'ennuis, en particulier, lors du 'FreLL(element_a_detruire)' ci-apres... */ \
\
Test(IFET(IFNE(element_a_detruire,ADRESSE(debordement)) \
,EST_VALIDE(Fvalid(element_a_detruire)) \
) \
) \
Bblock \
Test(I3ET(IFNE(Tete,indefini) \
,IFNE(Queue,indefini) \
,IFNE(element_a_detruire,indefini) \
) \
) \
Bblock \
DEFV(structure,INIT(POINTERs(element_precedent),indefini)); \
DEFV(structure,INIT(POINTERs(element_suivant),indefini)); \
EGAL(element_precedent,Fpred(element_a_detruire)); \
EGAL(element_suivant,Fsucc(element_a_detruire)); \
/* Ces deux structures sont introduites simplement pour simplifier la mise a jour des */ \
/* differents chainages, l'initialisation en deux temps etant liees aux compilateurs... */ \
\
Test(IFNE(element_precedent,indefini)) \
Bblock \
/* Test introduit le 20031102085818. */ \
Test(IFNE(Fsucc(element_precedent),element_a_detruire)) \
Bblock \
PRINT_ERREUR("probleme de chainage 'AVANT' lors de la destruction d'un element de liste"); \
CAL1(Prer1("element precedent............=0x%x\n",element_precedent)); \
CAL1(Prer1("successeur(element precedent)=0x%x different de :\n",Fsucc(element_precedent))); \
CAL1(Prer1("element a detruire...........=0x%x\n",element_a_detruire)); \
CAL1(Prer1("tete de la liste.............=0x%x\n",Tete)); \
CAL1(Prer1("queue de la liste............=0x%x\n",Queue)); \
CAL1(Prer1("indicateur de fin de liste...=0x%x\n",indefini)); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
\
Test(IFNE(element_suivant,indefini)) \
Bblock \
/* Test introduit le 20031102085818. */ \
Test(IFNE(element_a_detruire,Fpred(element_suivant))) \
Bblock \
PRINT_ERREUR("probleme de chainage 'ARRIERE' lors de la destruction d'un element de liste"); \
CAL1(Prer1("element suivant..............=0x%x\n",element_suivant)); \
CAL1(Prer1("predecesseur(element suivant)=0x%x different de :\n",Fpred(element_suivant))); \
CAL1(Prer1("element a detruire...........=0x%x\n",element_a_detruire)); \
CAL1(Prer1("tete de la liste.............=0x%x\n",Tete)); \
CAL1(Prer1("queue de la liste............=0x%x\n",Queue)); \
CAL1(Prer1("indicateur de fin de liste...=0x%x\n",indefini)); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
\
EGAL(Fvalid(element_a_detruire),INVALIDE); \
/* L'element detruit est 'INVALIDE', mais conserve dans la liste afin de ne pas rompre */ \
/* les chainages. On notera donc qu'il n'y a pas de : */ \
/* */ \
/* CALS(FreLL(element_a_detruire)); */ \
/* */ \
/* ci -apres... */ \
\
BLOC(sequence); \
/* Et execution d'une sequence specifique... */ \
\
DECR(longueur,I); \
/* Decomptage des elements en presence... */ \
Eblock \
ATes \
Bblock \
PRINT_ERREUR("probleme lors de la destruction d'un element"); \
CAL1(Prer1("tete..............=0x%x\n",Tete)); \
CAL1(Prer1("queue.............=0x%x\n",Queue)); \
CAL1(Prer1("element_a_detruire=0x%x\n",element_a_detruire)); \
CAL1(Prer1("(indefini=0x%x)\n",indefini)); \
Eblock \
ETes \
Eblock \
ATes \
Bblock \
Test(IFEQ(element_a_detruire,ADRESSE(debordement))) \
Bblock \
PRINT_ERREUR("la destruction de la zone de debordement est demandee"); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
\
Test(EST_INVALIDE(Fvalid(element_a_detruire))) \
Bblock \
PRINT_ERREUR("la destruction d'un element 'INVALIDE' est demandee"); \
CAL1(Prer1("element a detruire...........=0x%x\n",element_a_detruire)); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
ETes \
Eblock \
/* Deconnexion d'un element 'element_a_detruire' dans une liste et liberation eventuelle */ \
/* de la memoire occupee... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N S L O C A L E S E T P R O P R E S A ' $sHOTE ' : */
/* */
/*************************************************************************************************************************************/
#define sHOTE_____NOMBRE_DE_PROCESSEURS \
GvalDefaut("ProcessorNumber",UN) \
/* Nombre de processeurs (introduit le 20170418100108). */
#define VALEUR_PAR_DEFAUT_DE_PCMemorySizeMB \
QUATRE_VINGT
#define sHOTE_____TAILLE_DE_LA_MEMOIRE_DE_REFERENCE_EN_MEGA_OCTETS \
GvalDefaut("PCMemorySizeMB",VALEUR_PAR_DEFAUT_DE_PCMemorySizeMB)
/* Taille de la memoire en mega-octets (introduit le 20170418100108). */
/* */
/* 'VALEUR_PAR_DEFAUT_DE_PCMemorySizeMB' a ete introduit dans 'v $xig/fonct$vv$DEF' le */
/* 20120201104802, puis deplace ici le 20170418102408... */
#define VALEUR_PAR_DEFAUT_DE_MemorySizeMB \
MILLE
#define sHOTE_____TAILLE_DE_LA_MEMOIRE_EN_MEGA_OCTETS \
GvalDefaut("MemorySizeMB",VALEUR_PAR_DEFAUT_DE_MemorySizeMB)
/* Taille de la memoire en mega-octets (introduit le 20170418100108). */
/* */
/* Le 20170418101457, 'GvalDefaut(...)' a remplace 'Gval(...)'. */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D I R E C T O R Y R A C I N E O U " H O M E - D I R E C T O R Y " : */
/* */
/*************************************************************************************************************************************/
#define HOME_DIRECTORY \
GvarDefaut("x" \
,Gvar("HOME") \
) \
/* Definition du "home-directory" a l'aide de '$x'. On notera que si cette variable */ \
/* n'existe pas (ce qui peut apparaitre lors de l'utilisation d'une commande via la */ \
/* commande 'v $xcg/remote.01$K shell'), on la definit a l'aide de '$HOME' sachant bien */ \
/* que sur certains SYSTEMEs '$x' et '$HOME' peuvent differer (voir '$EDFR22')... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D I R E C T O R Y C O U R A N T : */
/* */
/*************************************************************************************************************************************/
#define CURRENT_DIRECTORY \
Gvar("CWD") \
/* Definition du "current-directory" (introduit le 20050906091415). */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D I R E C T O R Y D E S C O M M A N D E S G E N E R A L E S : */
/* */
/*************************************************************************************************************************************/
#define Direct_xcg \
GvarDefaut("xcg" \
,EGAs(chain_Aconcaten5(HOME_DIRECTORY \
,cSEPARATEUR_DES_PATHS \
,"commandes" \
,cSEPARATEUR_DES_PATHS \
,"generales" \
) \
) \
) \
/* Definition du directory '$xcg'. Ceci a ete introduit le 20041221122847 afin de */ \
/* faciliter l'utilisation de 'EXECUTION_D_UNE_SUITE_DE_COMMANDES_SOUS_SH(...)'... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D I R E C T O R Y D E S C O M M A N D E S I M A G E S : */
/* */
/*************************************************************************************************************************************/
#define Direct_xci \
GvarDefaut("xci" \
,EGAs(chain_Aconcaten5(HOME_DIRECTORY \
,cSEPARATEUR_DES_PATHS \
,"commandes" \
,cSEPARATEUR_DES_PATHS,"images" \
) \
) \
) \
/* Definition du directory '$xci'. Ceci a ete introduit le 20020228164122 afin de */ \
/* faciliter l'utilisation de 'EXECUTION_D_UNE_SUITE_DE_COMMANDES_SOUS_SH(...)' sur des */ \
/* MACHINEs qui n'ont pas (ou pas encore) d'environnement... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D I R E C T O R Y D E S C O M M A N D E S D E P R E - P R O C E S S I N G : */
/* */
/*************************************************************************************************************************************/
#define Direct_xcp \
GvarDefaut("xcp" \
,EGAs(chain_Aconcaten5(HOME_DIRECTORY \
,cSEPARATEUR_DES_PATHS \
,"commandes" \
,cSEPARATEUR_DES_PATHS \
,EGAs(chain_Aconcaten2("cpp",GvarDefaut("D",".D"))) \
) \
) \
) \
/* Definition du directory '$xcp'. Ceci a ete introduit le 20041221145839 afin de */ \
/* faciliter l'utilisation de 'EXECUTION_D_UNE_SUITE_DE_COMMANDES_SOUS_SH(...)'... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D I R E C T O R I E S T E M P O R A I R E S : */
/* */
/*************************************************************************************************************************************/
#define GvarDirectory(directory) \
GvarDefaut(directory \
,EGAs(chain_Aconcaten3(HOME_DIRECTORY \
,cSEPARATEUR_DES_PATHS \
,"TeMpOrAiReS" \
) \
) \
) \
/* Definition generale d'un directory. ATTENTION : en cas de non existence de celui-ci */ \
/* (en tant que variable d'environnement), il est emule dans '$xTG'. On notera que l'on */ \
/* n'utilise pas cette variable d'environnement ('$xTG') et ce au cas ou elle n'existerait */ \
/* pas (ou du moins pas encore...). Ceci a ete introduit le 20020228164122 afin de faciliter */ \
/* l'utilisation de 'EXECUTION_D_UNE_SUITE_DE_COMMANDES_SOUS_SH(...)' sur des MACHINEs qui */ \
/* n'ont pas (ou pas encore) d'environnement... */ \
/* */ \
/* La procedure 'GvarDirectory(...)' a ete introduite le 20160510170638... */
#define Direct__xBTG \
GvarDirectory("xBTG")
#define Direct__xBTG0 \
GvarDirectory("xBTG0")
#define Direct__xBTM \
GvarDirectory("xBTM")
#define Direct__xBTR \
GvarDirectory("xBTR")
#define Direct__xT \
Direct__xTGL \
/* Afin d'assurer la compatibilite anterieure au 20160510170638... */
#define Direct__xTC \
GvarDirectory("xTC")
#define Direct__xTF \
GvarDirectory("xTF")
#define Direct__xTFG \
GvarDirectory("xTFG")
#define Direct__xTFGL \
GvarDirectory("xTFGL")
#define Direct__xTG \
GvarDirectory("xTG")
#define Direct__xTG0 \
GvarDirectory("xTG0")
#define Direct__xTG0L \
GvarDirectory("xTG0L")
#define Direct__xTGL \
GvarDirectory("xTGL")
#define Direct__xTL \
GvarDirectory("xTL")
#define Direct__xTM \
GvarDirectory("xTM")
#define Direct__xTR \
GvarDirectory("xTR")
#define Direct__xTS \
GvarDirectory("xTS")
#define Direct__xTSG \
GvarDirectory("xTSG")
#define Direct__xTSGL \
GvarDirectory("xTSGL")
#define Direct__xTSUG \
GvarDirectory("xTSUG")
#define Direct__xTV \
GvarDirectory("xTV")
/* Cette liste a ete remaniee et completee le 20170418135135, puis le 20170515104124 en */
/* concerne '$xTSUG'... */
Denumer21(INIS(_nDirect__xTG,UN)
,_nDirect__xTGL
,_nDirect__xTG0
,_nDirect__xTG0L
,_nDirect__xTFG
,_nDirect__xTFGL
,_nDirect__xTSG
,_nDirect__xTSGL
,_nDirect__xTV
,_nDirect__xT
,_nDirect__xBTG
,_nDirect__xBTG0
,_nDirect__xBTM
,_nDirect__xBTR
,_nDirect__xTC
,_nDirect__xTF
,_nDirect__xTL
,_nDirect__xTM
,_nDirect__xTR
,_nDirect__xTS
,_nDirect__xTSUG
,choix_d_un_directory_temporaire
);
/* On notera que l'on utilise 'Denume20(...)' et non pas 'Denume20(...)' a cause du */
/* 'INIS(...)'. */
/* */
/* Le 20170418150813, dix nouveaux directories : */
/* */
/* {xBTG,xBTG0,xBTM,xBTR,xTC,xTF,xTL,xTM,xTR,xTS} */
/* */
/* et ce SANS CHANGER les numeros des dix premiers : */
/* */
/* {xTG,xTGL,xTG0,xTG0L,xTFG,xTFGL,xTSG,xTSGL,xTV,xT} */
/* */
/* car, en effet, on ne sait jamais... */
#define nDirect__xBTG \
_nDirect__xBTG
#define nDirect__xBTG0 \
_nDirect__xBTG0
#define nDirect__xBTM \
_nDirect__xBTM
#define nDirect__xBTR \
_nDirect__xBTR
#define nDirect__xTC \
_nDirect__xTC
#define nDirect__xTG \
_nDirect__xTG
#define nDirect__xTGL \
_nDirect__xTGL
#define nDirect__xTG0 \
_nDirect__xTG0
#define nDirect__xTG0L \
_nDirect__xTG0L
#define nDirect__xTF \
_nDirect__xTF
#define nDirect__xTFG \
_nDirect__xTFG
#define nDirect__xTFGL \
_nDirect__xTFGL
#define nDirect__xTL \
_nDirect__xTL
#define nDirect__xTM \
_nDirect__xTM
#define nDirect__xTR \
_nDirect__xTR
#define nDirect__xTS \
_nDirect__xTS
#define nDirect__xTSG \
_nDirect__xTSG
#define nDirect__xTSGL \
_nDirect__xTSGL
#define nDirect__xTSUG \
_nDirect__xTSUG
#define nDirect__xTV \
_nDirect__xTV
#define nDirect__xT \
_nDirect__xT
/* Numeros des directories temporaires accessibles (introduits le 20160511095737 et */
/* completes le 20170418150813 par 10 nouveaux directories). On a ainsi a priori : */
/* */
/* xTG = 1 N */
/* xTGL = 2 U */
/* xTG0 = 3 M */
/* xTG0L = 4 E */
/* xTFG = 5 R */
/* xTFGL = 6 O */
/* xTSG = 7 S */
/* xTSGL = 8 */
/* xTV = 9 INCHANGES */
/* xT = 10 (par rapport a avant le 20170418150813) */
/* */
/* xBTG = 11 */
/* xBTG0 = 12 */
/* xBTM = 13 */
/* xBTR = 14 */
/* xTC = 15 */
/* xTF = 16 */
/* xTL = 17 */
/* xTM = 18 */
/* xTR = 19 */
/* xTS = 20 */
/* xTSUG = 21 */
/* */
/* sachant que, suivant le contexte (MACHINE,...), certains peuvent etre identiques. C'est, */
/* par exemple, le cas de '$xTFG' et de '$xTSG' sur $CMAP28'. A la date du 20160512150135, */
/* on a respectivement sur '$LACT19' et sur '$CMAP8' : */
/* */
/* */
/* $LACT19 */
/* $CMAP8 */
/* */
/* */
/* 11 = xBTGA /home/colonna/TeMpOrAiReS */
/* /home2/users/colonna/TeMpOrAiReS */
/* */
/* 12 = xBTG0 /home/colonna/TeMpOrAiReS */
/* /home/colonna/TeMpOrAiReS */
/* */
/* 13 = xBTM /home/colonna/TeMpOrAiReS */
/* /home2/users/colonna/TeMpOrAiReS/$CMAP28$D */
/* */
/* 14 = xBTR /home/colonna/TeMpOrAiReS_ReMaNeNtS */
/* /home/colonna/TeMpOrAiReS_ReMaNeNtS */
/* */
/* */
/* 15 = xTC /home/colonna/TeMpOrAiReS_CoMmUn */
/* /home/colonna/TeMpOrAiReS_CoMmUn */
/* */
/* 01 = xTG /home/colonna/TeMpOrAiReS */
/* /home2/users/colonna/TeMpOrAiReS/$CMAP28$D I */
/* D */
/* 02 = xTGL /home/colonna/TeMpOrAiReS/$Cshell.nnnn$D - E */
/* - -------------- | N */
/* /home2/users/colonna/TeMpOrAiReS/$CMAP28$D/$Cshell.nnnn$D | T */
/* -------------- | I */
/* 10 = xT /home/colonna/TeMpOrAiReS/$Cshell.nnnn$D | Q */
/* /home2/users/colonna/TeMpOrAiReS/$CMAP28$D/$Cshell.nnnn$D - U */
/* E */
/* S */
/* 16 = xTF /tmp */
/* /tmp */
/* */
/* 05 = xTFG /mnt/tmpfs/colonna */
/* /tmp/colonna */
/* */
/* 06 = xTFGL /mnt/tmpfs/colonna/$Cshell.nnnn$D */
/* - -------------- */
/* /tmp/colonna/$Cshell.nnnn$D */
/* -------------- */
/* */
/* */
/* 03 = xTG0 /home/colonna/TeMpOrAiReS */
/* /home/colonna/TeMpOrAiReS/$CMAP28$D */
/* */
/* 04 = xTG0L /home/colonna/TeMpOrAiReS/$Cshell.nnnn$D */
/* - -------------- */
/* /home/colonna/TeMpOrAiReS/$CMAP28$D/$Cshell.nnnn$D */
/* -------------- */
/* */
/* */
/* 17 = xTL /home/colonna/TeMpOrAiReS/$Cshell.nnnn$D */
/* /home2/users/colonna/TeMpOrAiReS/$CMAP28$D/$Cshell.nnnn$D */
/* */
/* */
/* 18 = xTM /home/colonna/TeMpOrAiReS/$Cshell.nnnn$D */
/* /home2/users/colonna/TeMpOrAiReS/$CMAP28$D/$Cshell.nnnn$D */
/* */
/* */
/* 19 = xTR /home/colonna/TeMpOrAiReS_ReMaNeNtS */
/* /home/colonna/TeMpOrAiReS_ReMaNeNtS/$CMAP28$D */
/* */
/* */
/* 20 = xTS /tmp */
/* /tmp */
/* */
/* 07 = xTSG /tmp/colonna */
/* /tmp/colonna */
/* */
/* 08 = xTSGL /tmp/colonna/$Cshell.nnnn$D */
/* - -------------- */
/* /tmp/colonna/$Cshell.nnnn$D */
/* -------------- */
/* */
/* */
/* 09 = xTV VARIABLE... */
/* VARIABLE... */
/* */
/* */
/* ou 'nnnn' represente un numero compris entre '0001' et '9999' (ce dernier n'ayant */
/* evidemment jamais ete atteint...) et ou '$Cshell' est le 'PID' d'un '$CSH' avec */
/* suffisamment de "0"s devant... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D I R E C T O R Y D E S T O C K A G E D E S I M A G E S : */
/* */
/*************************************************************************************************************************************/
#define directory_images \
EGAs(chain_Aconcaten2(GvarDefaut("xp" \
,EGAs(chain_Aconcaten3(HOME_DIRECTORY,cSEPARATEUR_DES_PATHS,"images")) \
) \
,cSEPARATEUR_DES_PATHS \
) \
) \
/* Maintenant, la variable 'directory_images' est recuperee dynamiquement a partir de la */ \
/* variable d'environnement 'xp', ce qui fait qu'il n'est plus necessaire de recompiler de */ \
/* nombreux modules de bibliotheques et de nombreuses commandes en cas de changement dans */ \
/* les noms de directories. On notera que, malheureusement, l'espace allouee par l'appel */ \
/* de la fonction 'chain_Aconcaten3(...)' n'est jamais rendu... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D I R E C T O R Y D E S T O C K A G E D E S P A L E T T E S : */
/* */
/*************************************************************************************************************************************/
#define directory_palettes \
EGAs(chain_Aconcaten2(GvarDefaut("xiP" \
,EGAs(chain_Aconcaten2(directory_images,"palettes")) \
) \
,cSEPARATEUR_DES_PATHS \
) \
) \
/* La variable 'directory_palettes' recuperee dynamiquement a partir de la variable */ \
/* d'environnement 'xiP' a ete introduite le 20020512101004. On notera que, malheureusement, */ \
/* l'espace allouee par l'appel de la fonction 'chain_Aconcaten2(...)' n'est jamais rendu... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N D ' U N D I R E C T O R Y I N E X I S T A N T : */
/* */
/*************************************************************************************************************************************/
#define DIRECTORY_UNDEF \
"UNDEF
/* Est l'equivalent de 'UNDEF' pour les directories ; ATTENTION : la ligne precedente ne */
/* doit pas contenir de " \" et ce parce qu'elle contient un debut de chaine destinee */
/* a etre concatenee a d'autres... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D I R E C T O R Y D E S T O C K A G E D E S I M A G E S D E M A N O E U V R E : */
/* */
/*************************************************************************************************************************************/
#define directory_images_manoeuvre \
"images/manoeuvre
/* ATTENTION : la ligne precedente ne doit pas contenir de " \", et ce parce qu'elle */
/* contient un debut de chaine destinee a etre concatenee a d'autres... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* P O U R I N S E R E R D E S C O M M E N T A I R E S T R E S G E N E R A U X : */
/* */
/*************************************************************************************************************************************/
#define COMMENTAIRES_______(sequence_quelconque) \
/* Ceci a ete introduit le 20160411095715. Cela permet d'introduire des sequences */ \
/* quelconques dont un exemple est 'v $xtc/geodesiques.01$vv$c COMMENTAIRES_______'... */