/*************************************************************************************************************************************/
/* */
/* O P T I M I S A T I O N E N C O O R D O N N E E S S P H E R I Q U E S */
/* D E S D I S T A N C E S E N T R E D E S P O I N T S */
/* E N C O O R D O N N E E S S P H E R I Q U E S ( O U C A R T E S I E N N E S ) */
/* P A R M A X I M I S A T I O N D E L A D I S T A N C E M I N I M A L E : */
/* */
/* */
/* Definitions : */
/* */
/* Les arguments devront etre definis */
/* soit en coordonnees spheriques : */
/* */
/* rho */
/* theta E [0,PI] */
/* phi E [0,2.PI] */
/* */
/* soit en coordonnees cartesiennes {X,Y,Z}. */
/* */
/* */
/* ATTENTION : */
/* */
/* Que les coordonnees soient definies en */
/* spheriques {rho,theta,phi} ou bien en */
/* cartesiennes {X,Y,Z}, les perturbations se */
/* font en spheriques. Ces perturbations sont */
/* donc conditionnees par : */
/* */
/* {phi__delta_initial,phi__delta_final,phi__minimum,phi__maximum} = {1/5,1/5 ,0 ,2.pi} */
/* {theta_delta_initial,theta_delta_final,theta_minimum,theta_maximum} = {1/2,1/10,0 ,pi} */
/* */
/* et surtout par : */
/* */
/* {rho__delta_initial,rho__delta_final,rho__minimum,rho__maximum} = {0,0,1,1} */
/* */
/* qui sont initialises pour une sphere de */
/* rayon constant (egal a 1)... */
/* */
/* */
/* Author of '$xrv/optimise.01$K' : */
/* */
/* Jean-Francois COLONNA (LACTAMME, 20011009085752). */
/* */
/*************************************************************************************************************************************/
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* 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 : */
/* */
/*************************************************************************************************************************************/
/* Le 20080311163639, fut supprime : */
/* */
/* @define PRAGMA_CL_____MODULE_NON_OPTIMISABLE */
/* */
/* qui semblait inutile... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* F I C H I E R S D ' I N C L U D E S : */
/* */
/*************************************************************************************************************************************/
#include INCLUDES_BASE
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* V A L E U R S I M P L I C I T E S D E S P A R A M E T R E S : */
/* */
/*************************************************************************************************************************************/
#define UTILISER_LES_COORDONNEES_CARTESIENNES_EN_ENTREE \
FAUX
#define UTILISER_LES_COORDONNEES_CARTESIENNES_EN_SORTIE \
FAUX
/* Afin de choisir entre les coordonnees cartesiennes ('VRAI') et les coordonnees */
/* spheriques ('VRAI') en entree et en sortie... */
#define NOMBRE_D_ITERATIONS_D_OPTIMISATION \
CENT_MILLE \
/* Nombre d'iterations maximum... */
#define S_ARRETER_AVANT_LA_FIN \
FAUX
#define NOMBRE_D_ITERATIONS_D_OPTIMISATION_AU_BOUT_DUQUEL_S_ARRETER \
NOMBRE_D_ITERATIONS_D_OPTIMISATION
/* Faut-il s'arreter avant la fin et si oui, au bout de combien d'iterations ? Ceci a ete */
/* introduit le 20011107161207 afin de permettre la realisation des animations decrites */
/* par 'v $xiirs/.PSPH.31.1.$u optimise.01'. Il est en effet important que pour toutes */
/* les images d'une visualisation de la dynamique du processus, l'echelle de 'temps' soit la */
/* meme ; et pour ce faire, il est essentiel que 'nombre_d_iterations_d_optimisation' soit */
/* le meme pour toutes ces images ; il convient donc d'introduire un nouveau test d'arret, */
/* d'ou 'nombre_d_iterations_d_optimisation_au_bout_duquel_s_arreter'... */
#define NOMBRE_MAXIMAL_DE_TENTATIVES_PAR_ITERATION \
UN \
/* Pour chaque iteration, il est possible de faire plusieurs tentatives de suite dans le */ \
/* cas ou elles sont infructueuses (c'est-a-dire n'augmente pas la distance minimale). */ \
/* La valeur par defaut est choisie le 20011110102959 pour assurer la compatibilite avec */ \
/* utilisations anterieures... */ \
/* */ \
/* On notera qu'une valeur differente de la valeur par defaut ('UN') peut rentrer en */ \
/* conflit avec les parametres de probabilite 'probabilite_de_refuser_une_bonne_solution' */ \
/* et 'probabilite_d_accepter_une_mauvaise_solution', puisque l'espoir avec ce parametre */ \
/* 'nombre_maximal_de_tentatives_par_iteration' est finalement de ne trouver, pour chaque */ \
/* iteration, qu'une bonne solution... */
#define RHO__MINIMUM \
FU
#define RHO__MAXIMUM \
RHO__MINIMUM
#define RHO__DELTA_INITIAL \
FZERO
#define RHO__DELTA_FINAL \
FZERO
#define RHO__DELTA_DOIT_ETRE_NEGATIF \
FAUX
#define RHO__DELTA_DOIT_ETRE_POSITIF \
FAUX
/* Definition de la coordonnee spherique 'rho' initialise tel que rho=constante a priori, */
/* c'est-a-dire tel que les points {X,Y,Z} soient sur une sphere de rayon 'rho'... */
#define PHI__MINIMUM \
FZERO
#define PHI__MAXIMUM \
CERCLE_TRIGONOMETRIQUE
#define PHI__DELTA_INITIAL \
GRO2(FRA2(FU))
#define PHI__DELTA_FINAL \
GRO2(FRA10(FU))
#define PHI__DELTA_DOIT_ETRE_NEGATIF \
FAUX
#define PHI__DELTA_DOIT_ETRE_POSITIF \
FAUX
/* Definition de la coordonnee spherique 'phi'. */
#define THETA_MINIMUM \
FZERO
#define THETA_MAXIMUM \
PI
#define THETA_DELTA_INITIAL \
GRO1(FRA2(FU))
#define THETA_DELTA_FINAL \
GRO1(FRA10(FU))
#define THETA_DELTA_DOIT_ETRE_NEGATIF \
FAUX
#define THETA_DELTA_DOIT_ETRE_POSITIF \
FAUX
/* Definition de la coordonnee spherique 'theta'. */
#define PLUS_PETITE_DISTANCE_MINIMALE_AUTORISEE \
FZERO
#define PLUS_GRANDE_DISTANCE_MINIMALE_AUTORISEE \
F_INFINI
/* Definitions des bornes de la distance minimale (introduites le 20150616133828). */
#define PROBABILITE_DE_PERTURBER_UN_POINT \
FRA1(FRA10(FU)) \
/* Probabilite de perturber le point courant... */
#define PROBABILITE_DE_REFUSER_UNE_BONNE_SOLUTION \
FRA2(FRA10(FU)) \
/* Probabilite de refuser une bonne solution... */
#define PROBABILITE_D_ACCEPTER_UNE_MAUVAISE_SOLUTION \
FZERO \
/* Probabilite d'accepter une mauvaise solution... Cette valeur nulle par defaut est */ \
/* justifiee par ce qui est decrit le 20011111085109 lors de l'utilisation de ces diverses */ \
/* probabilites... */
#define EDITER_LES_DISTANCES_MINIMALES_INITIALE_ET_FINALE \
FAUX \
/* Doit-on editer les distances minimales initiale et finale pour voir l'amelioration ? */
#define AVOIR_UN_POINT_FIXE \
FAUX
#define INDEX_DU_POINT_FIXE \
PREMIER_ELEMENT_D_UN_FICHIER
/* Doit-il y avoir un point fixe et si oui, lequel ? Ceci a ete introduit le 20011107135709 */
/* afin de "stabiliser" les animations decrites par 'v $xiirs/.PSPH.31.1.$u optimise.01'. */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N D E S F I C H I E R S : */
/* */
/*************************************************************************************************************************************/
#include xrv/ARITHMET.1d.I"
/* Passage a l'allocation dynamique le 20060214192917... */
#include xrv/ARITHMET.21.I"
#include xrv/champs_5.41.I"
#include xrq/nucleon.LB.I"
#define RHO__IMPLICITE \
RHO__MINIMUM
#define PHI__IMPLICITE \
PHI__MINIMUM
#define THETA_IMPLICITE \
THETA_MINIMUM
gGENERATION_D_UN_FICHIER(fichier_LISTE_RHO_,liste_initiale_des_RHO_);
gGENERATION_D_UN_FICHIER(fichier_LISTE_PHI_,liste_initiale_des_PHI_);
gGENERATION_D_UN_FICHIER(fichier_LISTE_THETA,liste_initiale_des_THETA);
/* Definition en memoire des fichiers de coordonnees spheriques. */
#define ELEMENT_DU_FICHIER_LISTE_RHO_(index) \
gELEMENT_DU_FICHIER(liste_initiale_des_RHO_,index)
#define ELEMENT_DU_FICHIER_LISTE_PHI_(index) \
gELEMENT_DU_FICHIER(liste_initiale_des_PHI_,index)
#define ELEMENT_DU_FICHIER_LISTE_THETA(index) \
gELEMENT_DU_FICHIER(liste_initiale_des_THETA,index)
/* Acces a un element courant des fichiers de coordonnees spheriques. */
#define X_IMPLICITE \
FZERO
#define Y_IMPLICITE \
FZERO
#define Z_IMPLICITE \
FZERO
gGENERATION_D_UN_FICHIER(fichier_LISTE_X,liste_initiale_des_X);
gGENERATION_D_UN_FICHIER(fichier_LISTE_Y,liste_initiale_des_Y);
gGENERATION_D_UN_FICHIER(fichier_LISTE_Z,liste_initiale_des_Z);
/* Definition en memoire des fichiers de coordonnees cartesiennes. */
#define ELEMENT_DU_FICHIER_LISTE_X(index) \
gELEMENT_DU_FICHIER(liste_initiale_des_X,index)
#define ELEMENT_DU_FICHIER_LISTE_Y(index) \
gELEMENT_DU_FICHIER(liste_initiale_des_Y,index)
#define ELEMENT_DU_FICHIER_LISTE_Z(index) \
gELEMENT_DU_FICHIER(liste_initiale_des_Z,index)
/* Acces a un element courant des fichiers de coordonnees cartesiennes. */
gGENERATION_D_UN_FICHIER_liste(sauvegarde_liste_initiale_des_RHO_);
gGENERATION_D_UN_FICHIER_liste(sauvegarde_liste_initiale_des_PHI_);
gGENERATION_D_UN_FICHIER_liste(sauvegarde_liste_initiale_des_THETA);
/* Definition en memoire des fichiers de sauvegarde des coordonnees spheriques. */
#define ELEMENT_DU_FICHIER_SAUVEGARDE_LISTE_RHO_(index) \
gELEMENT_DU_FICHIER(sauvegarde_liste_initiale_des_RHO_,index)
#define ELEMENT_DU_FICHIER_SAUVEGARDE_LISTE_PHI_(index) \
gELEMENT_DU_FICHIER(sauvegarde_liste_initiale_des_PHI_,index)
#define ELEMENT_DU_FICHIER_SAUVEGARDE_LISTE_THETA(index) \
gELEMENT_DU_FICHIER(sauvegarde_liste_initiale_des_THETA,index)
/* Acces a un element courant des fichiers de sauvegarde des coordonnees spheriques. */
gGENERATION_D_UN_FICHIER_liste(sauvegarde_liste_initiale_des_X);
gGENERATION_D_UN_FICHIER_liste(sauvegarde_liste_initiale_des_Y);
gGENERATION_D_UN_FICHIER_liste(sauvegarde_liste_initiale_des_Z);
/* Definition en memoire des fichiers de sauvegarde des coordonnees cartesiennes. */
#define ELEMENT_DU_FICHIER_SAUVEGARDE_LISTE_X(index) \
gELEMENT_DU_FICHIER(sauvegarde_liste_initiale_des_X,index)
#define ELEMENT_DU_FICHIER_SAUVEGARDE_LISTE_Y(index) \
gELEMENT_DU_FICHIER(sauvegarde_liste_initiale_des_Y,index)
#define ELEMENT_DU_FICHIER_SAUVEGARDE_LISTE_Z(index) \
gELEMENT_DU_FICHIER(sauvegarde_liste_initiale_des_Z,index)
/* Acces a un element courant des fichiers sauvegarde des coordonnees cartesiennes. */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* M A C R O S U T I L E S : */
/* */
/*************************************************************************************************************************************/
#define TEMPS \
DIVZ(FLOT(SOUS(iteration_courante,PREMIERE_ITERATION_D_UN_Komp)) \
,FLOT(SOUS(nombre_d_iterations_d_optimisation,PREMIERE_ITERATION_D_UN_Komp)) \
) \
/* Simulation d'un temps dans [0,1]. */ \
/* */ \
/* Le 20080301193036 'DIVI(...)' a ete remplace par 'DIVZ(...)' pour traiter le cas ou */ \
/* il n'y a qu'une seule iteration... */
#define PERTURBATION_ALEATOIRE(delta_initial,delta_final) \
MUL2(SOUS(perturbation_aleatoire,COORDONNEE_BARYCENTRIQUE_CENTRALE) \
,BARY(delta_initial,delta_final,temps) \
) \
/* Amplitude de la perturbation isotrope d'une coordonnee (variant avec le temps...). */ \
/* */ \
/* On rappelle la definition de 'BARY(...)' : */ \
/* */ \
/* BARY(initial,final,temps) = [(1-temps).initial] + [(temps-0).final] */ \
/* */
#define NOMBRE_MAXIMAL_DE_TENTATIVES_DE_PERTURBATION \
CENT \
/* Introduit le 20080303153155... */
#define EDITER_LE_MESSAGE_DE_DEPASSEMENT_DES_TENTATIVES_DE_PERTURBATION \
VRAI \
/* Introduit le 20120903143738... */
#define PERTURBATION_D_UNE_COORDONNEE(Coordonnee,delta_initial,delta_final,minimum,maximum,periodiser,negatif,positif) \
/* Le 20080303151721, toutes les variables "coordonnee..." sont devenues "Coordonnee..." */ \
/* a cause du 'PRINT_ATTENTION(...)' ci-apres qui edite le mot "coordonnee"... */ \
Bblock \
DEFV(Int,INIT(compteur_de_tentatives_de_perturbation,ZERO)); \
DEFV(Logical,INIT(perturber,VRAI)); \
DEFV(Float,INIT(Coordonnee_perturbee,FLOT__UNDEF)); \
DEFV(Float,INIT(temps,TEMPS)); \
\
Tant(IL_FAUT(perturber)) \
Bblock \
DEFV(Float,INIT(perturbation_aleatoire,FLOT__UNDEF)); \
GENERATION_D_UNE_VALEUR(perturbation_aleatoire \
,COND(IL_FAUT(positif) \
,COORDONNEE_BARYCENTRIQUE_CENTRALE \
,COORDONNEE_BARYCENTRIQUE_MINIMALE \
) \
,COND(IL_FAUT(negatif) \
,COORDONNEE_BARYCENTRIQUE_CENTRALE \
,COORDONNEE_BARYCENTRIQUE_MAXIMALE \
) \
); \
EGAL(Coordonnee_perturbee,ADD2(Coordonnee,PERTURBATION_ALEATOIRE(delta_initial,delta_final))); \
/* Perturbation de la coordonnee courante... */ \
\
Test(IFOU(IL_FAUT(negatif),IL_FAUT(positif))) \
Bblock \
EGAL(Coordonnee_perturbee,TRON(Coordonnee_perturbee,minimum,maximum)); \
/* Il est necessaire de faire ce 'TRON(...)' car, sinon, a force de croitre (ou de */ \
/* decroitre), une certaine coordonnee peut sortir definitivement de [minimum,maximum], */ \
/* d'ou alors une boucle infinie ci-apres... */ \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
\
Test(IL_FAUT(periodiser)) \
Bblock \
EGAL(Coordonnee_perturbee,MODF(Coordonnee_perturbee,minimum,maximum)); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
\
INCR(compteur_de_tentatives_de_perturbation,I); \
\
Test(IFET(IFEXff(Coordonnee_perturbee,minimum,maximum) \
,IFLT(compteur_de_tentatives_de_perturbation,nombre_maximal_de_tentatives_de_perturbation) \
) \
) \
Bblock \
/* Les coordonnees hors du segment [minimum,maximum] sont rejetees. */ \
Eblock \
ATes \
Bblock \
Test(IFGE(compteur_de_tentatives_de_perturbation,nombre_maximal_de_tentatives_de_perturbation)) \
Bblock \
Test(IL_FAUT(editer_le_message_de_depassement_des_tentatives_de_perturbation)) \
/* Possibilite introduite le 20120903143738... */ \
Bblock \
PRINT_ATTENTION("trop de tentatives de perturbation d'une coordonnee"); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
\
EGAL(Coordonnee,Coordonnee_perturbee); \
EGAL(perturber,FAUX); \
/* On s'arrete sur la premiere coordonnee perturbee situee dans l'ecran... */ \
Eblock \
ETes \
Eblock \
ETan \
Eblock \
/* Perturbation isotrope d'une coordonnee... */
#define DISTANCE_MINIMALE(distance_minimale) \
Bblock \
DEFV(Int,INIT(index_i,UNDEF)); \
DEFV(Int,INIT(index_j,UNDEF)); \
EGAL(distance_minimale,F_INFINI); \
\
DoIn(index_i,PREMIER_ELEMENT_D_UN_FICHIER,DERNIER_ELEMENT_D_UN_FICHIER,I) \
Bblock \
DoIn(index_j,PREMIER_ELEMENT_D_UN_FICHIER,DERNIER_ELEMENT_D_UN_FICHIER,I) \
Bblock \
Test(IFGT(index_i,index_j)) \
Bblock \
DEFV(Float,INIT(distance_courante \
,RdisF3D(ELEMENT_DU_FICHIER_LISTE_X(index_i) \
,ELEMENT_DU_FICHIER_LISTE_Y(index_i) \
,ELEMENT_DU_FICHIER_LISTE_Z(index_i) \
,ELEMENT_DU_FICHIER_LISTE_X(index_j) \
,ELEMENT_DU_FICHIER_LISTE_Y(index_j) \
,ELEMENT_DU_FICHIER_LISTE_Z(index_j) \
) \
) \
); \
EGAL(distance_minimale,MIN2(distance_minimale,distance_courante)); \
/* Recherche de la distance minimale courante du nuage de points. On notera que les */ \
/* distances sont calculees de facon euclidienne dans l'espace R^3 et non pas suivant */ \
/* les geodesiques d'une quelconque surface puisqu'en effet nulle part n'est definie */ \
/* une surface (sauf dans le cas tres particulier -cas par defaut- ou 'rho=constante', */ \
/* auquel cas, il s'agit d'une sphere...). */ \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
EDoI \
Eblock \
EDoI \
Eblock \
/* Calcul de la distance minimale a un instant donne. */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* O P T I M I S A T I O N E N C O O R D O N N E E S S P H E R I Q U E S */
/* D E S D I S T A N C E S E N T R E D E S P O I N T S */
/* E N C O O R D O N N E E S S P H E R I Q U E S ( O U C A R T E S I E N N E S ) */
/* P A R M A X I M I S A T I O N D E L A D I S T A N C E M I N I M A L E : */
/* */
/*************************************************************************************************************************************/
BCommande(nombre_d_arguments,arguments)
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
#include xrv/ARITHMET.22.I"
#include xci/valeurs.03.I"
DEFV(Logical,INIT(utiliser_les_coordonnees_cartesiennes_en_entree,UTILISER_LES_COORDONNEES_CARTESIENNES_EN_ENTREE));
DEFV(Logical,INIT(utiliser_les_coordonnees_cartesiennes_en_sortie,UTILISER_LES_COORDONNEES_CARTESIENNES_EN_SORTIE));
/* Afin de choisir entre les coordonnees cartesiennes ('VRAI') et les coordonnees */
/* spheriques ('VRAI') en entree et en sortie... */
DEFV(Int,INIT(nombre_d_iterations_d_optimisation,NOMBRE_D_ITERATIONS_D_OPTIMISATION));
/* Nombre d'iterations maximum... */
DEFV(Logical,INIT(s_arreter_avant_la_fin,S_ARRETER_AVANT_LA_FIN));
DEFV(Int,INIT(nombre_d_iterations_d_optimisation_au_bout_duquel_s_arreter
,NOMBRE_D_ITERATIONS_D_OPTIMISATION_AU_BOUT_DUQUEL_S_ARRETER
)
);
/* Faut-il s'arreter avant la fin et si oui, au bout de combien d'iterations ? Ceci a ete */
/* introduit le 20011107161207 afin de permettre la realisation des animations decrites */
/* par 'v $xiirs/.PSPH.31.1.$u optimise.01'. Il est en effet important que pour toutes */
/* les images d'une visualisation de la dynamique du processus, l'echelle de 'temps' soit la */
/* meme ; et pour ce faire, il est essentiel que 'nombre_d_iterations_d_optimisation' soit */
/* le meme pour toutes ces images ; il convient donc d'introduire un nouveau test d'arret, */
/* d'ou 'nombre_d_iterations_d_optimisation_au_bout_duquel_s_arreter'... */
DEFV(Int,INIT(nombre_maximal_de_tentatives_par_iteration,NOMBRE_MAXIMAL_DE_TENTATIVES_PAR_ITERATION));
/* Pour chaque iteration, il est possible de faire plusieurs tentatives de suite dans le */
/* cas ou elles sont infructueuses (c'est-a-dire n'augmente pas la distance minimale). */
/* La valeur par defaut est choisie le 20011110102959 pour assurer la compatibilite avec */
/* utilisations anterieures... */
/* */
/* On notera qu'une valeur differente de la valeur par defaut ('UN') peut rentrer en */
/* conflit avec les parametres de probabilite 'probabilite_de_refuser_une_bonne_solution' */
/* et 'probabilite_d_accepter_une_mauvaise_solution', puisque l'espoir avec ce parametre */
/* 'nombre_maximal_de_tentatives_par_iteration' est finalement de ne trouver, pour chaque */
/* iteration, qu'une bonne solution... */
DEFV(Int,INIT(nombre_maximal_de_tentatives_de_perturbation,NOMBRE_MAXIMAL_DE_TENTATIVES_DE_PERTURBATION));
/* Introduit le 20120903132830 sous la forme d'une variable afin de pouvoir l'augmenter, */
/* par exemple, dans le cas ou les parametres "rdi=..." et "rdf=..." sont utilises avec */
/* des valeurs non nulles... */
DEFV(Logical,INIT(editer_le_message_de_depassement_des_tentatives_de_perturbation
,EDITER_LE_MESSAGE_DE_DEPASSEMENT_DES_TENTATIVES_DE_PERTURBATION
)
);
/* Introduit le 20120903143738... */
DEFV(Float,INIT(rho__minimum,RHO__MINIMUM));
DEFV(Float,INIT(rho__maximum,RHO__MAXIMUM));
DEFV(Float,INIT(rho__delta_initial,RHO__DELTA_INITIAL));
DEFV(Float,INIT(rho__delta_final,RHO__DELTA_FINAL));
DEFV(Logical,INIT(rho__delta_doit_etre_negatif,RHO__DELTA_DOIT_ETRE_NEGATIF));
DEFV(Logical,INIT(rho__delta_doit_etre_positif,RHO__DELTA_DOIT_ETRE_POSITIF));
/* Definition de la coordonnee spherique 'rho' initialise tel que rho=constante a priori, */
/* c'est-a-dire tel que les points {X,Y,Z} soient sur une sphere de rayon 'rho'... */
DEFV(Float,INIT(phi__minimum,PHI__MINIMUM));
DEFV(Float,INIT(phi__maximum,PHI__MAXIMUM));
DEFV(Float,INIT(phi__delta_initial,PHI__DELTA_INITIAL));
DEFV(Float,INIT(phi__delta_final,PHI__DELTA_FINAL));
DEFV(Logical,INIT(phi__delta_doit_etre_negatif,PHI__DELTA_DOIT_ETRE_NEGATIF));
DEFV(Logical,INIT(phi__delta_doit_etre_positif,PHI__DELTA_DOIT_ETRE_POSITIF));
/* Definition de la coordonnee spherique 'phi'. */
DEFV(Float,INIT(theta_minimum,THETA_MINIMUM));
DEFV(Float,INIT(theta_maximum,THETA_MAXIMUM));
DEFV(Float,INIT(theta_delta_initial,THETA_DELTA_INITIAL));
DEFV(Float,INIT(theta_delta_final,THETA_DELTA_FINAL));
DEFV(Logical,INIT(theta_delta_doit_etre_negatif,THETA_DELTA_DOIT_ETRE_NEGATIF));
DEFV(Logical,INIT(theta_delta_doit_etre_positif,THETA_DELTA_DOIT_ETRE_POSITIF));
/* Definition de la coordonnee spherique 'theta'. */
DEFV(Float,INIT(plus_petite_distance_minimale_autorisee,PLUS_PETITE_DISTANCE_MINIMALE_AUTORISEE));
DEFV(Float,INIT(plus_grande_distance_minimale_autorisee,PLUS_GRANDE_DISTANCE_MINIMALE_AUTORISEE));
/* Definitions des bornes de la distance minimale (introduites le 20150616133828). */
DEFV(Float,INIT(probabilite_de_perturber_un_point,PROBABILITE_DE_PERTURBER_UN_POINT));
/* Probabilite de perturber le point courant... */
DEFV(Float,INIT(probabilite_de_refuser_une_bonne_solution,PROBABILITE_DE_REFUSER_UNE_BONNE_SOLUTION));
/* Probabilite de refuser une bonne solution... */
DEFV(Float,INIT(probabilite_d_accepter_une_mauvaise_solution,PROBABILITE_D_ACCEPTER_UNE_MAUVAISE_SOLUTION));
/* Probabilite d'accepter une mauvaise solution... Cette valeur nulle par defaut est */
/* justifiee par ce qui est decrit le 20011111085109 lors de l'utilisation de ces diverses */
/* probabilites... */
DEFV(Logical,INIT(editer_les_distances_minimales_initiale_et_finale,EDITER_LES_DISTANCES_MINIMALES_INITIALE_ET_FINALE));
/* Doit-on editer les distances minimales initiale et finale pour voir l'amelioration ? */
DEFV(Logical,INIT(avoir_un_point_fixe,AVOIR_UN_POINT_FIXE));
DEFV(Int,INIT(index_du_point_fixe,INDEX_DU_POINT_FIXE));
/* Doit-il y avoir un point fixe et si oui, lequel ? Ceci a ete introduit le 20011107135709 */
/* afin de "stabiliser" les animations decrites par 'v $xiirs/.PSPH.31.1.$u optimise.01'. */
DEFV(Int,INIT(iteration_courante,UNDEF));
/* Index divers... */
DEFV(Float,INIT(distance_minimale_avant_la_perturbation,FLOT__UNDEF));
DEFV(Float,INIT(distance_minimale_apres_la_perturbation,FLOT__UNDEF));
/* Distances minimales avant et apres une tentative de perturbation... */
DEFV(Logical,INIT(la_distance_minimale_vient_d_augmenter,FAUX));
/* Pour optimiser le calcul des distances... */
/*..............................................................................................................................*/
#include xrv/champs_5.1A.I"
/* Ceci fut introduit le 20070103174132... */
GET_ARGUMENTS_(nombre_d_arguments
,BLOC(PROCESS_ARGUMENT_I("nombre_elements=""ne=",nombre_d_elements
,BLOC(VIDE;)
,BLOC(Bblock
PRINT_AVERTISSEMENT("'ne=' doit etre defini avant toute entree de fichiers");
Eblock
)
);
PROCESS_ARGUMENTS_DE_DEFINITION_DES_FICHIERS_01;
GET_ARGUMENT_L("cartesiennesA=""cartesienneA=""cA=",utiliser_les_coordonnees_cartesiennes_en_entree);
GET_ARGUMENT_N("spheriquesA=""spheriqueA=""sA=",utiliser_les_coordonnees_cartesiennes_en_entree);
/* Les parametres "spherique..." furent introduit le 20080229171247 et les abbreviations */
/* le 20080307090513... */
GET_ARGUMENT_L("cartesiennesR=""cartesienneR=""cR=",utiliser_les_coordonnees_cartesiennes_en_sortie);
GET_ARGUMENT_N("spheriquesR=""spheriqueR=""sR=",utiliser_les_coordonnees_cartesiennes_en_sortie);
/* Les parametres "spherique..." furent introduit le 20080229171247 et les abbreviations */
/* le 20080307090513... */
PROKESF_ARGUMENT_FICHIER("LISTE_RHO="
,fichier_LISTE_RHO_
,liste_initiale_des_RHO_
,RHO__IMPLICITE
,lTRANSFORMAT_0d
,iGENERATION_D_UN_FICHIER
);
PROKESF_ARGUMENT_FICHIER("LISTE_PHI="
,fichier_LISTE_PHI_
,liste_initiale_des_PHI_
,PHI__IMPLICITE
,lTRANSFORMAT_0d
,iGENERATION_D_UN_FICHIER
);
PROKESF_ARGUMENT_FICHIER("LISTE_THETA="
,fichier_LISTE_THETA
,liste_initiale_des_THETA
,THETA_IMPLICITE
,lTRANSFORMAT_0d
,iGENERATION_D_UN_FICHIER
);
PROKESF_ARGUMENT_FICHIER("LISTE_X="
,fichier_LISTE_X
,liste_initiale_des_X
,X_IMPLICITE
,lTRANSFORMAT_0d
,iGENERATION_D_UN_FICHIER
);
PROKESF_ARGUMENT_FICHIER("LISTE_Y="
,fichier_LISTE_Y
,liste_initiale_des_Y
,Y_IMPLICITE
,lTRANSFORMAT_0d
,iGENERATION_D_UN_FICHIER
);
PROKESF_ARGUMENT_FICHIER("LISTE_Z="
,fichier_LISTE_Z
,liste_initiale_des_Z
,Z_IMPLICITE
,lTRANSFORMAT_0d
,iGENERATION_D_UN_FICHIER
);
GET_ARGUMENT_I("graine=""g=",graine_du_generateur_d_evenements);
GET_ARGUMENT_L("affiner_rdn=",rdnIFnD_____affiner_la_generation);
GET_ARGUMENT_L("iterer_rdn=",rdnIFnD_____iterer_la_generation);
GET_ARGUMENT_I("iterations=",nombre_d_iterations_d_optimisation);
GET_ARGUMENT_L("avant_la_fin=",s_arreter_avant_la_fin);
GET_ARGUMENT_I("fin=",nombre_d_iterations_d_optimisation_au_bout_duquel_s_arreter);
GET_ARGUMENT_I("tentatives=",nombre_maximal_de_tentatives_par_iteration);
GET_ARGUMENT_I("tentatives_de_perturbation=""tp=",nombre_maximal_de_tentatives_de_perturbation);
/* Parametres introduits le 20120903132830... */
GET_ARGUMENT_L("message_trop_de_perturbations=""mtp="
,editer_le_message_de_depassement_des_tentatives_de_perturbation
);
/* Parametres introduits le 20120903143738... */
GET_ARGUMENT_F("rm=",rho__minimum);
GET_ARGUMENT_F("rM=",rho__maximum);
GET_ARGUMENT_F("rdi=",rho__delta_initial);
GET_ARGUMENT_F("rdf=",rho__delta_final);
GET_ARGUMENT_L("rdn=",rho__delta_doit_etre_negatif);
GET_ARGUMENT_L("rdp=",rho__delta_doit_etre_positif);
GET_ARGUMENT_F("pm=",phi__minimum);
GET_ARGUMENT_F("pM=",phi__maximum);
GET_ARGUMENT_F("pdi=",phi__delta_initial);
GET_ARGUMENT_F("pdf=",phi__delta_final);
GET_ARGUMENT_L("pdn=",phi__delta_doit_etre_negatif);
GET_ARGUMENT_L("pdp=",phi__delta_doit_etre_positif);
GET_ARGUMENT_F("tm=",theta_minimum);
GET_ARGUMENT_F("tM=",theta_maximum);
GET_ARGUMENT_F("tdi=",theta_delta_initial);
GET_ARGUMENT_F("tdf=",theta_delta_final);
GET_ARGUMENT_L("tdn=",theta_delta_doit_etre_negatif);
GET_ARGUMENT_L("tdp=",theta_delta_doit_etre_positif);
GET_ARGUMENT_F("plus_petite_distance_minimale=""ppdm=",plus_petite_distance_minimale_autorisee);
GET_ARGUMENT_F("plus_grande_distance_minimale=""pgdm=",plus_grande_distance_minimale_autorisee);
/* Parametres introduits le 20150616133828... */
GET_ARGUMENT_F("probabilite_perturber_point=""ppp=",probabilite_de_perturber_un_point);
GET_ARGUMENT_F("probabilite_refuser_bonne_solution=""prbs=",probabilite_de_refuser_une_bonne_solution);
GET_ARGUMENT_F("probabilite_accepter_mauvaise_solution=""pams=",probabilite_d_accepter_une_mauvaise_solution);
GET_ARGUMENT_L("point_fixe=""pf=",avoir_un_point_fixe);
GET_ARGUMENT_I("index_point_fixe=""Ipf=",index_du_point_fixe);
GET_ARGUMENT_L("lister=""editer=""lister_initiale_finale=""liif=""editer_initiale_finale=""edif="
,editer_les_distances_minimales_initiale_et_finale
);
/* Parametres completes par "lister_initiale_finale=",... le 20150208084428... */
PROCESS_ARGUMENTS_DE_PARAMETRAGE_DE_LA_GENERATION_DE_SUITE_DE_VALEURS_3;
/* Cette procedure fut introduite le 20070103174132... */
PROCESS_ARGUMENTS_DE_PARAMETRAGE_DE_LA_GENERATION_DE_SUITE_DE_VALEURS_1;
/* Cette procedure fut introduite le 20061226192626... */
)
);
iGENERATION_D_UN_FICHIER(sauvegarde_liste_initiale_des_RHO_,FLOT__UNDEF);
iGENERATION_D_UN_FICHIER(sauvegarde_liste_initiale_des_PHI_,FLOT__UNDEF);
iGENERATION_D_UN_FICHIER(sauvegarde_liste_initiale_des_THETA,FLOT__UNDEF);
iGENERATION_D_UN_FICHIER(sauvegarde_liste_initiale_des_X,FLOT__UNDEF);
iGENERATION_D_UN_FICHIER(sauvegarde_liste_initiale_des_Y,FLOT__UNDEF);
iGENERATION_D_UN_FICHIER(sauvegarde_liste_initiale_des_Z,FLOT__UNDEF);
/* Ceci est rendu obligatoire par l'allocation dynamique de la memoire (le 20060214192917). */
Test(IFLT(probabilite_de_perturber_un_point,INVE(FLOT(nombre_d_elements))))
Bblock
PRINT_ATTENTION("lors de certaines iterations, aucun point ne sera perturbe");
/* En effet, logiquement, il faut que cette probabilite soit superieure ou egale a */
/* l'inverse du nombre de particules... */
Eblock
ATes
Bblock
Eblock
ETes
DoIn(index,PREMIER_ELEMENT_D_UN_FICHIER,DERNIER_ELEMENT_D_UN_FICHIER,I)
Bblock
Test(IL_FAUT(utiliser_les_coordonnees_cartesiennes_en_entree))
Bblock
EGAL(ELEMENT_DU_FICHIER_LISTE_RHO_(index)
,Rho_3D(ELEMENT_DU_FICHIER_LISTE_X(index)
,ELEMENT_DU_FICHIER_LISTE_Y(index)
,ELEMENT_DU_FICHIER_LISTE_Z(index)
)
);
EGAL(ELEMENT_DU_FICHIER_LISTE_PHI_(index)
,Phi_3D(ELEMENT_DU_FICHIER_LISTE_X(index)
,ELEMENT_DU_FICHIER_LISTE_Y(index)
,ELEMENT_DU_FICHIER_LISTE_Z(index)
)
);
EGAL(ELEMENT_DU_FICHIER_LISTE_THETA(index)
,Theta_3D(ELEMENT_DU_FICHIER_LISTE_X(index)
,ELEMENT_DU_FICHIER_LISTE_Y(index)
,ELEMENT_DU_FICHIER_LISTE_Z(index)
)
);
/* Et conversion cartesienne --> spherique... */
Eblock
ATes
Bblock
EGAL(ELEMENT_DU_FICHIER_LISTE_X(index)
,Xcartesienne_3D(ELEMENT_DU_FICHIER_LISTE_RHO_(index)
,ELEMENT_DU_FICHIER_LISTE_PHI_(index)
,ELEMENT_DU_FICHIER_LISTE_THETA(index)
)
);
EGAL(ELEMENT_DU_FICHIER_LISTE_Y(index)
,Ycartesienne_3D(ELEMENT_DU_FICHIER_LISTE_RHO_(index)
,ELEMENT_DU_FICHIER_LISTE_PHI_(index)
,ELEMENT_DU_FICHIER_LISTE_THETA(index)
)
);
EGAL(ELEMENT_DU_FICHIER_LISTE_Z(index)
,Zcartesienne_3D(ELEMENT_DU_FICHIER_LISTE_RHO_(index)
,ELEMENT_DU_FICHIER_LISTE_PHI_(index)
,ELEMENT_DU_FICHIER_LISTE_THETA(index)
)
);
/* Et conversion spherique --> cartesienne... */
Eblock
ETes
Eblock
EDoI
Komp(iteration_courante
,COND(IL_NE_FAUT_PAS(s_arreter_avant_la_fin)
,nombre_d_iterations_d_optimisation
,MIN2(nombre_d_iterations_d_optimisation_au_bout_duquel_s_arreter,nombre_d_iterations_d_optimisation)
)
)
Bblock
DEFV(Logical,INIT(on_a_trouve_une_bonne_perturbation,FAUX));
DEFV(Int,INIT(nombre_de_tentatives_effectuees,ZERO));
/* On n'a pas encore trouve une bonne perturbation... */
Tant(IFET(EST_FAUX(on_a_trouve_une_bonne_perturbation)
,IFLT(nombre_de_tentatives_effectuees,nombre_maximal_de_tentatives_par_iteration)
)
)
Bblock
DEFV(Float,INIT(probabilite_courante,FLOT__UNDEF));
/* Probabilite destinee a choisir les points, les mauvaises solutions,... */
DoIn(index,PREMIER_ELEMENT_D_UN_FICHIER,DERNIER_ELEMENT_D_UN_FICHIER,I)
Bblock
EGAL(ELEMENT_DU_FICHIER_SAUVEGARDE_LISTE_RHO_(index),ELEMENT_DU_FICHIER_LISTE_RHO_(index));
EGAL(ELEMENT_DU_FICHIER_SAUVEGARDE_LISTE_PHI_(index),ELEMENT_DU_FICHIER_LISTE_PHI_(index));
EGAL(ELEMENT_DU_FICHIER_SAUVEGARDE_LISTE_THETA(index),ELEMENT_DU_FICHIER_LISTE_THETA(index));
EGAL(ELEMENT_DU_FICHIER_SAUVEGARDE_LISTE_X(index),ELEMENT_DU_FICHIER_LISTE_X(index));
EGAL(ELEMENT_DU_FICHIER_SAUVEGARDE_LISTE_Y(index),ELEMENT_DU_FICHIER_LISTE_Y(index));
EGAL(ELEMENT_DU_FICHIER_SAUVEGARDE_LISTE_Z(index),ELEMENT_DU_FICHIER_LISTE_Z(index));
/* Sauvegarde de l'etat courant des points {{rho,phi,theta},{X,Y,Z}}. */
Eblock
EDoI
Test(EST_FAUX(la_distance_minimale_vient_d_augmenter))
Bblock
Test(IFEQ(iteration_courante,PREMIERE_ITERATION_D_UN_Komp))
Bblock
DISTANCE_MINIMALE(distance_minimale_avant_la_perturbation);
/* Recherche de la distance minimale avant la perturbation. */
Eblock
ATes
Bblock
/* Dans ce cas 'distance_minimale_avant' est encore valide (calculee lors d'une iteration */
/* anterieure...). */
Eblock
ETes
Eblock
ATes
Bblock
EGAL(distance_minimale_avant_la_perturbation,distance_minimale_apres_la_perturbation);
Eblock
ETes
Test(IFET(IL_FAUT(editer_les_distances_minimales_initiale_et_finale)
,IFEQ(iteration_courante,PREMIERE_ITERATION_D_UN_Komp)
)
)
Bblock
CAL3(Prme1("distance minimale initiale=%f\n",distance_minimale_avant_la_perturbation));
Eblock
ATes
Bblock
Eblock
ETes
DoIn(index,PREMIER_ELEMENT_D_UN_FICHIER,DERNIER_ELEMENT_D_UN_FICHIER,I)
Bblock
Test(IFOU(IL_NE_FAUT_PAS(avoir_un_point_fixe)
,IFET(IL_FAUT(avoir_un_point_fixe)
,IFNE(index,index_du_point_fixe)
)
)
)
Bblock
GENERATION_D_UNE_VALEUR(probabilite_courante,PROBABILITE_NULLE,PROBABILITE_UNITE);
Test(IFLT(probabilite_courante,probabilite_de_perturber_un_point))
Bblock
DEFV(Float,INIT(Rho__perturbe,ELEMENT_DU_FICHIER_LISTE_RHO_(index)));
DEFV(Float,INIT(Phi__perturbe,ELEMENT_DU_FICHIER_LISTE_PHI_(index)));
DEFV(Float,INIT(Theta_perturbe,ELEMENT_DU_FICHIER_LISTE_THETA(index)));
PERTURBATION_D_UNE_COORDONNEE(Rho__perturbe
,rho__delta_initial,rho__delta_final
,rho__minimum,rho__maximum
,FAUX
,rho__delta_doit_etre_negatif
,rho__delta_doit_etre_positif
);
PERTURBATION_D_UNE_COORDONNEE(Phi__perturbe
,phi__delta_initial,phi__delta_final
,phi__minimum,phi__maximum
,FAUX
,phi__delta_doit_etre_negatif
,phi__delta_doit_etre_positif
);
PERTURBATION_D_UNE_COORDONNEE(Theta_perturbe
,theta_delta_initial,theta_delta_final
,theta_minimum,theta_maximum
,FAUX
,theta_delta_doit_etre_negatif
,theta_delta_doit_etre_positif
);
/* ATTENTION : je note le 20150615161900 que les coordonnees sont perturbees dans leur */
/* version spherique. Ces perturbations sont donc conditionnees par : */
/* */
/* {phi__delta_initial,phi__delta_final,phi__minimum,phi__maximum} = {1/5,1/5 ,0,2.pi} */
/* {theta_delta_initial,theta_delta_final,theta_minimum,theta_maximum} = {1/2,1/10, 0,pi} */
/* */
/* et surtout par : */
/* */
/* {rho__delta_initial,rho__delta_final,rho__minimum,rho__maximum} = {0,0,1,1} */
/* */
/* qui sont initialisees pour une sphere de rayon constant (egal a 1)... */
EGAL(ELEMENT_DU_FICHIER_LISTE_RHO_(index),Rho__perturbe);
EGAL(ELEMENT_DU_FICHIER_LISTE_PHI_(index),Phi__perturbe);
EGAL(ELEMENT_DU_FICHIER_LISTE_THETA(index),Theta_perturbe);
/* Perturbation aleatoire des points. */
EGAL(ELEMENT_DU_FICHIER_LISTE_X(index)
,Xcartesienne_3D(ELEMENT_DU_FICHIER_LISTE_RHO_(index)
,ELEMENT_DU_FICHIER_LISTE_PHI_(index)
,ELEMENT_DU_FICHIER_LISTE_THETA(index)
)
);
EGAL(ELEMENT_DU_FICHIER_LISTE_Y(index)
,Ycartesienne_3D(ELEMENT_DU_FICHIER_LISTE_RHO_(index)
,ELEMENT_DU_FICHIER_LISTE_PHI_(index)
,ELEMENT_DU_FICHIER_LISTE_THETA(index)
)
);
EGAL(ELEMENT_DU_FICHIER_LISTE_Z(index)
,Zcartesienne_3D(ELEMENT_DU_FICHIER_LISTE_RHO_(index)
,ELEMENT_DU_FICHIER_LISTE_PHI_(index)
,ELEMENT_DU_FICHIER_LISTE_THETA(index)
)
);
/* Et conversion spherique --> cartesienne... */
Eblock
ATes
Bblock
Eblock
ETes
Eblock
ATes
Bblock
Eblock
ETes
Eblock
EDoI
DISTANCE_MINIMALE(distance_minimale_apres_la_perturbation);
/* Recherche de la distance minimale apres la perturbation. */
GENERATION_D_UNE_VALEUR(probabilite_courante,PROBABILITE_NULLE,PROBABILITE_UNITE);
Test(IFET(IFINff(distance_minimale_apres_la_perturbation
,plus_petite_distance_minimale_autorisee
,plus_grande_distance_minimale_autorisee
)
,IFOU(IFET(IFLT(distance_minimale_apres_la_perturbation
,distance_minimale_avant_la_perturbation
)
,IFLT(probabilite_courante
,probabilite_d_accepter_une_mauvaise_solution
)
)
,IFET(IFGE(distance_minimale_apres_la_perturbation
,distance_minimale_avant_la_perturbation
)
,IFGE(probabilite_courante
,probabilite_de_refuser_une_bonne_solution
)
)
)
)
)
/* On cherche a maximiser la distance minimale. On notera le test 'IFLT(...)' (alors que la */
/* logique voudrait 'IFLE(...)') a cause du cas ou les points occuperaient initialement tous */
/* la meme position (d'ou : distance_minimale_avant=0) : dans ce cas, comme un certain */
/* nombre de points ne sont pas perturbes, on a donc distance_minimale_apres=0, d'ou avec */
/* avec le test 'IFLE(...)' le rejet de cette solution ; ainsi, on risque d'etre bloque */
/* indefiniment puisque l'on restaure alors l'etat precedent... */
/* */
/* Le 20150616133828 a ete introduite la posssibilite de contraindre la distance minimale */
/* a rester dans un segment donne [plus_petite_distance...,plus_grande_distance...]. */
Bblock
EGAL(on_a_trouve_une_bonne_perturbation,VRAI);
/* On va pouvoir la boucle courante 'Tant(...)' des tentatives... */
Eblock
ATes
Bblock
Eblock
ETes
Test(EST_FAUX(on_a_trouve_une_bonne_perturbation))
/* ATTENTION, jusqu'au 20011110122102, il y avait ici : */
/* */
/* Test(IFOU(IFLT(distance_minimale_apres_la_perturbation */
/* ,distance_minimale_avant_la_perturbation */
/* ) */
/* ,IFLT(probabilite_courante */
/* ,probabilite_d_accepter_une_mauvaise_solution */
/* ) */
/* ) */
/* ) */
/* */
/* Or cela est faux et s'est manifeste avec l'introduction de l'option "tentatives=". D'ou */
/* cette nouvelle version. En fait, le 20011111085109, j'ai compris la source du probleme. */
/* En effet, il semble qu'il y ait confusion entre le fait de "accepter une mauviase */
/* solution" et celui de "refuser une bonne" ; c'est en fait ce dernier cas qui etait */
/* implemente, mais avec la terminologie 'probabilite_d_accepter_une_mauvaise_solution' */
/* qui etait mauvaise. J'ai donc, a cette date, change cette terminologie incorrecte en */
/* 'probabilite_de_refuser_une_bonne_solution' (en lui conservant sa probabilite par */
/* defaut) et introduit correctement 'probabilite_d_accepter_une_mauvaise_solution' en */
/* lui donnant une probabilite par defaut nulle afin de ne pas compromettre la compatibilite */
/* avec les realisations anterieures... */
Bblock
EGAL(la_distance_minimale_vient_d_augmenter,FAUX);
/* L'etat anterieur est inchange... */
DoIn(index,PREMIER_ELEMENT_D_UN_FICHIER,DERNIER_ELEMENT_D_UN_FICHIER,I)
Bblock
EGAL(ELEMENT_DU_FICHIER_LISTE_RHO_(index),ELEMENT_DU_FICHIER_SAUVEGARDE_LISTE_RHO_(index));
EGAL(ELEMENT_DU_FICHIER_LISTE_PHI_(index),ELEMENT_DU_FICHIER_SAUVEGARDE_LISTE_PHI_(index));
EGAL(ELEMENT_DU_FICHIER_LISTE_THETA(index),ELEMENT_DU_FICHIER_SAUVEGARDE_LISTE_THETA(index));
EGAL(ELEMENT_DU_FICHIER_LISTE_X(index),ELEMENT_DU_FICHIER_SAUVEGARDE_LISTE_X(index));
EGAL(ELEMENT_DU_FICHIER_LISTE_Y(index),ELEMENT_DU_FICHIER_SAUVEGARDE_LISTE_Y(index));
EGAL(ELEMENT_DU_FICHIER_LISTE_Z(index),ELEMENT_DU_FICHIER_SAUVEGARDE_LISTE_Z(index));
/* Restauration de l'etat anterieur {{rho,phi,theta},{X,Y,Z}} lorsqu'il y a degradation */
/* des performances, c'est-a-dire lorsque la distance minimale n'augmente pas... */
Eblock
EDoI
Eblock
ATes
Bblock
EGAL(la_distance_minimale_vient_d_augmenter,VRAI);
/* On conserve un etat perturbe qui maximise la distance minimale... */
Eblock
ETes
Test(IFET(IL_FAUT(editer_les_distances_minimales_initiale_et_finale)
,IFEQ(iteration_courante,nombre_d_iterations_d_optimisation)
)
)
Bblock
CAL3(Prme1("distance minimale finale..=%f\n",distance_minimale_avant_la_perturbation));
/* ATTENTION : c'est la distance minimale a l'avant-derniere iteration qui est editee car, */
/* en effet, il n'est pas sur que 'distance_minimale_apres' etait maximale... */
Eblock
ATes
Bblock
Eblock
ETes
INCR(nombre_de_tentatives_effectuees,I);
/* Et une tentative de plus... */
Eblock
ETan
Eblock
EKom
DoIn(index
,PREMIER_ELEMENT_D_UN_FICHIER
,DERNIER_ELEMENT_D_UN_FICHIER
,I
)
Bblock
Test(IL_FAUT(utiliser_les_coordonnees_cartesiennes_en_sortie))
Bblock
CAL2(Prin0(" X="));
EDITION_DANS_gOPERATION_SUR_LES_FICHIERS(ELEMENT_DU_FICHIER_LISTE_X(index));
CAL2(Prin0(" Y="));
EDITION_DANS_gOPERATION_SUR_LES_FICHIERS(ELEMENT_DU_FICHIER_LISTE_Y(index));
CAL2(Prin0(" Z="));
EDITION_DANS_gOPERATION_SUR_LES_FICHIERS(ELEMENT_DU_FICHIER_LISTE_Z(index));
/* Edition du triplet {X,Y,Z}. */
Eblock
ATes
Bblock
CAL2(Prin0(" rho="));
EDITION_DANS_gOPERATION_SUR_LES_FICHIERS(ELEMENT_DU_FICHIER_LISTE_RHO_(index));
CAL2(Prin0(" phi="));
EDITION_DANS_gOPERATION_SUR_LES_FICHIERS(ELEMENT_DU_FICHIER_LISTE_PHI_(index));
CAL2(Prin0(" theta="));
EDITION_DANS_gOPERATION_SUR_LES_FICHIERS(ELEMENT_DU_FICHIER_LISTE_THETA(index));
/* Edition du triplet {rho,phi,theta}. */
Eblock
ETes
CAL2(Prin0("\n"));
/* ATTENTION : on notera bien l'espace qui est mis en bout de ligne (de meme celui qui */
/* a ete mis en debut de ligne precedemment, devant le "X=" par exemple) ; ceci est destine */
/* a faciliter la recuperation et la manipulation du fichier ainsi produit (par exemple, */
/* 'v $xiirs/.PSPH.21.1.$U Xx')... */
Eblock
EDoI
RETU_Commande;
Eblock
ECommande