/*************************************************************************************************************************************/
/* */
/* C A L C U L D E L A F O N C T I O N Z E T A D E R I E M A N N A V E C L A S E R I E D ' E U L E R */
/* P O U R D E S N O M B R E S D ' I T E R A T I O N S V A R I A N T */
/* D E F A C O N S E Q U E N T I E L L E */
/* A V E C R E N O R M A L I S A T I O N G L O B A L E D E S I M A G E S : */
/* */
/* */
/* Author of '$xrc/zeta.12$K' : */
/* */
/* Jean-Francois COLONNA (LACTAMME, 1992??????????). */
/* */
/*************************************************************************************************************************************/
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* 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
#include maths_compl_fonct_ITERATIONS_EXT
#include image_image_QUAD_IMAGE_EXT
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* P A R A M E T R E S : */
/* */
/*************************************************************************************************************************************/
#define X_DEPART_GAUCHE \
PARE(0.0)
#define X_DEPART_DROITE \
PARE(8.0)
#define Y_DEPART_BAS \
PARE(-4.0)
#define Y_DEPART_HAUT \
PARE(4.0)
/* Definition de la fenetre de depart. */
#define X_ARRIVEE_GAUCHE \
X_DEPART_GAUCHE
#define X_ARRIVEE_DROITE \
X_DEPART_DROITE
#define Y_ARRIVEE_BAS \
Y_DEPART_BAS
#define Y_ARRIVEE_HAUT \
Y_DEPART_HAUT
/* Definition de la fenetre d'arrivee. */
#define NOMBRE_D_ITERATIONS_DE_DEPART \
DEUX \
/* Nombre d'iterations demandees, */
#define PAS_D_EVOLUTION_DU_NOMBRE_D_ITERATIONS \
I \
/* Et son pas d'evolution... */
#define PRECISION \
PARE(0.00001) \
/* Pour calculer le rapport de reduction. */
#define NOMBRE_D_IMAGES \
UN \
/* Nombre d'images a generer. */
#define PREMIERE_IMAGE \
PREMIERE_IMAGE_ABSOLUE \
/* Numero de la premiere image a generer : ce parametre permet de faire une reprise sur une */ \
/* sequence interrompue. */
#define PRENDRE_UNE_DYNAMIQUE_LOGARITHMIQUE_POUR_LE_MODULE \
FAUX \
/* Indique si l'on doit changer la dynamique du module en une dynamique logarithmique... */
#define GENERER_LA_PARTIE_REELLE \
FAUX
#define GENERER_LA_PARTIE_IMAGINAIRE \
FAUX
#define GENERER_LE_MODULE \
VRAI
#define GENERER_LA_PHASE \
VRAI
/* Indicateurs controlant la generation des quatre types d'images. */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* M A C R O S U T I L E S : */
/* */
/*************************************************************************************************************************************/
#include xrc/ITERATION.11.I"
/* Introduit le 20091122183119... */
#define RECHERCHE_DES_EXTREMA(image_flottante,niveau_minimum_de_la_sequence,niveau_maximum_de_la_sequence) \
Bblock \
DEFV(genere_Float,INIT(niveau_minimum_de_l_image,FLOT__NIVEAU_UNDEF)); \
DEFV(genere_Float,INIT(niveau_maximum_de_l_image,FLOT__NIVEAU_UNDEF)); \
/* Afin de rechercher les niveaux extrema de l'image courante. */ \
CALS(IFnivo_extrema(image_flottante \
,ADRESSE(niveau_minimum_de_l_image) \
,ADRESSE(niveau_maximum_de_l_image) \
) \
); \
/* Recherche des extrema locaux a l'image courante. */ \
EGAL(niveau_minimum_de_la_sequence \
,MIN2(niveau_minimum_de_la_sequence \
,niveau_minimum_de_l_image \
) \
); \
EGAL(niveau_maximum_de_la_sequence \
,MAX2(niveau_maximum_de_la_sequence \
,niveau_maximum_de_l_image \
) \
); \
/* Recherche des extrema globaux a la sequence entiere. */ \
Eblock \
/* Procedure recherchant les extrema globaux d'une suite d'image flottantes... */
#define STOCKAGE_INTERMEDIAIRE_D_UN_TYPE_D_IMAGE(generer_ce_type_d_image,nom_du_type_d_image,image_flottante,minimum,maximum) \
Bblock \
Test(IL_FAUT(generer_ce_type_d_image)) \
Bblock \
RECHERCHE_DES_EXTREMA(image_flottante,minimum,maximum); \
/* Echerche des extrema globaux... */ \
EGAL(nom_image \
,chain_Aconcaten2_sauf_nom_pipe(nom_du_type_d_image \
,chain_numero(numero_d_image,nombre_de_chiffres) \
) \
); \
CALi(IupdateF_image(nom_image,image_flottante)); \
/* Stockage intermediaire de l'image flottante... */ \
CALZ_FreCC(nom_image); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
/* Procedure generant si necessaire un certain type d'image. */
#define GENERATION_D_UN_TYPE_D_IMAGE(generer_ce_type_d_image,nom_du_type_d_image,image_flottante,minimum,maximum,image_standard) \
Bblock \
Test(IL_FAUT(generer_ce_type_d_image)) \
Bblock \
EGAL(nom_image \
,chain_Aconcaten2_sauf_nom_pipe(nom_du_type_d_image \
,chain_numero(numero_d_image,nombre_de_chiffres) \
) \
); \
Test(PAS_D_ERREUR(CODE_ERROR(IloadF_image(image_flottante,nom_image)))) \
Bblock \
CALS(Ifloat_std(image_standard,image_flottante,minimum,maximum)); \
/* Conversion preliminaire en une image "standard" avec renormalisation globale. */ \
CALi(Iupdate_image(nom_image,image_standard)); \
/* Puis enregistrement... */ \
Eblock \
ATes \
Bblock \
Test__CODE_ERREUR__ERREUR07; \
Eblock \
ETes \
CALZ_FreCC(nom_image); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
/* Procedure generant si necessaire un certain type d'image. */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* C A L C U L D E L A F O N C T I O N Z E T A D E R I E M A N N A V E C L A S E R I E D ' E U L E R */
/* P O U R D E S N O M B R E S D ' I T E R A T I O N S V A R I A N T */
/* D E F A C O N S E Q U E N T I E L L E */
/* A V E C R E N O R M A L I S A T I O N G L O B A L E D E S I M A G E S : */
/* */
/*************************************************************************************************************************************/
BCommande(nombre_d_arguments,arguments)
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
DEFV(complexe,coin_bas_gauche_de_depart_puis_courant);
/* Definition du point situe en bas a gauche de la fenetre de depart, puis de la fenetre */
/* courante au cours du zoom. */
DEFV(complexe,coin_haut_droite_de_depart_puis_courant);
/* Definition du point situe en haut a droite de la fenetre de depart, puis de la fenetre */
/* courante au cours du zoom. */
DEFV(complexe,coin_bas_gauche_d_arrivee);
/* Definition du point situe en bas a gauche de la fenetre d'arrivee, */
DEFV(complexe,coin_haut_droite_d_arrivee);
/* Definition du point situe en haut a droite de la fenetre d'arrivee. */
DEFV(Positive,INIT(nombre_d_iterations,NOMBRE_D_ITERATIONS_DE_DEPART));
/* Nombre maximal d'iterations a effectuer, */
DEFV(Positive,INIT(pas_d_evolution_du_nombre_d_iterations,PAS_D_EVOLUTION_DU_NOMBRE_D_ITERATIONS));
/* Et son pas d'evolution... */
DEFV(Float,INIT(precision,PRECISION));
/* Pour calculer le rapport de reduction. */
DEFV(Float,INIT(rapport_de_reduction,FLOT__UNDEF));
/* Rapport de passage d'une fenetre a l'autre. */
DEFV(Int,INIT(nombre_d_images,NOMBRE_D_IMAGES));
/* Nombre d'images a generer. */
DEFV(Int,INIT(numero_d_image,PREMIERE_IMAGE_ABSOLUE));
/* Numero de l'image courante (celle-ci n'est pas necessairement generee : voir */
/* le parametre 'PREMIERE_IMAGE'). */
DEFV(CHAR,INIC(POINTERc(nom_imageRR),NOM_PIPE));
DEFV(CHAR,INIC(POINTERc(nom_imageRI),NOM_PIPE));
DEFV(CHAR,INIC(POINTERc(nom_imageRMo),NOM_PIPE));
DEFV(CHAR,INIC(POINTERc(nom_imageRPh),NOM_PIPE));
/* Nom de la sequence d'images a generer. */
DEFV(Int,INIT(nombre_de_chiffres,NOMBRE_DE_CHIFFRES));
/* Nombre de chiffres codant le numero des images de la sequence a generer. */
DEFV(CHAR,INIT(POINTERc(nom_image),NOM_UNDEF));
/* Nom courant des images. */
DEFV(Logical,INIT(prendre_une_dynamique_logarithmique_pour_le_module,PRENDRE_UNE_DYNAMIQUE_LOGARITHMIQUE_POUR_LE_MODULE));
/* Indique si l'on doit changer la dynamique du module en une dynamique logarithmique... */
DEFV(Logical,INIT(generer_la_partie_reelle,GENERER_LA_PARTIE_REELLE));
DEFV(Logical,INIT(generer_la_partie_imaginaire,GENERER_LA_PARTIE_IMAGINAIRE));
DEFV(Logical,INIT(generer_le_module,GENERER_LE_MODULE));
DEFV(Logical,INIT(generer_la_phase,GENERER_LA_PHASE));
/* Indicateurs controlant la generation des quatre types d'images. */
DEFV(Positive,INIT(premiere_iteration_effective,PREMIER_ELEMENT_DE_LA_FONCTION_ZETA_DE_RIEMANN));
/* Numero de la premiere iteration effective (ceci va permettre d'optimiser...). */
DEFV(complexe,valeur_initiale);
/* Valeur initiale de 'fonction_zeta_de_Riemann' */
DEFV(genere_Float,INIT(niveau_minimum_des_parties_reelles,F_INFINI));
DEFV(genere_Float,INIT(niveau_maximum_des_parties_reelles,F_MOINS_L_INFINI));
/* Afin de rechercher les niveaux extrema globaux de l'ensemble des parties reelles. */
DEFV(genere_Float,INIT(niveau_minimum_des_parties_imaginaires,F_INFINI));
DEFV(genere_Float,INIT(niveau_maximum_des_parties_imaginaires,F_MOINS_L_INFINI));
/* Afin de rechercher les niveaux extrema globaux de l'ensemble des parties imaginaires. */
DEFV(genere_Float,INIT(niveau_minimum_des_modules,F_INFINI));
DEFV(genere_Float,INIT(niveau_maximum_des_modules,F_MOINS_L_INFINI));
/* Afin de rechercher les niveaux extrema globaux de l'ensemble des modules. */
DEFV(genere_Float,INIT(niveau_minimum_des_phases,F_INFINI));
DEFV(genere_Float,INIT(niveau_maximum_des_phases,F_MOINS_L_INFINI));
/* Afin de rechercher les niveaux extrema globaux de l'ensemble des phases. */
/*..............................................................................................................................*/
Cinitialisation(coin_bas_gauche_de_depart_puis_courant,X_DEPART_GAUCHE,Y_DEPART_BAS);
Cinitialisation(coin_haut_droite_de_depart_puis_courant,X_DEPART_DROITE,Y_DEPART_HAUT);
/* Definition de la fenetre de depart. */
Cinitialisation(coin_bas_gauche_d_arrivee,X_ARRIVEE_GAUCHE,Y_ARRIVEE_BAS);
Cinitialisation(coin_haut_droite_d_arrivee,X_ARRIVEE_DROITE,Y_ARRIVEE_HAUT);
/* Definition de la fenetre d'arrivee. */
GET_ARGUMENTSi(nombre_d_arguments
,BLOC(GET_ARGUMENT_I("n=""images=""N=",nombre_d_images);
GET_ARGUMENT_C("imageRR=""RR=",nom_imageRR);
GET_ARGUMENT_C("imageRI=""RI=",nom_imageRI);
GET_ARGUMENT_C("imageRMo=""RMo=",nom_imageRMo);
GET_ARGUMENT_C("imageRPh=""RPh=",nom_imageRPh);
GET_ARGUMENT_I("chiffres=",nombre_de_chiffres);
GET_ARGUMENT_I("iterations=",nombre_d_iterations);
GET_ARGUMENT_I("pas=",pas_d_evolution_du_nombre_d_iterations);
GET_ARGUMENT_F("xbgd=""xbgD=",Reelle(coin_bas_gauche_de_depart_puis_courant));
GET_ARGUMENT_F("ybgd=""ybgD=",Imaginaire(coin_bas_gauche_de_depart_puis_courant));
GET_ARGUMENT_F("xhdd=""xhdD=",Reelle(coin_haut_droite_de_depart_puis_courant));
GET_ARGUMENT_F("yhdd=""yhdD=",Imaginaire(coin_haut_droite_de_depart_puis_courant));
GET_ARGUMENT_F("xbga=""xbgA=",Reelle(coin_bas_gauche_d_arrivee));
GET_ARGUMENT_F("ybga=""ybgA=",Imaginaire(coin_bas_gauche_d_arrivee));
GET_ARGUMENT_F("xhda=""xhdA=",Reelle(coin_haut_droite_d_arrivee));
GET_ARGUMENT_F("yhda=""yhdA=",Imaginaire(coin_haut_droite_d_arrivee));
GET_ARGUMENT_F("precision=",precision);
GET_ARGUMENT_L("logarithmique=",prendre_une_dynamique_logarithmique_pour_le_module);
GET_ARGUMENT_L("genererR=""gR=",generer_la_partie_reelle);
GET_ARGUMENT_L("genererI=""gI=",generer_la_partie_imaginaire);
GET_ARGUMENT_L("genererMo=""gMo=",generer_le_module);
GET_ARGUMENT_L("genererPh=""gPh=",generer_la_phase);
/* Les abbreviations "g.=" et "g..=" ont ete introduites le 20210205120303... */
)
);
begin_nouveau_block
Bblock
BDEFV(imageJ,fonction_zeta_de_Riemann);
/* Definition de la fonction zeta complexe. */
BDEFV(imageF,partie_reelle_de_la_fonction_zeta_de_Riemann);
BDEFV(imageF,partie_imaginaire_de_la_fonction_zeta_de_Riemann);
BDEFV(imageF,module_de_la_fonction_zeta_de_Riemann);
BDEFV(imageF,phase_de_la_fonction_zeta_de_Riemann);
/* Definition des images flottantes necessaires. */
BDEFV(image,imageRR);
BDEFV(image,imageRI);
BDEFV(image,imageRMo);
BDEFV(image,imageRPh);
/* Definition des images "standards" necessaires. */
Cinitialisation(valeur_initiale,R0_Complexe,I0_Complexe);
CALS(IJinitialisation(fonction_zeta_de_Riemann,ADRESSE(valeur_initiale)));
/* Initialisation du processus iteratif sur : */
/* */
/* zeta(C) = 0 */
/* */
CALCUL_DU_RAPPORT_DE_REDUCTION;
DoIn(numero_d_image
,PREMIERE_IMAGE_ABSOLUE
,LSTX(PREMIERE_IMAGE_ABSOLUE,nombre_d_images)
,I
)
Bblock
Test(IFGE(numero_d_image,PREMIERE_IMAGE))
Bblock
/* Afin de se positionner dans la sequence... */
CALS(IJfonction_serie_zeta_dans_C(fonction_zeta_de_Riemann
,fonction_zeta_de_Riemann
,ADRESSE(coin_bas_gauche_de_depart_puis_courant)
,ADRESSE(coin_haut_droite_de_depart_puis_courant)
,premiere_iteration_effective
,nombre_d_iterations
)
);
/* Calcul de la fonction 'zeta' de Riemann. */
Test(IFOU(IFOU(IL_FAUT(generer_la_partie_reelle),IL_FAUT(generer_la_partie_imaginaire))
,IFOU(IL_FAUT(generer_le_module),IL_FAUT(generer_la_phase))
)
)
Bblock
CALS(Icomplexe_reelle(partie_reelle_de_la_fonction_zeta_de_Riemann,fonction_zeta_de_Riemann));
CALS(Icomplexe_imaginaire(partie_imaginaire_de_la_fonction_zeta_de_Riemann,fonction_zeta_de_Riemann));
/* Recuperation des parties Reelles et Imaginaires de la fonction 'zeta' de Riemann, */
Eblock
ATes
Bblock
Eblock
ETes
Test(IFOU(IL_FAUT(generer_le_module),IL_FAUT(generer_la_phase)))
Bblock
CALS(Iconversion_XY_RT(module_de_la_fonction_zeta_de_Riemann
,phase_de_la_fonction_zeta_de_Riemann
,partie_reelle_de_la_fonction_zeta_de_Riemann
,partie_imaginaire_de_la_fonction_zeta_de_Riemann
)
);
/* Puis calcul du Module et de la Phase dans [0,2.PI]. */
Test(IL_FAUT(prendre_une_dynamique_logarithmique_pour_le_module))
Bblock
CALS(IFdynamique_logarithmique_avec_translation_dynamique(module_de_la_fonction_zeta_de_Riemann
,module_de_la_fonction_zeta_de_Riemann
)
);
/* Changement eventuel de la dynamique du module... */
Eblock
ATes
Bblock
Eblock
ETes
Eblock
ATes
Bblock
Eblock
ETes
STOCKAGE_INTERMEDIAIRE_D_UN_TYPE_D_IMAGE(generer_la_partie_reelle
,nom_imageRR
,partie_reelle_de_la_fonction_zeta_de_Riemann
,niveau_minimum_des_parties_reelles
,niveau_maximum_des_parties_reelles
);
STOCKAGE_INTERMEDIAIRE_D_UN_TYPE_D_IMAGE(generer_la_partie_imaginaire
,nom_imageRI
,partie_imaginaire_de_la_fonction_zeta_de_Riemann
,niveau_minimum_des_parties_imaginaires
,niveau_maximum_des_parties_imaginaires
);
STOCKAGE_INTERMEDIAIRE_D_UN_TYPE_D_IMAGE(generer_le_module
,nom_imageRMo
,module_de_la_fonction_zeta_de_Riemann
,niveau_minimum_des_modules
,niveau_maximum_des_modules
);
STOCKAGE_INTERMEDIAIRE_D_UN_TYPE_D_IMAGE(generer_la_phase
,nom_imageRPh
,phase_de_la_fonction_zeta_de_Riemann
,niveau_minimum_des_phases
,niveau_maximum_des_phases
);
/* Stockage intermediaire des images flottantes et recherche des extrema globaux. */
Eblock
ATes
Bblock
Eblock
ETes
EGAL(premiere_iteration_effective
,SUCC(LSTX(PREMIER_ELEMENT_DE_LA_FONCTION_ZETA_DE_RIEMANN,nombre_d_iterations))
);
/* Et evolution du numero de la premiere iteration effective, qui correspond a celle qui */
/* suit la derniere qui vient d'etre calculee... */
INCR(nombre_d_iterations,pas_d_evolution_du_nombre_d_iterations);
/* Et progression du nombre d'iterations... */
REDUCTION_DE_LA_FENETRE_COURANTE;
Eblock
EDoI
DoIn(numero_d_image
,PREMIERE_IMAGE_ABSOLUE
,LSTX(PREMIERE_IMAGE_ABSOLUE,nombre_d_images)
,I
)
Bblock
Test(IFGE(numero_d_image,PREMIERE_IMAGE))
Bblock
/* Afin de se positionner dans la sequence... */
GENERATION_D_UN_TYPE_D_IMAGE(generer_la_partie_reelle
,nom_imageRR
,partie_reelle_de_la_fonction_zeta_de_Riemann
,niveau_minimum_des_parties_reelles
,niveau_maximum_des_parties_reelles
,imageRR
);
GENERATION_D_UN_TYPE_D_IMAGE(generer_la_partie_imaginaire
,nom_imageRI
,partie_imaginaire_de_la_fonction_zeta_de_Riemann
,niveau_minimum_des_parties_imaginaires
,niveau_maximum_des_parties_imaginaires
,imageRI
);
GENERATION_D_UN_TYPE_D_IMAGE(generer_le_module
,nom_imageRMo
,module_de_la_fonction_zeta_de_Riemann
,niveau_minimum_des_modules
,niveau_maximum_des_modules
,imageRMo
);
GENERATION_D_UN_TYPE_D_IMAGE(generer_la_phase
,nom_imageRPh
,phase_de_la_fonction_zeta_de_Riemann
,niveau_minimum_des_phases
,niveau_maximum_des_phases
,imageRPh
);
/* Generation des images demandees. */
Eblock
ATes
Bblock
Eblock
ETes
Eblock
EDoI
EDEFV(image,imageRPh);
EDEFV(image,imageRMo);
EDEFV(image,imageRI);
EDEFV(image,imageRR);
/* Definition des images "standards" necessaires. */
EDEFV(imageF,phase_de_la_fonction_zeta_de_Riemann);
EDEFV(imageF,module_de_la_fonction_zeta_de_Riemann);
EDEFV(imageF,partie_imaginaire_de_la_fonction_zeta_de_Riemann);
EDEFV(imageF,partie_reelle_de_la_fonction_zeta_de_Riemann);
/* Definition des images flottantes necessaires. */
EDEFV(imageJ,fonction_zeta_de_Riemann);
/* Definition de la fonction zeta complexe. */
Eblock
end_nouveau_block
RETU_Commande;
Eblock
ECommande