/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        E T U D E   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 '$xci/valeurs_Goldbach.02$I' :                                                                                   */
/*                                                                                                                                   */
/*                    Jean-Francois COLONNA (LACTAMME, 20130110101422).                                                              */
/*                                                                                                                                   */
/*************************************************************************************************************************************/

/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        M A C R O S   U T I L E S  :                                                                                               */
/*                                                                                                                                   */
/*************************************************************************************************************************************/
#define   NOMBRE_PREMIER(index)                                                                                                         \
                    IdTb1(liste_des_nombres_premiers,index,NOMBRE_DE_NOMBRES_PREMIERS)                                                  \
                                        /* Introduit le 20131208085138 pour alleger ce qui suit...                                   */

#define   RANGEMENT_D_UN_NOMBRE_PREMIER(nombre_premier)                                                                                 \
                    Bblock                                                                                                              \
                    EGAL(NOMBRE_PREMIER(index_courant_des_nombres_premiers)                                                             \
                        ,nombre_premier                                                                                                 \
                         );                                                                                                             \
                    INCR(index_courant_des_nombres_premiers,I);                                                                         \
                    Eblock                                                                                                              \
                                        /* Rangement d'un nombre premier...                                                          */

#define   DEBUT_DE_LA_GENERATION_DE_LA_LISTE_DES_NOMBRES_PREMIERS                                                                       \
                    Bblock                                                                                                              \
                    DEFV(Int,INIT(index_courant_des_nombres_premiers,INDEX_DU_PREMIER_NOMBRE_PREMIER));                                 \
                    DEFV(Local,DEFV(Int                                                                                                 \
                                   ,DdTb1(POINTERi,liste_des_nombres_premiers,NOMBRE_DE_NOMBRES_PREMIERS,ADRESSE_NON_ENCORE_DEFINIE)    \
                                    )                                                                                                   \
                         );                                                                                                             \
                    MdTb1(liste_des_nombres_premiers,NOMBRE_DE_NOMBRES_PREMIERS,Int,ADRESSE_NON_ENCORE_DEFINIE);                        \
                                        /* Definition de la liste des nombres premiers...                                            */ \
                    DEFV(Int,INIT(nombre_entier_courant,UNDEF));                                                                        \
                                                                                                                                        \
                    Test(EST_PAIR(PREMIER_NOMBRE_PREMIER))                                                                              \
                                        /* Test introduit le 20130112102242 pour 'v $xrk/Goldbach.01$K PREMIER_NOMBRE_PREMIER'...    */ \
                         Bblock                                                                                                         \
                         RANGEMENT_D_UN_NOMBRE_PREMIER(PREMIER_NOMBRE_PREMIER);                                                         \
                                        /* Le premier nombre premier est 2...                                                        */ \
                                                                                                                                        \
                         EGAL(nombre_entier_courant,SUCC(PREMIER_NOMBRE_PREMIER));                                                      \
                                        /* Le premier nombre a tester ensuite est donc 3...                                          */ \
                         Eblock                                                                                                         \
                    ATes                                                                                                                \
                         Bblock                                                                                                         \
                         EGAL(nombre_entier_courant,PREMIER_NOMBRE_PREMIER);                                                            \
                                        /* Le premier nombre a tester ensuite est donc 3...                                          */ \
                         Eblock                                                                                                         \
                    ETes                                                                                                                \
                                                                                                                                        \
                    Tant(IFLE(index_courant_des_nombres_premiers,INDEX_DU_DERNIER_NOMBRE_PREMIER))                                      \
                         Bblock                                                                                                         \
                         DEFV(Int,INIT(index,UNDEF));                                                                                   \
                         DEFV(Logical,INIT(le_nombre_entier_courant_est_premier,VRAI));                                                 \
                                        /* Le nombre courant est a priori premier...                                                 */ \
                                                                                                                                        \
                         DoIn(index,INDEX_DU_PREMIER_NOMBRE_PREMIER,PRED(index_courant_des_nombres_premiers),I)                         \
                              Bblock                                                                                                    \
                              Test(DIVISIBLE(nombre_entier_courant                                                                      \
                                            ,NOMBRE_PREMIER(index)                                                                      \
                                             )                                                                                          \
                                   )                                                                                                    \
                                        /* On teste ainsi la divisibilite par les nombres premiers deja memorises.                   */ \
                                   Bblock                                                                                               \
                                   EGAL(le_nombre_entier_courant_est_premier,FAUX);                                                     \
                                        /* Et non, le nombre courant n'est pas premier...                                            */ \
                                   Eblock                                                                                               \
                              ATes                                                                                                      \
                                   Bblock                                                                                               \
                                   Eblock                                                                                               \
                              ETes                                                                                                      \
                              Eblock                                                                                                    \
                         EDoI                                                                                                           \
                                                                                                                                        \
                         Test(EST_VRAI(le_nombre_entier_courant_est_premier))                                                           \
                              Bblock                                                                                                    \
                              RANGEMENT_D_UN_NOMBRE_PREMIER(nombre_entier_courant);                                                     \
                                        /* Cas ou le nombre courant est premier...                                                   */ \
                              Eblock                                                                                                    \
                         ATes                                                                                                           \
                              Bblock                                                                                                    \
                              Eblock                                                                                                    \
                         ETes                                                                                                           \
                                                                                                                                        \
                         INCR(nombre_entier_courant,PAS_DE_PROGRESSION_DES_ENTIERS);                                                    \
                                        /* Ainsi on ne teste que les nombres impairs...                                              */ \
                                                                                                                                        \
                         Test(EST_PAIR(nombre_entier_courant))                                                                          \
                              Bblock                                                                                                    \
                              PRINT_ERREUR("les nombres entiers dont est testee la primalite sont pairs");                              \
                              Eblock                                                                                                    \
                         ATes                                                                                                           \
                              Bblock                                                                                                    \
                              Eblock                                                                                                    \
                         ETes                                                                                                           \
                         Eblock                                                                                                         \
                    ETan                                                                                                                \
                                                                                                                                        \
                    DECR(index_courant_des_nombres_premiers,I);                                                                         \
                                        /* A priori ne sert a rien, mais permet de faire que 'index_courant_des_nombres_premiers'    */ \
                                        /* soit egal a 'INDEX_DU_DERNIER_NOMBRE_PREMIER'...                                          */ \
                    DECR(nombre_entier_courant,PAS_DE_PROGRESSION_DES_ENTIERS);                                                         \
                                        /* Retour sur le dernier nombre entier traite. Ceci a ete introduit le 20131127170008        */ \
                                        /* pour 'v $xrk/Goldbach.01$K DernierNombrePair=.d.n..nombre_entier_courant'...              */

#define   VERIFICATION_DE_LA_CONJECTURE_DE_GOLDBACH(sequence_si_verifiee)                                                               \
                    Bblock                                                                                                              \
                    DEFV(Int,INIT(nombre_premier_1,UNDEF));                                                                             \
                    DEFV(Int,INIT(index1,UNDEF));                                                                                       \
                                                                                                                                        \
                    EGAL(index1,INDEX_DU_PREMIER_NOMBRE_PREMIER);                                                                       \
                                                                                                                                        \
                    Test(IFLT(nombre_entier_courant                                                                                     \
                             ,NOMBRE_PREMIER(INDEX_DU_DERNIER_NOMBRE_PREMIER)                                                           \
                              )                                                                                                         \
                         )                                                                                                              \
                         Bblock                                                                                                         \
                         Tant(I3ET(IFLT(EGAL(nombre_premier_1,NOMBRE_PREMIER(index1))                                                   \
                                       ,nombre_entier_courant                                                                           \
                                        )                                                                                               \
                                  ,IFLE(index1,INDEX_DU_DERNIER_NOMBRE_PREMIER)                                                         \
                                  ,IFLE(nombre_premier_1,valeur_a_ne_pas_depasser_pour_les_nombres_premiers)                            \
                                   )                                                                                                    \
                              )                                                                                                         \
                                        /* Optimisation ('DoIn(...)' remplace par 'Tant(...)') introduite le 20131208080258...       */ \
                                        /*                                                                                           */ \
                                        /* Le 20221021173451 fut introduit le test de la valeur maximale a ne pas depasser pour      */ \
                                        /* nombres premiers...                                                                       */ \
                              Bblock                                                                                                    \
                              DEFV(Int,INIT(nombre_premier_2,UNDEF));                                                                   \
                              DEFV(Int,INIT(index2,UNDEF));                                                                             \
                                                                                                                                        \
                              EGAL(index2                                                                                               \
                                  ,COND(IL_FAUT(ignorer_les_couples_commutes_dus_a_la_commutativite_de_l_addition)                      \
                                       ,index1                                                                                          \
                                       ,INDEX_DU_PREMIER_NOMBRE_PREMIER                                                                 \
                                        )                                                                                               \
                                   );                                                                                                   \
                                                                                                                                        \
                              Tant(I3ET(IFLT(EGAL(nombre_premier_2,NOMBRE_PREMIER(index2))                                              \
                                            ,nombre_entier_courant                                                                      \
                                             )                                                                                          \
                                       ,IFLE(index2,INDEX_DU_DERNIER_NOMBRE_PREMIER)                                                    \
                                       ,IFLE(nombre_premier_2,valeur_a_ne_pas_depasser_pour_les_nombres_premiers)                       \
                                        )                                                                                               \
                                   )                                                                                                    \
                                        /* Optimisation ('DoIn(...)' remplace par 'Tant(...)') introduite le 20131208080258...       */ \
                                        /*                                                                                           */ \
                                        /* On notera le 20131208082307 que ce calcul est passe de 269 a 114 secondes (sur            */ \
                                        /* '$LACT19') pour le calcul de 'v $xiirv/GOLD.A2'...                                        */ \
                                        /*                                                                                           */ \
                                        /* Le 20221021173451 fut introduit le test de la valeur maximale a ne pas depasser pour      */ \
                                        /* nombres premiers...                                                                       */ \
                                   Bblock                                                                                               \
                                   Test(IFEQ(nombre_entier_courant,ADD2(nombre_premier_1,nombre_premier_2)))                            \
                                        /* Edition des nombres entiers pairs superieurs ou egaux a 4 satisfaisant a la conjecture    */ \
                                        /* de Goldbach :                                                                             */ \
                                        Bblock                                                                                          \
                                        BLOC(sequence_si_verifiee);                                                                     \
                                        Eblock                                                                                          \
                                   ATes                                                                                                 \
                                        Bblock                                                                                          \
                                        Eblock                                                                                          \
                                   ETes                                                                                                 \
                                                                                                                                        \
                                   INCR(index2,I);                                                                                      \
                                   Eblock                                                                                               \
                              ETan                                                                                                      \
                                                                                                                                        \
                              INCR(index1,I);                                                                                           \
                              Eblock                                                                                                    \
                         ETan                                                                                                           \
                         Eblock                                                                                                         \
                    ATes                                                                                                                \
                         Bblock                                                                                                         \
                         PRINT_ERREUR("la liste de nombres premiers n'est pas assez longue");                                           \
                         CAL1(Prer2("(le plus grand nombre premier est %d, alors que le nombre entier courant vaut %d)\n"               \
                                   ,NOMBRE_PREMIER(INDEX_DU_DERNIER_NOMBRE_PREMIER)                                                     \
                                   ,nombre_entier_courant                                                                               \
                                    )                                                                                                   \
                              );                                                                                                        \
                         Eblock                                                                                                         \
                    ETes                                                                                                                \
                    Eblock

#define   FIN_DE_LA_GENERATION_DE_LA_LISTE_DES_NOMBRES_PREMIERS                                                                         \
                    FdTb1(liste_des_nombres_premiers,NOMBRE_DE_NOMBRES_PREMIERS,Int,ADRESSE_NON_ENCORE_DEFINIE);                        \
                                        /* Definition de la liste des nombres premiers...                                            */ \
                    Eblock



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.