/*************************************************************************************************************************************/
/* */
/* E V O L U T I O N D E F O N C T I O N S P R O P R E S S I M P L I F I E E S : */
/* */
/* */
/* Exemple avec : */
/* */
/* sigma=0.2 */
/* theta=$pis4 */
/* */
/* */
/* ............... */
/* ....................... */
/* ............................ ............... */
/* ................................ ...................... */
/* ............................................................. */
/* .............:::::::........................................... */
/* ..........:::-------:::......................................... */
/* ........::--++++o++++--::....................................... */
/* .......::-++oo*****oo++-::...................................... */
/* ......::-++o**#####**o++-::..................................... */
/* ......::-+oo*#######*oo+-::..................................... */
/* ......::-++o**#####**o++-::..................................... */
/* .......::-++oo*****oo++-::...................................... */
/* ........::--+++ooo+++--::....................................... */
/* ..........::--------:::......................................... */
/* .............:::::::........................................... */
/* ............................................................. */
/* ................................. ...................... */
/* ............................. ............... */
/* ....................... */
/* ............... */
/* */
/* */
/* Author of '$xrq/f_propres.11$K' : */
/* */
/* Jean-Francois COLONNA (LACTAMME, 1993??????????). */
/* */
/*************************************************************************************************************************************/
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* 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_CL_____MODULE_NON_OPTIMISABLE
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* F I C H I E R S D ' I N C L U D E S : */
/* */
/*************************************************************************************************************************************/
#include INCLUDES_BASE
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N D E S F O N C T I O N S U T I L E S ( C O M P A T I B I L I T E ) : */
/* */
/*************************************************************************************************************************************/
#include xrk/attractor.11.I"
#include xrv/particule.41.I"
#include xrs/sphere.18.I"
#include xrs/sphere.19.I"
/* Inutile, mais pour la compatibilite (introduit le 20030130111200 a cause de */
/* 'v $xcc/cpp$Z INCLUDES_1.sed'). */
#include xrk/attractor.12.I"
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N D E S C O O R D O N N E E S : */
/* */
/*************************************************************************************************************************************/
#define cXf(translation) \
MUL2(ASD1(echelle,cx),SOUS(_____cNORMALISE_OX(X),ASD1(translation,dx)))
#define cYf(translation) \
MUL2(ASD1(echelle,cy),SOUS(_____cNORMALISE_OY(Y),ASD1(translation,dy)))
/* Definition des coordonnees cartesiennes. On notera que l'on utilise (cXf,cYf) afin */
/* de ne pas rentrer en conflit avec la procedure 'coordonnees_flottantes_X_et_Y' qui */
/* definit {Xf,Yf} et qui est appelee dans '$xrv/champs_5.12$I' via '$xrs/surfaces.11$I' */
/* et '$xrk/attractor.17$I', et tout cela pour des raisons de compatibilite... */
#include xrs/surfaces.11.I"
#define cRHO(translation) \
Rho_2D(cXf(translation),cYf(translation)) \
/* Definition du rayon polaire. */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N D E S F O N C T I O N S P R O P R E S : */
/* */
/* */
/* Definition : */
/* */
/* On definit les deux fonctions */
/* suivantes : */
/* */
/* 2 2 */
/* (r+R) (r-R) */
/* - -------- - -------- */
/* 2 2 */
/* sigma sigma */
/* */
/* e + e */
/* psi (r) = --------------------------- */
/* + \ --- */
/* \/ 2 */
/* */
/* et : */
/* */
/* 2 2 */
/* (r+R) (r-R) */
/* - -------- - -------- */
/* 2 2 */
/* sigma sigma */
/* */
/* e - e */
/* psi (r) = --------------------------- */
/* - \ --- */
/* \/ 2 */
/* */
/* */
/* ou 'r' et 'R' designent les deux vecteurs : */
/* */
/* ('R' valant implicitement 1/4) */
/* */
/* r = {x,y} */
/* R = (R,0) */
/* */
/* */
/* Ensuite, on se definit la combinaison */
/* lineaire suivante : */
/* */
/* -i.theta */
/* alpha.psi (r) + beta.e .psi (r) */
/* + - */
/* psi(r,theta) = ---------------------------------------- */
/* \ --- */
/* \/ 2 */
/* */
/* 'theta' est (a une pulsation 'omega' pres) le */
/* temps 't' : */
/* */
/* theta = omega.t */
/* */
/* */
/* On notera les valeurs particulieres */
/* suivantes : */
/* */
/* alpha.psi (r) + beta.psi (r) */
/* + - */
/* psi(r,0) = ------------------------------ */
/* \ --- */
/* \/ 2 */
/* */
/* */
/* alpha.psi (r) - beta.psi (r) */
/* + - */
/* psi(r,pi) = ------------------------------ */
/* \ --- */
/* \/ 2 */
/* */
/* ainsi en jouant sur 'alpha' et 'beta' on peut */
/* "extraire" l'une des deux fonctions. Ainsi, on */
/* aura : */
/* */
/* psi = psi(r,0) */
/* + | alpha=1 */
/* | beta=0 */
/* */
/* psi = psi(r,0) */
/* - | alpha=0 */
/* | beta=1 */
/* */
/* psi = psi(r,0) */
/* Gauche | alpha=1 */
/* | beta=1 */
/* */
/* psi = psi(r,pi) */
/* Droite | alpha=1 */
/* | beta=1 */
/* */
/* et on fera : */
/* */
/* imaginaire=FAUX */
/* */
/* */
/*************************************************************************************************************************************/
#define ALPHA \
FU
#define BETA \
FU
DEFV(Local,DEFV(Float,INIT(alpha,ALPHA)));
DEFV(Local,DEFV(Float,INIT(beta,BETA)));
/* Definition de la ponderation des deux fonctions "psi-plus" et "psi-moins". */
#define SIGMA \
FRA5(FU)
DEFV(Local,DEFV(Float,INIT(sigma,SIGMA)));
/* "Sigma" des exponentielles. ATTENTION, pendant longtemps cette constante a ete definie */
/* avec la valeur : */
/* */
/* FRA4(FU) */
/* */
/* mais la nouvelle valeur donne des pics plus separes... */
#define PSI_PLUS_MOINS(operateur,ponderation) \
DIVI(MUL2(ponderation \
,operateur(EXPB(NEGA(DIVI(EXP2(cRHO(translation_a_gauche)),EXP2(sigma)))) \
,EXPB(NEGA(DIVI(EXP2(cRHO(translation_a_droite)),EXP2(sigma)))) \
) \
) \
,RACX(FDEUX) \
) \
/* Fonction "psi-plus/moins" generique. */ \
/* */ \
/* On notera que l'on utilise 'EXPB(...)' et non pas 'EXPX(...)' a cause du bug */ \
/* 'BUG_SYSTEME_SG_C_exp'... */
#define PSI_PLUS \
PSI_PLUS_MOINS(ADD2,alpha) \
/* Fonction "psi-plus", */
#define PSI_MOINS \
PSI_PLUS_MOINS(SOUS,beta) \
/* Fonction "psi-moins". */
dfTRANSFORMAT_31(liste_PARAMETRE_THETA,fichier_PARAMETRE_THETA,PARAMETRE_THETA_IMPLICITE,FZERO)
/* Definition du fichier du parametre 'theta'. */
#define sPARAMETRE_THETA(numero_de_la_periode) \
FLOT(sTRANSFORMAT_31(numero_de_la_periode,liste_PARAMETRE_THETA))
/* Formule generale definissant les variations de 'theta' au cours du temps. */
DEFV(Local,DEFV(Float,INIT(theta,FLOT__UNDEF)));
/* Definition du temps compte comme un angle... */
#define PARTIE_REELLE_DE_PSI \
DIVI(ADD2(PSI_PLUS \
,MUL2(PSI_MOINS,COSX(NEGA(theta))) \
) \
,RACX(FDEUX) \
) \
/* Partie reelle de la fonction "psi", */
#define PARTIE_IMAGINAIRE_DE_PSI \
DIVI(MUL2(PSI_MOINS,SINX(NEGA(theta))) \
,RACX(FDEUX) \
) \
/* Partie imaginaire de la fonction "psi". */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* C H O I X D E C E Q U I S E R A V I S U A L I S E : */
/* */
/*************************************************************************************************************************************/
#define CALCULER_AUSSI_LA_PARTIE_IMAGINAIRE \
VRAI
DEFV(Local,DEFV(Logical,INIT(calculer_aussi_la_partie_Imaginaire,CALCULER_AUSSI_LA_PARTIE_IMAGINAIRE)));
/* Faut-il calculer la partie Imaginaire : */
/* */
/* VRAI : c'est le module de la fonction propre qui sera visualise, */
/* FAUX : c'est uniquement la partie Reelle de la fonction propre qui sera visualise. */
/* */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* P A R A M E T R E S : */
/* */
/*************************************************************************************************************************************/
#define X_ECHELLE \
FU \
/* Echelle horizontale du champ, */
#define Y_ECHELLE \
FU \
/* Echelle verticale du champ. */
#define X_TRANSLATION \
FDU
#define Y_TRANSLATION \
FDU
/* Translation generale du champ. */
#define POSITION_HORIZONTALE_DES_GAUSSIENNES \
FRA4(FU) \
/* Position horizontale (en valeur absolue) des deux gaussiennes par rapport a l'origine. */
#define X_TRANSLATION_A_DROITE \
ADD2(X_TRANSLATION,POSITION_HORIZONTALE_DES_GAUSSIENNES)
#define Y_TRANSLATION_A_DROITE \
Y_TRANSLATION
/* Translation a droite du champ, */
#define X_TRANSLATION_A_GAUCHE \
SOUS(X_TRANSLATION,POSITION_HORIZONTALE_DES_GAUSSIENNES)
#define Y_TRANSLATION_A_GAUCHE \
Y_TRANSLATION
/* Translation a gauche du champ. */
#define RENORMALISER_CHAQUE_CHAMP_INDEPENDAMMENT \
FAUX \
/* Faut-il renormaliser chaque champ independamment des autres ('VRAI') ou bien faire une */ \
/* renormalisation globale de l'ensemble des champs ('FAUX') ? */
#define PRENDRE_UNE_DYNAMIQUE_LOGARITHMIQUE \
FAUX \
/* Faut-il prendre une dynamique logarithmique ('VRAI') ou laisser le champ des fonctions */ \
/* propres tel qu'il a ete calcule ('FAUX') ? */
#define NOMBRE_D_ITERATIONS_DE_LA_DYNAMIQUE_LOGARITHMIQUE \
UN \
/* S'il faut prendre une dynamique logarithmique, combien de fois faut-il iterer cela ? */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* M A C R O S U T I L E S : */
/* */
/*************************************************************************************************************************************/
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* E V O L U T I O N D E F O N C T I O N S P R O P R E S S I M P L I F I E E S : */
/* */
/*************************************************************************************************************************************/
BCommande(nombre_d_arguments,arguments)
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
DEFV(CHAR,INIC(POINTERc(nom_imageR),NOM_PIPE));
/* Nom de la sequence d'images a generer. */
DEFV(CHAR,INIT(POINTERc(nom_image),NOM_UNDEF));
/* Nom courant des images. */
DEFV(coeffF_2D,echelle);
/* Echelle du champ a generer. */
DEFV(deltaF_2D,translation_a_droite);
DEFV(deltaF_2D,translation_a_gauche);
/* Translations du champ a generer. */
DEFV(Logical,INIT(renormaliser_chaque_champ_independamment,RENORMALISER_CHAQUE_CHAMP_INDEPENDAMMENT));
/* Faut-il renormaliser chaque champ independamment des autres ('VRAI') ou bien faire une */
/* renormalisation globale de l'ensemble des champs ('FAUX') ? */
DEFV(Logical,INIT(prendre_une_dynamique_logarithmique,PRENDRE_UNE_DYNAMIQUE_LOGARITHMIQUE));
/* Faut-il prendre une dynamique logarithmique ('VRAI') ou laisser le champ des fonctions */
/* propres tel qu'il a ete calcule ('FAUX') ? */
DEFV(Positive,INIT(nombre_d_iterations_de_la_dynamique_logarithmique,NOMBRE_D_ITERATIONS_DE_LA_DYNAMIQUE_LOGARITHMIQUE));
/* S'il faut prendre une dynamique logarithmique, combien de fois faut-il iterer cela ? */
/*..............................................................................................................................*/
iTRANSFORMAT_31(liste_PARAMETRE_THETA,PARAMETRE_THETA_IMPLICITE);
/* Initialisation du parametre 'z'. */
INITIALISATION_COEFFICIENT_2D(echelle,X_ECHELLE,Y_ECHELLE);
/* Initialisation de l'echelle du champ a generer. */
INITIALISATION_ACCROISSEMENT_2D(translation_a_droite,X_TRANSLATION_A_DROITE,Y_TRANSLATION_A_DROITE);
INITIALISATION_ACCROISSEMENT_2D(translation_a_gauche,X_TRANSLATION_A_GAUCHE,Y_TRANSLATION_A_GAUCHE);
/* Initialisation des translations du champ a generer. */
#include xrv/champs_5.1A.I"
GET_ARGUMENTSi(nombre_d_arguments
,BLOC(PROCESS_ARGUMENTS_GEOMETRIQUES;
PROCESS_ARGUMENT_FICHIER("THETA="
,fichier_PARAMETRE_THETA
,liste_PARAMETRE_THETA
,PARAMETRE_THETA_IMPLICITE
,gTRANSFORMAT_31
);
GET_ARGUMENT_C("imageR=""R=",nom_imageR);
GET_ARGUMENT_F("Ex=",ASD1(echelle,cx));
GET_ARGUMENT_F("Ey=",ASD1(echelle,cy));
GET_ARGUMENT_F("Tdx=",ASD1(translation_a_droite,dx));
GET_ARGUMENT_F("Tdy=",ASD1(translation_a_droite,dy));
GET_ARGUMENT_F("Tgx=",ASD1(translation_a_gauche,dx));
GET_ARGUMENT_F("Tgy=",ASD1(translation_a_gauche,dy));
GET_ARGUMENT_F("alpha=",alpha);
GET_ARGUMENT_F("beta=",beta);
GET_ARGUMENT_F("sigma=",sigma);
GET_ARGUMENT_F("theta=",theta);
GET_ARGUMENT_L("imaginaire=",calculer_aussi_la_partie_Imaginaire);
GET_ARGUMENT_L("independant=",renormaliser_chaque_champ_independamment);
GET_ARGUMENT_L("logarithmique=""log=",prendre_une_dynamique_logarithmique);
GET_ARGUMENT_I("iterations=",nombre_d_iterations_de_la_dynamique_logarithmique);
)
);
#include xrq/synapse.11.I"
begin_nouveau_block
Bblock
DONNEES_DE_RECHERCHE_DES_EXTREMA_GLOBAUX_D_UNE_SEQUENCE_D_IMAGES;
/* Extrema globaux de l'ensemble de la sequence... */
BDEFV(imageF,champ_des_fonctions_propres);
/* Image flottante dans laquelle on trouve les fonctions propres avant renormalisation. */
CALi(Inoir(ImageR));
/* Initialisation de l'image Resultat. */
Komp(numero_de_la_periode_courante_de_la_simulation,nombre_de_periodes_de_la_simulation)
Bblock
DONNEES_DE_RECHERCHE_DES_EXTREMA_LOCAUX_D_UNE_SEQUENCE_D_IMAGES;
/* Extrema locaux de la sequence... */
vTRANSFORMAT_31(theta,sPARAMETRE_THETA,numero_de_la_periode_courante,fichier_PARAMETRE_THETA);
/* Definition du temps "theta". */
begin_image
Bblock
DEFV(complexe,fonction_propre);
Cinitialisation(fonction_propre
,PARTIE_REELLE_DE_PSI
,COND(IL_FAUT(calculer_aussi_la_partie_Imaginaire)
,PARTIE_IMAGINAIRE_DE_PSI
,FLOT__UNDEF
)
);
storeF_point(COND(IL_FAUT(calculer_aussi_la_partie_Imaginaire)
,Cmodule2(fonction_propre)
,Reelle(fonction_propre)
)
,champ_des_fonctions_propres
,X,Y
);
/* Et memorisation... */
Eblock
end_image
Test(IL_FAUT(prendre_une_dynamique_logarithmique))
Bblock
Repe(nombre_d_iterations_de_la_dynamique_logarithmique)
Bblock
CALS(IFdynamique_logarithmique_avec_translation_dynamique(champ_des_fonctions_propres
,champ_des_fonctions_propres
)
);
/* S'il le faut, la dynamique du champ des fonctions propres est reduite par application */
/* d'une fonction logarithme, et ce 'N' fois... */
Eblock
ERep
Eblock
ATes
Bblock
Eblock
ETes
RECHERCHE_DES_EXTREMA_D_UNE_SEQUENCE_D_IMAGES(champ_des_fonctions_propres);
/* Recherche des extrema locaux et globaux de l'ensemble de la sequence... */
EGAL(nom_image
,chain_Aconcaten2_sauf_nom_pipe(nom_imageR
,ChaineNumero(numero_de_la_periode_courante
,NOMBRE_DE_CHIFFRES
)
)
);
/* Le 20080602134954 fut introduit 'ChaineNumero(...)' afin de pouvoir parametrer */
/* aisement le nombre de chiffres des numeros... */
CALi(IupdateF_image(nom_image,champ_des_fonctions_propres));
/* Sauvegarde du champ sans renormalisation... */
CALZ_FreCC(nom_image);
INCR(numero_de_la_periode_courante,I);
/* Et passage a l'image suivante... */
Eblock
EKom
EGAL(numero_de_la_periode_courante,NUMERO_DE_LA_PREMIERE_PERIODE_DE_LA_SIMULATION);
/* Reinitialisation... */
Komp(numero_de_la_periode_courante_de_la_simulation,nombre_de_periodes_de_la_simulation)
Bblock
EGAL(nom_image
,chain_Aconcaten2_sauf_nom_pipe(nom_imageR
,ChaineNumero(numero_de_la_periode_courante
,NOMBRE_DE_CHIFFRES
)
)
);
/* Le 20080602134954 fut introduit 'ChaineNumero(...)' afin de pouvoir parametrer */
/* aisement le nombre de chiffres des numeros... */
Test(PAS_D_ERREUR(CODE_ERROR(IloadF_image(champ_des_fonctions_propres,nom_image))))
Bblock
Test(IL_NE_FAUT_PAS(renormaliser_chaque_champ_independamment))
Bblock
CALS(Ifloat_std(ImageR
,champ_des_fonctions_propres
,niveau_minimum_de_la_sequence
,niveau_maximum_de_la_sequence
)
);
/* Renormalisation globale des images de la sequence... */
Eblock
ATes
Bblock
CALS(Ifloat_std_avec_renormalisation(ImageR
,champ_des_fonctions_propres
)
);
/* Renormalisation locale des images de la sequence... */
Eblock
ETes
CALi(Iupdate_image(nom_image,ImageR));
Eblock
ATes
Bblock
/* ATTENTION : ce n'est plus une erreur que l'image courante n'existe pas puisque */
/* dorenavant, il peut y avoir des trous dans la sequence... */
Eblock
ETes
CALZ_FreCC(nom_image);
INCR(numero_de_la_periode_courante,I);
/* Et passage a l'image suivante... */
Eblock
EKom
EDEFV(imageF,champ_des_fonctions_propres);
/* Image flottante dans laquelle on trouve les fonctions propres avant renormalisation. */
Eblock
end_nouveau_block
RETU_Commande;
Eblock
ECommande