/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        V I S U A L I S A T I O N   D E   L A   C O N J E C T U R E   D E   G O L D B A C H  :                                     */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*        Author of '$xrk/Goldbach.01$K' :                                                                                           */
/*                                                                                                                                   */
/*                    Jean-Francois COLONNA (LACTAMME, 20130110095412).                                                              */
/*                                                                                                                                   */
/*************************************************************************************************************************************/

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

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

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

/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        P A R A M E T R E S  :                                                                                                     */
/*                                                                                                                                   */
/*************************************************************************************************************************************/
#define   VISUALISER_LES_NOMBRES_PAIRS_HORIZONTALEMENT                                                                                  \
                    VRAI                                                                                                                \
                                        /* Faut-il visualiser les nombres pairs horizontalement ('VRAI') ou verticalement ('FAUX') ? */ \
                                        /* Ce parametre a ete introduit le 20130112085356...                                         */
#define   MONTRER_LES_COUPLES_DE_NOMBRES_PREMIERS                                                                                       \
                    VRAI                                                                                                                \
                                        /* Faut-il visualiser les couples de nombres premiers ('VRAI') ou bien les couples de        */ \
                                        /* leurs index ('FAUX') ?                                                                    */

#define   EDITER_LE_PREMIER_ET_LE_DERNIER_NOMBRES_PAIRS                                                                                 \
                    FAUX                                                                                                                \
                                        /* Faut-il editer les premier et dernier nombres pairs ('VRAI') ou pas ('FAUX') ? Ceci a     */ \
                                        /* ete introduit le 20131127095700...                                                        */

#define   VISUALISER_UNIQUEMENT_LE_NOMBRE_DE_DECOMPOSITIONS                                                                             \
                    FAUX
#define   VISUALISER_LE_NOMBRE_DE_DECOMPOSITIONS_COMME_UN_HISTOGRAMME                                                                   \
                    FAUX
#define   NIVEAU_DE_MARQUAGE_DU_NOMBRE_DE_DECOMPOSITIONS_1                                                                              \
                    BLANC
#define   NIVEAU_DE_MARQUAGE_DU_NOMBRE_DE_DECOMPOSITIONS_2                                                                              \
                    NIVEAU_DE_MARQUAGE_DU_NOMBRE_DE_DECOMPOSITIONS_1
                                        /* Faut-il visualiser uniquement le nombre de decompositions ('VRAI') ou bien les            */
                                        /* decompositions elles-memes ('FAUX') ? Ce parametre a ete introduit le 20131104134727      */
                                        /* et complete le 20131105074956...                                                          */

#define   FACTEUR_D_ECHELLE_DES_NOMBRES_PREMIERS                                                                                        \
                    UN
#define   FACTEUR_D_ECHELLE_DES_INDEX                                                                                                   \
                    UN
#define   FACTEUR_D_ECHELLE_DU_NOMBRE_DE_DECOMPOSITIONS                                                                                 \
                    UN
                                        /* Introduit le 20131126163733 afin de mieux occuper l'espace...                             */

/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        M A C R O S   U T I L E S  :                                                                                               */
/*                                                                                                                                   */
/*************************************************************************************************************************************/
#define   PREMIER_NOMBRE_PREMIER                                                                                                        \
                    SUCC(VERITABLE_PREMIER_NOMBRE_PREMIER)                                                                              \
                                        /* Premier nombre premier a traiter en excluant donc 2 ((introduit ici le 20130112101944).   */
#define   NOMBRE_DE_NOMBRES_PREMIERS                                                                                                    \
                    ADD2(MUL2(BASE_DE_PARITE,COYR(Ymax)),PREMIER_NOMBRE_PAIR_A_TESTER)                                                  \
                                        /* Nombre maximal de nombres premiers que l'on va calculer, mais en fait leur nombre est     */ \
                                        /* plus petit que cela car, en effet, la valeur ci-dessus donne plutot le plus grand         */ \
                                        /* nombre pair que l'on va decomposer...                                                     */
#define   PREMIER_NOMBRE_PAIR_A_TESTER                                                                                                  \
                    SIX                                                                                                                 \
                                        /* Je note le 20130111115112 que l'on ne peut pas commencer a 'QUATRE' car, en effet, sa     */ \
                                        /* decomposition est :                                                                       */ \
                                        /*                                                                                           */ \
                                        /*                  4 = 2 + 2                                                                */ \
                                        /*                                                                                           */ \
                                        /* or '2' est le seul nombre premier pair et dans les 'store_point_valide(...)' qui vont     */ \
                                        /* suivre les nombres premiers sont divises par 'BASE_DE_PARITE' afin de definir la          */ \
                                        /* coordonnee 'X'. Alors les deux premiers nombres premiers {2,3} entrent en collision       */ \
                                        /* donnant X=1 tous les deux. La solution est donc de commencer a 6...                       */

#include  xci/valeurs_Goldbach.01.I"
#include  xci/valeurs_Goldbach.02.I"

#define   facteur_echelle_nombres_premiers                                                                                              \
                    facteur_d_echelle_des_nombres_premiers
#define   montrer_couples_nombres_premiers                                                                                              \
                    montrer_les_couples_de_nombres_premiers
                                        /* Afin de raccourcir des lignes a venir...                                                  */

#define   GENERATION_D_UNE_LIGNE_OU_D_UNE_COLONNE(COXYR,selection_X_ou_Y,COXYA,X1,Y1,X2,Y2,est_premier_element,est_dernier_element)     \
                    Bblock                                                                                                              \
                    DEFV(genere_p,INIT(niveau_de_marquage_courant,NOIR_PLANCHER));                                                      \
                                                                                                                                        \
                    DEFV(Int,INIT(nombre_de_decompositions,ZERO));                                                                      \
                                        /* Le nombre de decompositions a ete introduit le 20131104134727...                          */ \
                                                                                                                                        \
                    EGAL(nombre_entier_courant                                                                                          \
                        ,ADD2(MUL2(BASE_DE_PARITE                                                                                       \
                                  ,COXYR(selection_X_ou_Y(SE12(X1,X2),SE12(Y1,Y2)))                                                     \
                                   )                                                                                                    \
                             ,PREMIER_NOMBRE_PAIR_A_TESTER                                                                              \
                              )                                                                                                         \
                         );                                                                                                             \
                                        /* On notera que grace au 'MUL2(BASE_DE_PARITE,...)' seuls les nombres pairs sont testes     */ \
                                        /* (ce qui est heureux puisque c'est le sujet de la Conjecture de Goldbach...).              */ \
                                                                                                                                        \
                    Test(EST_IMPAIR(nombre_entier_courant))                                                                             \
                                        /* Test introduit le 20130112133805...                                                       */ \
                         Bblock                                                                                                         \
                         PRINT_ERREUR("le premier nombre pair a tester est en fait impair");                                            \
                         Eblock                                                                                                         \
                    ATes                                                                                                                \
                         Bblock                                                                                                         \
                         Eblock                                                                                                         \
                    ETes                                                                                                                \
                                                                                                                                        \
                    Test(EST_VRAI(est_premier_element))                                                                                 \
                                        /* Test introduit le 20131127170806...                                                       */ \
                         Bblock                                                                                                         \
                         Test(IL_FAUT(editer_le_premier_et_le_dernier_nombres_pairs))                                                   \
                                        /* Test introduit le 20131127095700...                                                       */ \
                              Bblock                                                                                                    \
                              CAL3(Prme1("PremierNombrePair=%d\n",nombre_entier_courant));                                              \
                              Eblock                                                                                                    \
                         ATes                                                                                                           \
                              Bblock                                                                                                    \
                              Eblock                                                                                                    \
                         ETes                                                                                                           \
                         Eblock                                                                                                         \
                    ATes                                                                                                                \
                         Bblock                                                                                                         \
                         Eblock                                                                                                         \
                    ETes                                                                                                                \
                                                                                                                                        \
                    VERIFICATION_DE_LA_CONJECTURE_DE_GOLDBACH(BLOC(Bblock                                                               \
                                                                   DEFV(Int,INIT(coordonnee_1                                           \
                                                                                ,COXYA(COND(IL_FAUT(montrer_couples_nombres_premiers)   \
                                                                                           ,MUL2(facteur_echelle_nombres_premiers       \
                                                                                                ,DIVI(SOUS(nombre_premier_1             \
                                                                                                          ,PREMIER_NOMBRE_PREMIER       \
                                                                                                           )                            \
                                                                                                     ,BASE_DE_PARITE                    \
                                                                                                      )                                 \
                                                                                                 )                                      \
                                                                                           ,MUL2(facteur_d_echelle_des_index            \
                                                                                                ,SOUS(index1                            \
                                                                                                     ,INDEX_DU_PREMIER_NOMBRE_PREMIER   \
                                                                                                      )                                 \
                                                                                                 )                                      \
                                                                                            )                                           \
                                                                                       )                                                \
                                                                                 )                                                      \
                                                                        );                                                              \
                                                                   DEFV(Int,INIT(coordonnee_2                                           \
                                                                                ,COXYA(COND(IL_FAUT(montrer_couples_nombres_premiers)   \
                                                                                           ,MUL2(facteur_echelle_nombres_premiers       \
                                                                                                ,DIVI(SOUS(nombre_premier_2             \
                                                                                                          ,PREMIER_NOMBRE_PREMIER       \
                                                                                                           )                            \
                                                                                                     ,BASE_DE_PARITE                    \
                                                                                                      )                                 \
                                                                                                 )                                      \
                                                                                           ,MUL2(facteur_d_echelle_des_index            \
                                                                                                ,SOUS(index2                            \
                                                                                                     ,INDEX_DU_PREMIER_NOMBRE_PREMIER   \
                                                                                                      )                                 \
                                                                                                 )                                      \
                                                                                            )                                           \
                                                                                       )                                                \
                                                                                 )                                                      \
                                                                        );                                                              \
                                        /* Definition des deux coordonnees de rangement...                                           */ \
                                        /*                                                                                           */ \
                                        /* On notera le 'DIVI(...,BASE_DE_PARITE)' destine a "economiser" un point sur deux l'axe    */ \
                                        /* 'OX' puisque l'on marque des nombres premiers qui sont donc necessairement impairs.       */ \
                                        /* Ainsi avec 'DIVI(...,BASE_DE_PARITE)' on ignore les nombres pairs...                      */ \
                                                                                                                                        \
                                                                   INCR(nombre_de_decompositions,I);                                    \
                                        /* Le nombre de decompositions a ete introduit le 20131104134727...                          */ \
                                                                                                                                        \
                                                                   Test(IL_FAUT(visualiser_uniquement_le_nombre_de_decompositions))     \
                                                                        Bblock                                                          \
                                                                        Eblock                                                          \
                                                                   ATes                                                                 \
                                                                        Bblock                                                          \
                                                                        Test(IFOU(EST_PAIR(nombre_premier_1)                            \
                                                                                 ,EST_PAIR(nombre_premier_2)                            \
                                                                                  )                                                     \
                                                                             )                                                          \
                                        /* Ce test a ete introduit le 20130111141955 suite a 'v $xrk/Goldbach.01$K 20130111115112'.  */ \
                                                                             Bblock                                                     \
                                                                             PRINT_ERREUR("un des nombres premiers au moins est pair"); \
                                                                             CAL1(Prer1("NombrePremier1=%d\n",nombre_premier_1));       \
                                                                             CAL1(Prer1("NombrePremier2=%d\n",nombre_premier_2));       \
                                        /* On notera que l'on ne pourrait trouver ici que le nombre 2 (sauf grosse erreur...).       */ \
                                                                             Eblock                                                     \
                                                                        ATes                                                            \
                                                                             Bblock                                                     \
                                                                             Eblock                                                     \
                                                                        ETes                                                            \
                                                                                                                                        \
                                                                        store_point_valide(niveau_de_marquage_courant                   \
                                                                                          ,ImageR                                       \
                                                                                          ,X1,Y1                                        \
                                                                                          ,FVARIABLE                                    \
                                                                                           );                                           \
                                                                        store_point_valide(niveau_de_marquage_courant                   \
                                                                                          ,ImageR                                       \
                                                                                          ,X2,Y2                                        \
                                                                                          ,FVARIABLE                                    \
                                                                                           );                                           \
                                        /* Marquage des deux nombres premiers dont la somme est egale au nombre entier courant...    */ \
                                                                                                                                        \
                                                                        INCR(niveau_de_marquage_courant,PAS_COULEURS);                  \
                                        /* Ainsi, le niveau de marquage evolue pour chaque nouveau couple de nombres premiers...     */ \
                                                                                                                                        \
                                                                        Test(IFEXff(niveau_de_marquage_courant,NOIR_PLANCHER,BLANC))    \
                                                                             Bblock                                                     \
                                                                             EGAL(niveau_de_marquage_courant,NOIR_PLANCHER);            \
                                                                             Eblock                                                     \
                                                                        ATes                                                            \
                                                                             Bblock                                                     \
                                                                             Eblock                                                     \
                                                                        ETes                                                            \
                                                                        Eblock                                                          \
                                                                   ETes                                                                 \
                                                                   Eblock                                                               \
                                                                   )                                                                    \
                                                              );                                                                        \
                                                                                                                                        \
                    Test(EST_VRAI(est_dernier_element))                                                                                 \
                                        /* Test introduit le 20131127170806...                                                       */ \
                         Bblock                                                                                                         \
                         Test(IL_FAUT(editer_le_premier_et_le_dernier_nombres_pairs))                                                   \
                                        /* Test introduit le 20131127095700...                                                       */ \
                              Bblock                                                                                                    \
                              CAL3(Prme1("DernierNombrePair=%d\n",nombre_entier_courant));                                              \
                              Eblock                                                                                                    \
                         ATes                                                                                                           \
                              Bblock                                                                                                    \
                              Eblock                                                                                                    \
                         ETes                                                                                                           \
                         Eblock                                                                                                         \
                    ATes                                                                                                                \
                         Bblock                                                                                                         \
                         Eblock                                                                                                         \
                    ETes                                                                                                                \
                                                                                                                                        \
                    Test(IL_FAUT(visualiser_uniquement_le_nombre_de_decompositions))                                                    \
                         Bblock                                                                                                         \
                         Test(IL_FAUT(visualiser_le_nombre_de_decompositions_comme_un_histogramme))                                     \
                                        /* Test introduit le 20131105074956...                                                       */ \
                              Bblock                                                                                                    \
                              Test(IL_FAUT(visualiser_les_nombres_pairs_horizontalement))                                               \
                                   Bblock                                                                                               \
                                   begin_colonneQ(DoIn                                                                                  \
                                                 ,Ymin                                                                                  \
                                                 ,MIN2(COYA(MUL2(facteur_d_echelle_du_nombre_de_decompositions                          \
                                                                ,nombre_de_decompositions                                               \
                                                                 )                                                                      \
                                                            )                                                                           \
                                                      ,Ymax                                                                             \
                                                       )                                                                                \
                                                 ,pasY                                                                                  \
                                                  )                                                                                     \
                                        Bblock                                                                                          \
                                        store_point_valide(COND(IFEQ(Y,Ymax_begin_colonneQ)                                             \
                                                               ,niveau_de_marquage_du_nombre_de_decompositions_2                        \
                                                               ,niveau_de_marquage_du_nombre_de_decompositions_1                        \
                                                                )                                                                       \
                                                          ,ImageR                                                                       \
                                                          ,selection_X_ou_Y(SE12(X1,X2),SE12(Y1,Y2))                                    \
                                                          ,Y                                                                            \
                                                          ,FVARIABLE                                                                    \
                                                           );                                                                           \
                                        /* Trace d'une barre verticale dont la longueur est le nombre de decompositions seuillee     */ \
                                        /* par 'Xmax'.                                                                               */ \
                                        Eblock                                                                                          \
                                   end_colonneQ(EDoI)                                                                                   \
                                   Eblock                                                                                               \
                              ATes                                                                                                      \
                                   Bblock                                                                                               \
                                   begin_ligneQ(DoIn                                                                                    \
                                               ,Xmin                                                                                    \
                                               ,MIN2(COXA(MUL2(facteur_d_echelle_du_nombre_de_decompositions                            \
                                                              ,nombre_de_decompositions                                                 \
                                                               )                                                                        \
                                                          )                                                                             \
                                                    ,Xmax                                                                               \
                                                     )                                                                                  \
                                               ,pasX                                                                                    \
                                                )                                                                                       \
                                        Bblock                                                                                          \
                                        store_point_valide(COND(IFEQ(X,Xmax_begin_ligneQ)                                               \
                                                               ,niveau_de_marquage_du_nombre_de_decompositions_2                        \
                                                               ,niveau_de_marquage_du_nombre_de_decompositions_1                        \
                                                                )                                                                       \
                                                          ,ImageR                                                                       \
                                                          ,X                                                                            \
                                                          ,selection_X_ou_Y(SE12(X1,X2),SE12(Y1,Y2))                                    \
                                                          ,FVARIABLE                                                                    \
                                                           );                                                                           \
                                        /* Trace d'une barre horizontale dont la longueur est le nombre de decompositions seuillee   */ \
                                        /* par 'Ymax'.                                                                               */ \
                                        Eblock                                                                                          \
                                   end_ligneQ(EDoI)                                                                                     \
                                   Eblock                                                                                               \
                              ETes                                                                                                      \
                              Eblock                                                                                                    \
                         ATes                                                                                                           \
                              Bblock                                                                                                    \
                              store_point_valide(niveau_de_marquage_du_nombre_de_decompositions_2                                       \
                                                ,ImageR                                                                                 \
                                                ,COND(IL_FAUT(visualiser_les_nombres_pairs_horizontalement)                             \
                                                     ,selection_X_ou_Y(SE12(X1,X2),SE12(Y1,Y2))                                         \
                                                     ,MUL2(facteur_d_echelle_du_nombre_de_decompositions,nombre_de_decompositions)      \
                                                      )                                                                                 \
                                                ,COND(IL_FAUT(visualiser_les_nombres_pairs_horizontalement)                             \
                                                     ,MUL2(facteur_d_echelle_du_nombre_de_decompositions,nombre_de_decompositions)      \
                                                     ,selection_X_ou_Y(SE12(X1,X2),SE12(Y1,Y2))                                         \
                                                      )                                                                                 \
                                                ,FVARIABLE                                                                              \
                                                 );                                                                                     \
                                        /* On notera que le nombre de decompositions peut etre plus grand que la dimension maximale  */ \
                                        /* de l'axe correspondant...                                                                 */ \
                              Eblock                                                                                                    \
                         ETes                                                                                                           \
                         Eblock                                                                                                         \
                    ATes                                                                                                                \
                         Bblock                                                                                                         \
                         Eblock                                                                                                         \
                    ETes                                                                                                                \
                    Eblock                                                                                                              \
                                        /* Procedure introduite le 20130112083824 afin de pouvoir generer aussi bien une disposition */ \
                                        /* en lignes qu'en colonnes...                                                               */

/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        V I S U A L I S A T I O N   D E   L A   C O N J E C T U R E   D E   G O L D B A C H  :                                     */
/*                                                                                                                                   */
/*************************************************************************************************************************************/
BCommande(nombre_d_arguments,arguments)
/*-----------------------------------------------------------------------------------------------------------------------------------*/
     Bblock
     DEFV(CHAR,INIC(POINTERc(nom_imageR),NOM_PIPE));

     DEFV(Logical,INIT(visualiser_les_nombres_pairs_horizontalement,VISUALISER_LES_NOMBRES_PAIRS_HORIZONTALEMENT));
                                        /* Faut-il visualiser les nombres pairs horizontalement ('VRAI') ou verticalement ('FAUX') ? */
                                        /* Ce parametre a ete introduit le 20130112085356...                                         */
     DEFV(Logical,INIT(montrer_les_couples_de_nombres_premiers,MONTRER_LES_COUPLES_DE_NOMBRES_PREMIERS));
                                        /* Faut-il visualiser les couples de nombres premiers ('VRAI') ou bien les couples de        */
                                        /* leurs index ('FAUX') ?                                                                    */
     DEFV(Logical,INIT(visualiser_uniquement_le_nombre_de_decompositions,VISUALISER_UNIQUEMENT_LE_NOMBRE_DE_DECOMPOSITIONS));
     DEFV(Logical,INIT(visualiser_le_nombre_de_decompositions_comme_un_histogramme
                      ,VISUALISER_LE_NOMBRE_DE_DECOMPOSITIONS_COMME_UN_HISTOGRAMME
                       )
          );
     DEFV(genere_p,INIT(niveau_de_marquage_du_nombre_de_decompositions_1,NIVEAU_DE_MARQUAGE_DU_NOMBRE_DE_DECOMPOSITIONS_1));
     DEFV(genere_p,INIT(niveau_de_marquage_du_nombre_de_decompositions_2,NIVEAU_DE_MARQUAGE_DU_NOMBRE_DE_DECOMPOSITIONS_2));
                                        /* Faut-il visualiser uniquement le nombre de decompositions ('VRAI') ou bien les            */
                                        /* decompositions elles-memes ('FAUX') ? Ce parametre a ete introduit le 20131104134727      */
                                        /* et complete le 20131105074956... Le 20131121105424, ce niveau a ete "dedouble" afin       */
                                        /* de pouvoir differencier la partie "histogramme" et son maximum...                         */

     DEFV(Logical,INIT(editer_le_premier_et_le_dernier_nombres_pairs,EDITER_LE_PREMIER_ET_LE_DERNIER_NOMBRES_PAIRS));
                                        /* Faut-il editer les premier et dernier nombres pairs ('VRAI') ou pas ('FAUX') ? Ceci a     */
                                        /* ete introduit le 20131127095700...                                                        */

     DEFV(Int,INIT(facteur_d_echelle_des_nombres_premiers,FACTEUR_D_ECHELLE_DES_NOMBRES_PREMIERS));
     DEFV(Int,INIT(facteur_d_echelle_des_index,FACTEUR_D_ECHELLE_DES_INDEX));
     DEFV(Int,INIT(facteur_d_echelle_du_nombre_de_decompositions,FACTEUR_D_ECHELLE_DU_NOMBRE_DE_DECOMPOSITIONS));
                                        /* Introduit le 20131126163733 afin de mieux occuper l'espace...                             */

     DEFV(Int,INIT(valeur_a_ne_pas_depasser_pour_les_nombres_premiers,PETIT_INFINI));
                                        /* Valeur a ne pas depasser pour les nombres premiers (introduite le 20221021172432) car     */
                                        /* etant referencee dans 'v $xci/valeurs_Goldbach.02$I valeur_a_ne_pas_depasser', mais ici   */
                                        /* elle n'est pas modifiable...                                                              */

     DEFV(Logical,INIT(ignorer_les_couples_commutes_dus_a_la_commutativite_de_l_addition,VRAI));
                                        /* Contrairement a 'v $xci/valeurs_Goldbach$K ignorer_les_couples_commutes_dus_a_la_com...'  */
                                        /* (qui a inspire ce probleme), il faut evidemment ici ignorer le couple {P2,P1} de nombes   */
                                        /* premiers lorsque le couple {P1,P2} (avec P1<P2) a deja ete marque (ces deux marquages     */
                                        /* sont en fait identiques au niveau de l'image generee...).                                 */
     /*..............................................................................................................................*/
     GET_ARGUMENTSi(nombre_d_arguments
                   ,BLOC(GET_ARGUMENT_C("imageR=""R=",nom_imageR);

                         GET_ARGUMENT_L("horizontalement=""horizontal=""hor=""h=",visualiser_les_nombres_pairs_horizontalement);
                         GET_ARGUMENT_N("verticalement=""vertical=""ver=""v=",visualiser_les_nombres_pairs_horizontalement);
                         GET_ARGUMENT_L("nombre_decompositions=""nc=",visualiser_uniquement_le_nombre_de_decompositions);
                         GET_ARGUMENT_N("decompositions=""d=",visualiser_uniquement_le_nombre_de_decompositions);
                         GET_ARGUMENT_L("decompositions_histogramme=""dh="
                                       ,visualiser_le_nombre_de_decompositions_comme_un_histogramme
                                        );
                         GET_ARGUMENT_P("niveau_marquage_decompositions_1=""ncm1=",niveau_de_marquage_du_nombre_de_decompositions_1);
                         GET_ARGUMENT_P("niveau_marquage_decompositions_2=""ncm2=",niveau_de_marquage_du_nombre_de_decompositions_2);
                                        /* Arguments introduits le 20131104134727 et completes le 20131105074956...                  */

                         GET_ARGUMENT_L("editer_premier_dernier=""epd=",editer_le_premier_et_le_dernier_nombres_pairs);
                                        /* Arguments introduits le 20131127095700...                                                 */

                         GET_ARGUMENT_L("nombres_premiers=""np=",montrer_les_couples_de_nombres_premiers);
                         GET_ARGUMENT_N("index=""in=",montrer_les_couples_de_nombres_premiers);

                         GET_ARGUMENT_I("echelle_nombres_premiers=""echelle_np=""enp=",facteur_d_echelle_des_nombres_premiers);
                         GET_ARGUMENT_I("echelle_index=""echelle_i=""ei=",facteur_d_echelle_des_index);
                         GET_ARGUMENT_I("echelle_decompositions=""echelle_d=""ed=",facteur_d_echelle_du_nombre_de_decompositions);
                         )
                    );

     CALi(Inoir(ImageR));

     DEBUT_DE_LA_GENERATION_DE_LA_LISTE_DES_NOMBRES_PREMIERS;

     Test(IL_FAUT(visualiser_les_nombres_pairs_horizontalement))
                                        /* Test introduit le 20130112085356...                                                       */
          Bblock
          begin_ligne
               Bblock
               GENERATION_D_UNE_LIGNE_OU_D_UNE_COLONNE(COXR,SE12
                                                      ,COYA
                                                      ,X,coordonnee_1
                                                      ,X,coordonnee_2
                                                      ,IFEQ(X,Xmin)
                                                      ,IFEQ(X,Xmax)
                                                       );
               Eblock
          end_ligne
          Eblock
     ATes
          Bblock
          begin_colonne
               Bblock
               GENERATION_D_UNE_LIGNE_OU_D_UNE_COLONNE(COYR,SE22
                                                      ,COXA
                                                      ,coordonnee_1,Y
                                                      ,coordonnee_2,Y
                                                      ,IFEQ(Y,Ymin)
                                                      ,IFEQ(Y,Ymax)
                                                       );
               Eblock
          end_colonne
          Eblock
     ETes

     FIN_DE_LA_GENERATION_DE_LA_LISTE_DES_NOMBRES_PREMIERS;

     CALi(Iupdate_image(nom_imageR,ImageR));

     RETU_Commande;
     Eblock
ECommande



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