/*************************************************************************************************************************************/
/* */
/* 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 : */
/* */
/* */
/* Definition : */
/* */
/* Cette commande (inspiree du programme */
/* 'v $xtc/Goldbach.01$c') teste la conjecture */
/* de Goldbach et edite un certain nombre de */
/* valeurs utiles. */
/* */
/* */
/* Nota : */
/* */
/* Je rappelle le 20250214174042 que pour */
/* simplement lister les nombres premiers, */
/* il suffira d'utiliser : */
/* */
/* $xci/valeurs_Goldbach$X premiere=1 derniere=N \ */
/* editer_nombres_premiers=VRAI \ */
/* calculer_decompositions=FAUX */
/* */
/* ou 'N' designe le nombre de nombres */
/* premiers que l'on souhaite calculer... */
/* */
/* */
/* Author of '$xci/valeurs_Goldbach$K' : */
/* */
/* Jean-Francois COLONNA (LACTAMME, 20121013082435). */
/* */
/*************************************************************************************************************************************/
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* 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
/* Introduit le 20121011101232... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* 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 : */
/* */
/*************************************************************************************************************************************/
#include xci/sequence.01.I"
#define CALCULER_LES_DECOMPOSITIONS_DES_NOMBRES_PAIRS \
VRAI \
/* Pour verifier la conjecture de Goldbach ('VRAI') ou bien uniquement eventuellement ne */ \
/* faire qu'editer les nombres premiers si 'IL_FAUT(editer_la_liste_des_nombres_premiers)' */ \
/* ('FAUX'). Ceci a ete introduit le 20131201102246... */
#define PREMIER_NOMBRE_PAIR_A_TESTER \
QUATRE \
/* Premier nombre pair a tester correspondant a la Conjecture de Goldbach... */
#define DERNIER_NOMBRE_PAIR_A_TESTER \
ZERO \
/* Dernier nombre pair a tester correspondant a la Conjecture de Goldbach (introduit */ \
/* le 20131208173156). La valeur par defaut permet de forcer une valeur egale au dernier */ \
/* nombre premier calcule... */
#define VALEUR_A_NE_PAS_DEPASSER_POUR_LES_NOMBRES_PREMIERS \
PETIT_INFINI \
/* Valeur a ne pas depasser pour nombres premiers (introduite le 20221021172426 pour */ \
/* generer 'v $xiirv/GOLD.F2'...). */
#define DISTANCE_ENTRE_DEUX_NOMBRES_PREMIERS_JUMEAUX \
DEUX \
/* Distance entre deux nombres premiers jumeaux (introduite le 20150324160607). */
#define EDITER_LA_LISTE_DES_NOMBRES_PREMIERS \
FAUX
#define TABULATION_DES_NOMBRES_PREMIERS \
ZERO
#define MARQUER_LE_DEUXIEME_NOMBRE_PREMIER_D_UN_COUPLE_DE_NOMBRES_PREMIERS_JUMEAUX \
FAUX
#define EDITER_TOUTES_LES_DECOMPOSITIONS \
VRAI
#define PLUTOT_QU_EDITER_LES_NOMBRES_PREMIERS_EDITER_LEUR_RANG \
FAUX
#define EDITER_LE_PRODUIT_DE_DEUX_NOMBRES_PREMIERS \
FAUX
#define EDITER_SEQUENTIELLEMENT_LES_DECOMPOSITIONS \
VRAI
#define IGNORER_LES_COUPLES_COMMUTES_DUS_A_LA_COMMUTATIVITE_DE_L_ADDITION \
VRAI
#define REMPLACER_LES_NOMBRES_PREMIERS_PAR_LEUR_INDEX \
FAUX
/* Controle des differentes editions. La tabulation des nombres premiers a ete introduite le */
/* 20170309101222, la valeur par defaut ('ZERO') garantissant la compatibilite anterieure. */
/* L'edition du produit des deux nombres premiers a ete introduite le 20200930142246. */
#define BORNE_INFERIEURE_DES_NOMBRES_PREMIERS \
ZERO
#define BORNE_SUPERIEURE_DES_NOMBRES_PREMIERS \
INFINI
/* Introduit le 20250214174042 afin de tester la conjecture de Legendre pour laquelle on */
/* utilisera : */
/* */
/* 2 */
/* BorneInferieure = N */
/* */
/* 2 */
/* BorneSuperieure = (N+1) */
/* */
/* 'N' designant un entier quelconque... */
#include xci/valeurs.01.I"
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* M A C R O S U T I L E S : */
/* */
/*************************************************************************************************************************************/
#include xci/valeurs.02.I"
#define DERNIER_NOMBRE_PAIR_POSSIBLE \
PAR0(NOMBRE_PREMIER(INDEX_DU_DERNIER_NOMBRE_PREMIER)) \
/* Dernier nombre pair a tester possible en focntion du dernier nombre premier calcule... */
#define PREMIER_NOMBRE_PREMIER \
VERITABLE_PREMIER_NOMBRE_PREMIER \
/* Premier nombre premier, qui est pair (introduit ici le 20130112101922) ! */
#define NOMBRE_DE_NOMBRES_PREMIERS \
NBRE(premiere_image,derniere_image) \
/* Nombre de nombres premiers... */
#include xci/valeurs_Goldbach.01.I"
#include xci/valeurs_Goldbach.02.I"
/* Introduits le 20130110101548... */
#define NOMBRE_PREMIER_1 \
COND(IL_FAUT(remplacer_les_nombres_premiers_par_leur_index),index1,nombre_premier_1)
#define NOMBRE_PREMIER_2 \
COND(IL_FAUT(remplacer_les_nombres_premiers_par_leur_index),index2,nombre_premier_2)
/* Le remplacement possible des nombres premiers par leur index lors des editions a ete */
/* introduit le 20221021134729... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* 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 : */
/* */
/*************************************************************************************************************************************/
BCommande(nombre_d_arguments,arguments)
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
DEFV(Int,INIT(premiere_image,PREMIERE_IMAGE));
/* Numero de la premiere image, */
DEFV(Int,INIT(derniere_image,DERNIERE_IMAGE));
/* Numero de la derniere image. */
DEFV(Logical,INIT(calculer_les_decompositions_des_nombres_pairs,CALCULER_LES_DECOMPOSITIONS_DES_NOMBRES_PAIRS));
/* Pour verifier la conjecture de Goldbach ('VRAI') ou bien uniquement eventuellement ne */
/* faire qu'editer les nombres premiers si 'IL_FAUT(editer_la_liste_des_nombres_premiers)' */
/* ('FAUX'). Ceci a ete introduit le 20131201102246... */
DEFV(Int,INIT(premier_nombre_pair_a_tester,PREMIER_NOMBRE_PAIR_A_TESTER));
/* Premier nombre pair a tester correspondant a la Conjecture de Goldbach (introduit */
/* sous cette forme en 'Int' et non plus seulement en '#define' le 20131203124313)... */
DEFV(Int,INIT(dernier_nombre_pair_a_tester,DERNIER_NOMBRE_PAIR_A_TESTER));
/* Dernier nombre pair a tester correspondant a la Conjecture de Goldbach (introduit */
/* le 20131208173156). La valeur par defaut permet de forcer une valeur egale au dernier */
/* nombre premier calcule... */
DEFV(Int,INIT(valeur_a_ne_pas_depasser_pour_les_nombres_premiers,VALEUR_A_NE_PAS_DEPASSER_POUR_LES_NOMBRES_PREMIERS));
/* Valeur a ne pas depasser pour nombres premiers (introduite le 20221021172426 pour */
/* generer 'v $xiirv/GOLD.F2'...). */
DEFV(Int,INIT(index_du_premier_nombre_premier,INDEX_DU_PREMIER_NOMBRE_PREMIER));
/* Index du premier nombre premier introduit le 20161019102237 afin de pouvoir eliminer 2 */
/* qui est le seul nombre premier pair et qui s'il est ajoute a d'autres nombres premiers */
/* (sauf lui-meme...) donne alors des nombres impairs (ce qui est ennuyeux si l'on travaille */
/* sur la conjecture de Goldbach... */
DEFV(Int,INIT(distance_entre_deux_nombres_premiers_jumeaux,DISTANCE_ENTRE_DEUX_NOMBRES_PREMIERS_JUMEAUX));
/* Distance entre deux nombres premiers jumeaux (introduite le 20150324160607). */
DEFV(Logical,INIT(editer_la_liste_des_nombres_premiers,EDITER_LA_LISTE_DES_NOMBRES_PREMIERS));
DEFV(Int,INIT(tabulation_des_nombres_premiers,TABULATION_DES_NOMBRES_PREMIERS));
DEFV(Logical,INIT(marquer_le_deuxieme_nombre_premier_d_un_couple_de_nombres_premiers_jumeaux
,MARQUER_LE_DEUXIEME_NOMBRE_PREMIER_D_UN_COUPLE_DE_NOMBRES_PREMIERS_JUMEAUX
)
);
DEFV(Logical,INIT(editer_toutes_les_decompositions,EDITER_TOUTES_LES_DECOMPOSITIONS));
DEFV(Logical,INIT(plutot_qu_editer_les_nombres_premiers_editer_leur_rang,PLUTOT_QU_EDITER_LES_NOMBRES_PREMIERS_EDITER_LEUR_RANG));
DEFV(Logical,INIT(editer_le_produit_de_deux_nombres_premiers,EDITER_LE_PRODUIT_DE_DEUX_NOMBRES_PREMIERS));
DEFV(Logical,INIT(editer_sequentiellement_les_decompositions,EDITER_SEQUENTIELLEMENT_LES_DECOMPOSITIONS));
DEFV(Logical,INIT(ignorer_les_couples_commutes_dus_a_la_commutativite_de_l_addition
,IGNORER_LES_COUPLES_COMMUTES_DUS_A_LA_COMMUTATIVITE_DE_L_ADDITION
)
);
DEFV(Logical,INIT(remplacer_les_nombres_premiers_par_leur_index,REMPLACER_LES_NOMBRES_PREMIERS_PAR_LEUR_INDEX));
/* Controle des differentes editions... */
/* */
/* Le 20121112092704 'prendre_en_compte_la_commutativite_de_l_addition' a ete change en */
/* 'ignorer_les_couples_commutes_dus_a_la_commutativite_de_l_addition' plus explicite... */
/* */
/* Le 20131204110949 'editer_toutes_les_decompositions' a ete introduit... */
/* */
/* La tabulation des nombres premiers a ete introduite le 20170309101222, la valeur par */
/* defaut ('ZERO') garantissant la compatibilite anterieure. */
/* */
/* L'edition du produit des deux nombres premiers a ete introduite le 20200930142246. */
/* */
/* L'edition de l'index des nombres premiers (plutot que les nombres premiers exu-memes) */
/* a ete introduite le 20221021134729... */
DEFV(Int,INIT(borne_inferieure_des_nombres_premiers,BORNE_INFERIEURE_DES_NOMBRES_PREMIERS));
DEFV(Int,INIT(borne_superieure_des_nombres_premiers,BORNE_SUPERIEURE_DES_NOMBRES_PREMIERS));
/* Introduit le 20250214174042 afin de tester la conjecture de Legendre pour laquelle on */
/* utilisera : */
/* */
/* 2 */
/* BorneInferieure = N */
/* */
/* 2 */
/* BorneSuperieure = (N+1) */
/* */
/* 'N' designant un entier quelconque... */
#include xci/valeurs.03.I"
/*..............................................................................................................................*/
GET_ARGUMENTS_(nombre_d_arguments
,BLOC(GET_ARGUMENT_I("premiere=""p=""D=",premiere_image);
GET_ARGUMENT_I("derniere=""d=""A=",derniere_image);
/* On rappelle le 20131203123243 que : */
/* */
/* derniere-premiere+1 */
/* */
/* donne le nombre de nombres premiers que l'on va calculer et exploiter. Si l'on souhaite */
/* "optimiser" cette valeur, on peut s'inspirer de 'v $xiirv/.GOLD.81.1.$U 20131203153623'. */
GET_ARGUMENT_L("calculer_decompositions=""cd=",calculer_les_decompositions_des_nombres_pairs);
/* Arguments introduits le 20131201102246... */
GET_ARGUMENT_I("premier_nombre_pair=""pnp=",premier_nombre_pair_a_tester);
/* Arguments introduits le 20131203124313... */
GET_ARGUMENT_I("dernier_nombre_pair=""dnp=",dernier_nombre_pair_a_tester);
/* Arguments introduits le 20131208173156... */
GET_ARGUMENT_I("valeur_maximale_nombres_premiers=""vmnp="
,valeur_a_ne_pas_depasser_pour_les_nombres_premiers
);
/* Arguments introduits le 20221021172426... */
GET_ARGUMENT_I("index_premier_nombre_premier=""ipnp=",index_du_premier_nombre_premier);
/* Arguments introduits le 20161019102237... */
GET_ARGUMENT_I("distance_jumeaux=""dj=",distance_entre_deux_nombres_premiers_jumeaux);
/* Arguments introduits le 20150324160607... */
GET_ARGUMENT_L("editer_nombres_premiers=""enp=",editer_la_liste_des_nombres_premiers);
GET_ARGUMENT_I("tabulation_nombres_premiers=""tnp=",tabulation_des_nombres_premiers);
GET_ARGUMENT_L("marquer_nombres_premiers_jumeaux=""mnpj="
,marquer_le_deuxieme_nombre_premier_d_un_couple_de_nombres_premiers_jumeaux
);
/* Arguments introduits le 20150324160607... */
GET_ARGUMENT_L("editer_decompositions=""ed=",editer_toutes_les_decompositions);
/* Argument introduit le 20131204110949... */
GET_ARGUMENT_L("rang=""rg=",plutot_qu_editer_les_nombres_premiers_editer_leur_rang);
/* Argument introduit le 20130111082637... */
GET_ARGUMENT_L("produit=""pr=",editer_le_produit_de_deux_nombres_premiers);
/* Argument introduit le 20200930142246... */
GET_ARGUMENT_L("edition_sequentielle=""es=",editer_sequentiellement_les_decompositions);
GET_ARGUMENT_N("edition_parallele=""ep=",editer_sequentiellement_les_decompositions);
/* Je rappelle le 20240101104722 que si l'on veut editer le nombre de decompositions il */
/* faut utiliser : */
/* */
/* edition_parallele=VRAI */
/* */
/* Le nombre apparait alors en bout de ligne apres un "#"... */
GET_ARGUMENT_L("ignorer_couples_commutes=""icc=""commutativite_addition=""commutativite=""ca="
,ignorer_les_couples_commutes_dus_a_la_commutativite_de_l_addition
);
GET_ARGUMENT_N("conserver_couples_commutes=""ccc="
,ignorer_les_couples_commutes_dus_a_la_commutativite_de_l_addition
);
/* Arguments etendus le 20121112092704... */
GET_ARGUMENT_L("remplacer_nombres_premiers=""rnp=""index=",remplacer_les_nombres_premiers_par_leur_index);
GET_ARGUMENT_N("garder_nombres_premiers=""gnp=",remplacer_les_nombres_premiers_par_leur_index);
/* Arguments introduits le 20221021134729... */
GET_ARGUMENT_I("borne_inferieure_nombres_premiers=""binp=",borne_inferieure_des_nombres_premiers);
GET_ARGUMENT_I("borne_superieure_nombres_premiers=""bsnp=",borne_superieure_des_nombres_premiers);
/* Arguments introduits le 20250214174042... */
PROCESS_ARGUMENTS_DE_PARAMETRAGE_DE_LA_GENERATION_DE_SUITE_DE_VALEURS_1;
)
);
Test(EST_IMPAIR(premier_nombre_pair_a_tester))
/* Test introduit le 20131208173156... */
Bblock
PRINT_ERREUR("le premier nombre pair n'est pas pair");
CAL1(Prer1("(il vaut %d ",premier_nombre_pair_a_tester));
EGAL(premier_nombre_pair_a_tester,PAR0(premier_nombre_pair_a_tester));
CAL1(Prer1("et %d sera utilise)\n",premier_nombre_pair_a_tester));
Eblock
ATes
Bblock
Eblock
ETes
Test(IL_FAUT(editer_la_liste_des_nombres_premiers))
Bblock
Test(IL_FAUT(marquer_le_deuxieme_nombre_premier_d_un_couple_de_nombres_premiers_jumeaux))
Bblock
Test(IFET(EST_IMPAIR(distance_entre_deux_nombres_premiers_jumeaux)
,IFGT(distance_entre_deux_nombres_premiers_jumeaux,UN)
)
)
Bblock
PRINT_ATTENTION("une distance entre nombres premiers 'jumeaux' impaire et superieure a 1 n'a pas de sens");
/* Message introduit le 20150324162229... */
/* */
/* En effet, la "distance" entre deux nombres premiers quelconques (et donc pas */
/* necessairement jumeaux) ne peut etre que paire (sauf entre 2 et 3) puisque les */
/* nombres premiers sont impairs (sauf 2...). */
Eblock
ATes
Bblock
Eblock
ETes
Eblock
ATes
Bblock
Eblock
ETes
Eblock
ATes
Bblock
Eblock
ETes
Test(IFLE(premiere_image,derniere_image))
Bblock
Test(IFGE(NOMBRE_DE_NOMBRES_PREMIERS,DEUX))
Bblock
DEBUT_DE_LA_GENERATION_DE_LA_LISTE_DES_NOMBRES_PREMIERS;
/* Introduit le 20130110101548 sous cette forme... */
Test(IL_FAUT(editer_la_liste_des_nombres_premiers))
Bblock
DEFV(Int,INIT(nombre_premier_precedent,UNDEF));
DEFV(Int,INIT(le_nombre_premier_precedent_existe,FAUX));
/* Introduit le 20150324160607... */
DEFV(Int,INIT(index,UNDEF));
DoIn(index,index_du_premier_nombre_premier,INDEX_DU_DERNIER_NOMBRE_PREMIER,I)
Bblock
Test(IFINoo(NOMBRE_PREMIER(index)
,borne_inferieure_des_nombres_premiers
,borne_superieure_des_nombres_premiers
)
)
/* Test introduit le 20250214182001... */
Bblock
Test(IL_FAUT(plutot_qu_editer_les_nombres_premiers_editer_leur_rang))
/* Test introduit le 20130111082637... */
Bblock
CAL2(Prin2("NP(%d)=%d\n"
,index
,NOMBRE_PREMIER(index)
)
);
Eblock
ATes
Bblock
Test(IL_FAUT(calculer_les_decompositions_des_nombres_pairs))
Bblock
CAL2(Prin0("NombrePremier="));
Eblock
ATes
Bblock
Eblock
ETes
CAL2(Prin2("%*d",tabulation_des_nombres_premiers,NOMBRE_PREMIER(index)));
/* La tabulation des nombres premiers a ete introduite le 20170309101222 afin de creer la */
/* page 'v $xiMd/NombresPremiers_10000$vv$m4'... */
Test(IL_FAUT(marquer_le_deuxieme_nombre_premier_d_un_couple_de_nombres_premiers_jumeaux))
Bblock
Test(EST_VRAI(le_nombre_premier_precedent_existe))
Bblock
Test(IFEQ(SOUS(NOMBRE_PREMIER(index),nombre_premier_precedent)
,distance_entre_deux_nombres_premiers_jumeaux
)
)
Bblock
CAL2(Prin1(" jumeaux(%d)",distance_entre_deux_nombres_premiers_jumeaux));
/* Edition introduite le 20150324160607... */
Eblock
ATes
Bblock
Eblock
ETes
Eblock
ATes
Bblock
Eblock
ETes
Eblock
ATes
Bblock
Eblock
ETes
CAL2(Prin0("\n"));
EGAL(nombre_premier_precedent,NOMBRE_PREMIER(index));
EGAL(le_nombre_premier_precedent_existe,VRAI);
Eblock
ETes
Eblock
ATes
Bblock
Eblock
ETes
Eblock
EDoI
Eblock
ATes
Bblock
Eblock
ETes
Test(IZLE(dernier_nombre_pair_a_tester))
/* Test introduit le 20131208174720... */
Bblock
EGAL(dernier_nombre_pair_a_tester,DERNIER_NOMBRE_PAIR_POSSIBLE);
Eblock
ATes
Bblock
Test(IFGT(dernier_nombre_pair_a_tester,DERNIER_NOMBRE_PAIR_POSSIBLE))
/* Test introduit le 20131208174720... */
Bblock
PRINT_ERREUR("le dernier nombre pair est trop grand");
CAL1(Prer1("(il vaut %d ",dernier_nombre_pair_a_tester));
EGAL(dernier_nombre_pair_a_tester,DERNIER_NOMBRE_PAIR_POSSIBLE);
CAL1(Prer1("et %d sera utilise)\n",dernier_nombre_pair_a_tester));
Eblock
ATes
Bblock
Eblock
ETes
Eblock
ETes
Test(EST_IMPAIR(dernier_nombre_pair_a_tester))
/* Test introduit le 20131208173156... */
Bblock
PRINT_ERREUR("le dernier nombre pair n'est pas pair");
CAL1(Prer1("(il vaut %d ",dernier_nombre_pair_a_tester));
EGAL(dernier_nombre_pair_a_tester,PAR0(dernier_nombre_pair_a_tester));
CAL1(Prer1("et %d sera utilise)\n",dernier_nombre_pair_a_tester));
Eblock
ATes
Bblock
Eblock
ETes
Test(IL_FAUT(calculer_les_decompositions_des_nombres_pairs))
/* Test introduit le 20131201102246... */
Bblock
DoIn(nombre_entier_courant
,premier_nombre_pair_a_tester
,dernier_nombre_pair_a_tester
,PAS_DE_PROGRESSION_DES_ENTIERS
)
/* Ainsi, on va tester les nombres entiers pairs a partir de 4 et tels qu'il puissent */
/* etre decomposes en une somme de deux nombres premiers appartenant a la liste de */
/* nombres premiers qui vient d'etre constituee... */
Bblock
DEFV(Int,INIT(nombre_de_decompositions,ZERO));
Test(IL_NE_FAUT_PAS(editer_sequentiellement_les_decompositions))
Bblock
CAL2(Prin1("%d",nombre_entier_courant));
Eblock
ATes
Bblock
Eblock
ETes
#define editer_le_rang_des_nombres_premiers \
plutot_qu_editer_les_nombres_premiers_editer_leur_rang
#define editer_le_produit \
editer_le_produit_de_deux_nombres_premiers
/* Afin de raccourcir certaines des lignes qui viennent... */
VERIFICATION_DE_LA_CONJECTURE_DE_GOLDBACH(BLOC(INCR(nombre_de_decompositions,I);
Test(IL_FAUT(editer_sequentiellement_les_decompositions))
Bblock
Test(IL_FAUT(editer_le_rang_des_nombres_premiers))
/* Test introduit le 20130111082637... */
Bblock
CAL2(Prin3("%d=NP(%d)+NP(%d)\n"
,nombre_entier_courant
,index1
,index2
)
);
Eblock
ATes
Bblock
Test(IL_NE_FAUT_PAS(editer_le_produit))
/* Test introduit le 20200930142246... */
Bblock
CAL2(Prin3("%d=%d+%d\n"
,nombre_entier_courant
,NOMBRE_PREMIER_1
,NOMBRE_PREMIER_2
)
);
Eblock
ATes
Bblock
CAL2(Prin2("%d=%d\n"
,nombre_entier_courant
,MUL2(NOMBRE_PREMIER_1
,NOMBRE_PREMIER_2
)
)
);
Eblock
ETes
Eblock
ETes
Eblock
ATes
Bblock
Test(IL_FAUT(editer_toutes_les_decompositions))
/* Test introduit le 20131204110949... */
Bblock
Test(IL_FAUT(editer_le_rang_des_nombres_premiers))
/* Test introduit le 20130111082637... */
Bblock
CAL2(Prin2("=NP(%d)+NP(%d)",index1,index2));
Eblock
ATes
Bblock
Test(IL_NE_FAUT_PAS(editer_le_produit))
/* Test introduit le 20200930142246... */
Bblock
CAL2(Prin2("=%d+%d"
,NOMBRE_PREMIER_1
,NOMBRE_PREMIER_2
)
);
Eblock
ATes
Bblock
CAL2(Prin1("=%d"
,MUL2(NOMBRE_PREMIER_1
,NOMBRE_PREMIER_2
)
)
);
Eblock
ETes
Eblock
ETes
Eblock
ATes
Bblock
Eblock
ETes
Eblock
ETes
)
);
/* Introduit le 20130110103355 sous cette forme... */
#undef editer_le_produit
#undef editer_le_rang_des_nombres_premiers
Test(IL_NE_FAUT_PAS(editer_sequentiellement_les_decompositions))
Bblock
CAL2(Prin1("#%d\n",nombre_de_decompositions));
Eblock
ATes
Bblock
Eblock
ETes
Eblock
EDoI
Eblock
ATes
Bblock
Eblock
ETes
FIN_DE_LA_GENERATION_DE_LA_LISTE_DES_NOMBRES_PREMIERS;
/* Introduit le 20130110101548 sous cette forme... */
Eblock
ATes
Bblock
PRINT_ERREUR("il faut calculer une liste avec au moins deux termes");
Eblock
ETes
Eblock
ATes
Bblock
PRINT_ERREUR("la relation d'ordre stricte ('premier < dernier') n'est pas respectee");
Eblock
ETes
RETU_Commande;
Eblock
ECommande