/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        O P E R A T I O N S   A R I T H M E T I Q U E S   S U R   D E S   F I C H I E R S  :                                       */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*        Author of '$xrv/ARITHMET.21$I' :                                                                                           */
/*                                                                                                                                   */
/*                    Jean-Francois COLONNA (LACTAMME, 1997??????????).                                                              */
/*                                                                                                                                   */
/*************************************************************************************************************************************/

/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        V A L E U R S   I M P L I C I T E S   D E S   P A R A M E T R E S  :                                                       */
/*                                                                                                                                   */
/*************************************************************************************************************************************/
#include  xci/valeurs.01.I"
#include  xci/valeurs.02.I"

#TestADef FORMATER_LE_RESULTAT_DE_L_OPERATION_SUR_LES_VALEURS_COURANTES                                                                 \
                    FAUX                                                                                                                \
                                        /* Le '#define' a ete remplace par '#TestADef' le 20030929100259 afin de garantir un         */ \
                                        /* fonctionnement compatible de 'v $xrv/cumul.01$K 20030929093702' apres la modification     */ \
                                        /* qu'il a subit a ce moment-la...                                                           */
DEFV(Local,DEFV(Logical,INIT(formater_le_resultat_de_l_operation_sur_les_valeurs_courantes
                            ,FORMATER_LE_RESULTAT_DE_L_OPERATION_SUR_LES_VALEURS_COURANTES
                             )
                )
     );
                                        /* Faut-il utiliser le mode anterieur au 20000117104932 ('FAUX') ou bien utiliser un mode    */
                                        /* similaire a ce que l'on trouve dans '$xci/valeurs_????$K' ('VRAI').                       */

#define   EDITER_LA_VALEUR_RESULTANTE_DANS_gOPERATION_SUR_LES_FICHIERS                                                                  \
                    VRAI
#define   NE_PAS_EDITER_LA_VALEUR_RESULTANTE_DANS_gOPERATION_SUR_LES_FICHIERS                                                           \
                    NOTL(EDITER_LA_VALEUR_RESULTANTE_DANS_gOPERATION_SUR_LES_FICHIERS)
                                        /* Pour rendre conditionnelle l'edition dans 'gOPERATION_SUR_LES_FICHIERS(...)'...           */

#define   PAS_DE_PARCOURS_D_UN_FICHIER                                                                                                  \
                    I
DEFV(Local,DEFV(Int,INIT(pas_de_parcours_d_un_fichier,PAS_DE_PARCOURS_D_UN_FICHIER)));
DEFV(Local,DEFV(Int,INIT(premier_element_d_un_fichier,PREMIER_ELEMENT_D_UN_FICHIER)));
                                        /* Introduits le 20160727144522 afin de permettre leur modification "dynamique"...           */

#define   NOMBRE_D_EXEMPLAIRES_DU_RESULTAT_DE_L_OPERATION_SUR_LES_VALEURS_COURANTES                                                     \
                    UN
DEFV(Local,DEFV(Positive,INIT(nombre_d_exemplaires_du_resultat_de_l_operation_sur_les_valeurs_courantes
                             ,NOMBRE_D_EXEMPLAIRES_DU_RESULTAT_DE_L_OPERATION_SUR_LES_VALEURS_COURANTES
                              )
                )
     );
                                        /* Nombre de fois que chaque resultat sera edite (une seule fois implicitement...).          */

#define   CUMULER_LES_VALEURS_RESULTANTES                                                                                               \
                    FAUX
DEFV(Local,DEFV(Logical,INIT(cumuler_les_valeurs_resultantes,CUMULER_LES_VALEURS_RESULTANTES)));

#define   MOYENNER_LE_CUMUL_DES_VALEURS_RESULTANTES                                                                                     \
                    FAUX
DEFV(Local,DEFV(Logical,INIT(moyenner_le_cumul_des_valeurs_resultantes,MOYENNER_LE_CUMUL_DES_VALEURS_RESULTANTES)));
                                        /* Le 20211003102324 a ete introduite la possibilite d'editer non plus la valeur courante,   */
                                        /* mais son cumul avec les valeurs courantes qui l'ont precedee, eventuellement              */
                                        /* "renormalise" avec le nombre de valeurs courantes deja rencontrees...                     */

/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        G E S T I O N   D E S   F I C H I E R S  :                                                                                 */
/*                                                                                                                                   */
/*************************************************************************************************************************************/
#define   DERNIER_ELEMENT_D_UN_FICHIER                                                                                                  \
                    LSTX(PREMIER_ELEMENT_D_UN_FICHIER,nombre_d_elements)                                                                \
                                        /* Introduit le 20200819115545 (bien tardivement...) pour simplifier...                      */
#define   gDERNIER_ELEMENT_D_UN_FICHIER(liste_des_valeurs)                                                                              \
                    LSTX(PREMIER_ELEMENT_D_UN_FICHIER,liste_des_valeurs`____nombre_d_elements)                                          \
                                        /* Introduit le 20240930170717 suite a 'v $xrv/ARITHMET.1g$I 20240930155301'...              */

#define   gEDITION_DANS_gOPERATION_SUR_LES_FICHIERS(operation_sur_les_valeurs_courantes,CalImpression,Impression1,Impression2)          \
                    Bblock                                                                                                              \
                    Test(IL_FAUT(formater_le_resultat_de_l_operation_sur_les_valeurs_courantes))                                        \
                         Bblock                                                                                                         \
                         CalImpression(Impression2(Cara(chain_Aconcaten4(C_POUR_CENT,valeurs_signees,".*",format_d_edition))            \
                                                  ,NOMBRE_DE_DECIMALES_EFFECTIF(nombre_de_decimales)                                    \
                                                  ,MULTIPLE_DE(ENTIER_FLOTTANT(operation_sur_les_valeurs_courantes))                    \
                                                   )                                                                                    \
                                       );                                                                                               \
                                        /* Edition de la valeur courante.                                                            */ \
                         Eblock                                                                                                         \
                    ATes                                                                                                                \
                         Bblock                                                                                                         \
                         CalImpression(Impression1(COND(IL_FAUT(utiliser_le_format_exponentiel),"%+.^^^","%+.^^^")                      \
                                                  ,operation_sur_les_valeurs_courantes                                                  \
                                                   )                                                                                    \
                                       );                                                                                               \
                                        /* Edition de la valeur courante.                                                            */ \
                                        /*                                                                                           */ \
                                        /* Le 20060105160311, le format "16g" est passe a "^^g" pour plus de souplesse, de meme      */ \
                                        /* que le format "17f" est passe a "^^f"...                                                  */ \
                                        /*                                                                                           */ \
                                        /* Le 20091123123502, le format "^^g" est passe a "^^^" pour plus de souplesse...            */ \
                         Eblock                                                                                                         \
                    ETes                                                                                                                \
                    Eblock                                                                                                              \
                                        /* Edition formatee ou non du resultat de l'operation sur 'valeurs_courantes' avec choix     */ \
                                        /* {CAL1,Prer1,Prer2}, {CAL2,Prin1,Prin2} ou {CAL3,Prme1,Prme2} des fonctions d'impression.  */ \
                                        /* Ceci fut introduit pour 'v $xrv/optimise.02$K gEDITION_DANS_gOPERATION_SUR_LES_FICHIERS'  */ \
                                        /* le 20080305103001...                                                                      */
#define   EDITION_DANS_gOPERATION_SUR_LES_FICHIERS(operation_sur_les_valeurs_courantes)                                                 \
                    Bblock                                                                                                              \
                    gEDITION_DANS_gOPERATION_SUR_LES_FICHIERS(operation_sur_les_valeurs_courantes,CAL2,Prin1,Prin2);                    \
                    Eblock                                                                                                              \
                                        /* Edition formatee ou non du resultat de l'operation sur 'valeurs_courantes'...             */
#define   EDITION_DANS_gOPERATION_SUR_LES_FICHIERS_AVEC_SAUT_DE_LIGNE(valeur)                                                           \
                    Bblock                                                                                                              \
                    EDITION_DANS_gOPERATION_SUR_LES_FICHIERS(valeur);                                                                   \
                    CAL2(Prin0("\n"));                                                                                                  \
                    Eblock                                                                                                              \
                                        /* Procedure d'edition avec saut de ligne introduite le 20160804092928 car, en effet,        */ \
                                        /* a cette date le code correspondant etait utilise dans cinq '$K's...                       */

#define   gOPERATION_SUR_LES_FICHIERS(valeurs_courantes,operation_sur_les_valeurs_courantes,editer_la_valeur_resultante,exemplaires)    \
                    Bblock                                                                                                              \
                    DEFV(Logical,INIT(introduire_un_K_NL,FAUX));                                                                        \
                                        /* Afin de ne pas introduire un saut de ligne devant la premiere ligne. Cet indicateur a     */ \
                                        /* deplace de '$xrv/ARITHMET.22.I' a '$xrv/ARITHMET.21$I' le 20011008144608.                 */ \
                    DEFV(Logical,INIT(une_valeur_courante_au_moins_a_ete_editee,FAUX));                                                 \
                                        /* Cet indicateur a ete ajoute le 19990813092149 car, en effet, l'indicateur argument        */ \
                                        /* 'editer_la_valeur_resultante' peut contenir des tests sur les donnees definies dans       */ \
                                        /* l'argument 'valeurs_courantes' et ne peut donc etre utilise en dehors du bloc dans        */ \
                                        /* lequel il est utilise (c'est-a-dire a l'interieur du 'DoIn(...)').                        */ \
                                                                                                                                        \
                    DEFV(Float,INIT(cumul_des_valeurs_resultantes,FZERO));                                                              \
                    DEFV(Positive,INIT(compteur_des_valeurs_resultantes,ZERO));                                                         \
                                        /* Le 20211003102324 a ete introduite la possibilite d'editer non plus la valeur courante,   */ \
                                        /* mais son cumul avec les valeurs courantes qui l'ont precedee, eventuellement              */ \
                                        /* "renormalise" avec le nombre de valeurs courantes deja rencontrees...                     */ \
                                                                                                                                        \
                    DoIn(index                                                                                                          \
                        ,premier_element_d_un_fichier                                                                                   \
                        ,DERNIER_ELEMENT_D_UN_FICHIER                                                                                   \
                        ,pas_de_parcours_d_un_fichier                                                                                   \
                         )                                                                                                              \
                                        /* ATTENTION : bien noter la difference ci-dessus entre 'premier_element_d_un_fichier'       */ \
                                        /* et 'PREMIER_ELEMENT_D_UN_FICHIER', ce dernier permettant le "vrai" premier element        */ \
                                        /* du vecteur correspondant et non pas le premier "utile"...                                 */ \
                         Bblock                                                                                                         \
                         BLOC(valeurs_courantes;);                                                                                      \
                                        /* Recuperation de la valeur courante dans les fichiers.                                     */ \
                                                                                                                                        \
                         begin_nouveau_block                                                                                            \
                              Bblock                                                                                                    \
                              DEFV(Float,INIT(valeur_resultante,operation_sur_les_valeurs_courantes));                                  \
                              INCR(cumul_des_valeurs_resultantes,valeur_resultante);                                                    \
                              INCR(compteur_des_valeurs_resultantes,I);                                                                 \
                                        /* Le cumul introduit le 20211003102324 est fait meme s'il est inutile...                    */ \
                                                                                                                                        \
                              Repe(exemplaires)                                                                                         \
                                   Bblock                                                                                               \
                                   Test(IL_FAUT(editer_la_valeur_resultante))                                                           \
                                        Bblock                                                                                          \
                                        Test(IL_FAUT(introduire_un_K_NL))                                                               \
                                             Bblock                                                                                     \
                                             CAL2(Prin0("\n"));                                                                         \
                                        /* Pas de saut de ligne devant la premiere ligne, mais uniquement sur les lignes suivantes.  */ \
                                             Eblock                                                                                     \
                                        ATes                                                                                            \
                                             Bblock                                                                                     \
                                             EGAL(introduire_un_K_NL,VRAI);                                                             \
                                             Eblock                                                                                     \
                                        ETes                                                                                            \
                                                                                                                                        \
                                        EDITION_DANS_gOPERATION_SUR_LES_FICHIERS                                                        \
                                            (COND(IL_NE_FAUT_PAS(cumuler_les_valeurs_resultantes)                                       \
                                                 ,valeur_resultante                                                                     \
                                                 ,COND(IL_NE_FAUT_PAS(moyenner_le_cumul_des_valeurs_resultantes)                        \
                                                      ,NEUT(cumul_des_valeurs_resultantes)                                              \
                                                      ,DIVI(cumul_des_valeurs_resultantes                                               \
                                                           ,FLOT(compteur_des_valeurs_resultantes)                                      \
                                                            )                                                                           \
                                                       )                                                                                \
                                                  )                                                                                     \
                                             );                                                                                         \
                                                                                                                                        \
                                        EGAL(une_valeur_courante_au_moins_a_ete_editee,VRAI);                                           \
                                        Eblock                                                                                          \
                                   ATes                                                                                                 \
                                        Bblock                                                                                          \
                                        Eblock                                                                                          \
                                   ETes                                                                                                 \
                                   Eblock                                                                                               \
                              ERep                                                                                                      \
                              Eblock                                                                                                    \
                         end_nouveau_block                                                                                              \
                         Eblock                                                                                                         \
                    EDoI                                                                                                                \
                                                                                                                                        \
                    Test(EST_VRAI(une_valeur_courante_au_moins_a_ete_editee))                                                           \
                                        /* ATTENTION, ce test a ete ajoute le 19990526085437 car il manquait, semble-t-il. Puis, il  */ \
                                        /* a ete encore modifie le 19990813092149 ne pouvant utiliser 'editer_la_valeur_resultante'  */ \
                                        /* en toute generalite (voir le commentaire de 'une_valeur_courante_au_moins_a_ete_editee'). */ \
                         Bblock                                                                                                         \
                         CAL2(Prin0("\n"));                                                                                             \
                                        /* "Fermeture" du fichier resultat (c'est-a-dire la sortie standard...).                     */ \
                         Eblock                                                                                                         \
                    ATes                                                                                                                \
                         Bblock                                                                                                         \
                         Eblock                                                                                                         \
                    ETes                                                                                                                \
                    Eblock                                                                                                              \
                                        /* Operations quelconques sur les elements des fichiers...                                   */



Copyright © Jean-François COLONNA, 2019-2024.
Copyright © CMAP (Centre de Mathématiques APpliquées) UMR CNRS 7641 / École polytechnique, Institut Polytechnique de Paris, 2019-2024.