/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        C A L C U L   " E T E N D U "   D E   ' AX+B '  :                                                                          */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*        Author of '$xcg/AXPBx.01$K' :                                                                                              */
/*                                                                                                                                   */
/*                    Jean-Francois COLONNA (LACTAMME, 20180818095211).                                                              */
/*                                                                                                                                   */
/*************************************************************************************************************************************/

/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        I N T E R F A C E   ' listG '  :                                                                                           */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*        :Debut_listG:                                                                                                              */
/*        :Fin_listG:                                                                                                                */
/*                                                                                                                                   */
/*************************************************************************************************************************************/

/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        D I R E C T I V E S   S P E C I F I Q U E S   D E   C O M P I L A T I O N  :                                               */
/*                                                                                                                                   */
/*************************************************************************************************************************************/
#define   PRAGMA_CPP_____AUTORISER_LE_GooF
#define   GENERER_LES_GET_ARGUMENTS_DE_CONTROLE_DE_L_ARITHMETIQUE_ETENDUE_DES_NOMBRES_FLOTTANTS

/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        F I C H I E R S   D ' I N C L U D E S  :                                                                                   */
/*                                                                                                                                   */
/*************************************************************************************************************************************/
#include  INCLUDES_MINI

/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        P A R A M E T R E S  :                                                                                                     */
/*                                                                                                                                   */
/*************************************************************************************************************************************/
#define   UTILISER_LE_GooF                                                                                                              \
                    VRAI                                                                                                                \
                                        /* Faut-il utiliser le 'GooF' ? Le 20181109105028, la valeur par defaut est passee de 'FAUX' */ \
                                        /* a 'VRAI' (ce qui ne change pas le comportement par defaut (tant que les ponderations des  */ \
                                        /* differentes fonctions type 'FfxADD2(...)' ne sont pas modifiees...                        */

#define   NOMBRE_A                                                                                                                      \
                    FU
#define   NOMBRE_X                                                                                                                      \
                    FU
#define   NOMBRE_B                                                                                                                      \
                    FZERO
                                        /* Les trois nombres flottants pour lesquels on va calculer 'ax+b'.                          */

#include  xcg/ARIT.01.I"
#include  xci/valeurs.01.I"

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

/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        C A L C U L   " E T E N D U "   D E   ' AX+B '  :                                                                          */
/*                                                                                                                                   */
/*************************************************************************************************************************************/
BCommande(nombre_d_arguments,arguments)
/*-----------------------------------------------------------------------------------------------------------------------------------*/
     Bblock
     DEFV(Logical,INIT(utiliser_le_GooF,UTILISER_LE_GooF));
                                        /* Faut-il utiliser le 'GooF' ? Le 20181109105028, la valeur par defaut est passee de 'FAUX' */
                                        /* a 'VRAI' (ce qui ne change pas le comportement par defaut (tant que les ponderations des  */
                                        /* differentes fonctions type 'FfxADD2(...)' ne sont pas modifiees...                        */

     DEFV(Float,INIT(nombre_A,NOMBRE_A));
     DEFV(Float,INIT(nombre_X,NOMBRE_X));
     DEFV(Float,INIT(nombre_B,NOMBRE_B));
                                        /* Les trois nombres flottants pour lesquels on va calculer 'ax+b'.                          */

#include  xci/valeurs.03.I"
     /*..............................................................................................................................*/
     GET_ARGUMENTS_(nombre_d_arguments
                   ,BLOC(GET_ARGUMENT_F("nombre_A=""a=""A=",nombre_A);
                         GET_ARGUMENT_F("x=""nombre_X=""X=",nombre_X);
                         GET_ARGUMENT_F("nombre_B=""b=""B=",nombre_B);

                         GET_ARGUMENT_L("GooF=",utiliser_le_GooF);
                                        /* ATTENTION, je note le 20180818103114 que :                                                */
                                        /*                                                                                           */
                                        /*                  GooF=VRAI                                                                */
                                        /*                                                                                           */
                                        /* n'a d'interet que si l'on utilise de plus :                                               */
                                        /*                                                                                           */
                                        /*                  arithmetique_etendue=VRAI                                                */
                                        /*                                                                                           */

                         PROCESS_ARGUMENTS_DE_PARAMETRAGE_DE_LA_GENERATION_DE_SUITE_DE_VALEURS_1;
                         PROCESS_ARGUMENTS_DE_PARAMETRAGE_DE_LA_GENERATION_DE_SUITE_DE_VALEURS_2;
                                        /* Ces deux procedures furent introduites le 20061226182255...                               */
                         )
                    );

     begin_nouveau_block
          Bblock
          DEFV(Float,INIT(valeur_courante,FLOT__UNDEF));

          USs_GooF______CONDITIONNEL(utiliser_le_GooF
                                    ,BLOC(
                                          Bblock
                                          EGAL(valeur_courante,AXPB(nombre_A,nombre_X,nombre_B));
                                        /* Calcul des elements attendus de la suite (avec 'GooF' par defaut...) suivant :            */
                                        /*                                                                                           */
                                        /*                  A.X + B                                                                  */
                                        /*                                                                                           */
                                        /* par defaut...                                                                             */
                                        /*                                                                                           */
                                        /* On notera le 20181008150627 une arithmetique originale "MAX-MIN" ou l'addition est        */
                                        /* remplacee par le maximum et la multiplication par le minimum. Il suffit de faire :        */
                                        /*                                                                                           */
                                        /*                  arithmetique_etendue=VRAI                                                */
                                        /*                  GooF=VRAI                                                                */
                                        /*                  pxADD2_ADD2=0 pxMAX2_ADD2=1                                              */
                                        /*                  pxMUL2_MUL2=0 pxMIN2_MUL2=1                                              */
                                        /*                                                                                           */
                                        /* On notera le 20181109105028 que l'on ne procede pas ici comme, par exemple, dans          */
                                        /* 'v $xcg/ADD2x.01$K FfxADD2' car, en effet, il n'existe pas de fonction 'FfxAXPB(...)'     */
                                        /* comme il existe 'FfxADD2(...)'...                                                         */
                                          Eblock
                                          )
                                     );

          EDITION_DE_LA_VALEUR_DE_L_OPERATEUR(valeur_courante);
                                        /* Edition de la valeur...                                                                   */
          Eblock
     end_nouveau_block

     RETU_Commande;
     Eblock
ECommande