/*************************************************************************************************************************************/
/* */
/* 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 U N I F O R 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.22$K' : */
/* */
/* Jean-Francois COLONNA (LACTAMME, 20150616151057). */
/* */
/*************************************************************************************************************************************/
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* 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
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* 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 NOMBRE_MAXIMAL_D_ELEMENTS_DANS_LE_FICHIER \
CENT_MILLE \
/* Definition du nombre maximal d'elements dans un fichier. */
#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 SORTIR_LES_COORDONNEES_OPTIMISEES \
VRAI
#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 ? */
#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). */ \
/* */ \
/* 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... */ \
/* */ \
/* Ce parametre est en fait un garde-fou destine a limiter le nombre des 'Tant(...)'s */ \
/* qui l'utilisent... */
#define NOMBRE_DE_PERIODES_DE_TEMPS \
UN \
/* Nombre de periode de temps pour calculer un temps d'interpolation periodise. */
#define UTILISER_L_INTERPOLATION_CUBIQUE \
FAUX \
/* Doit-on utiliser 'INTERPOLATION_CUBIQUE(...)' ('VRAI') ou 'INTERPOLATION_LINEAIRE(...)' */ \
/* ('FAUX') ? */
#define RHO__MINIMUM \
FU
#define RHO__MAXIMUM \
RHO__MINIMUM
#define RHO__DELTA_INITIAL \
FZERO
#define DERIVEE_RHO__DELTA_INITIAL \
FZERO
#define RHO__DELTA_FINAL \
FZERO
#define DERIVEE_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 DERIVEE_PHI__DELTA_INITIAL \
FZERO
#define PHI__DELTA_FINAL \
GRO2(FRA10(FU))
#define DERIVEE_PHI__DELTA_FINAL \
FZERO
#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 DERIVEE_THETA_DELTA_INITIAL \
FZERO
#define THETA_DELTA_FINAL \
GRO1(FRA10(FU))
#define DERIVEE_THETA_DELTA_FINAL \
FZERO
#define THETA_DELTA_DOIT_ETRE_NEGATIF \
FAUX
#define THETA_DELTA_DOIT_ETRE_POSITIF \
FAUX
/* Definition de la coordonnee spherique 'theta'. */
#define CHOISIR_LES_POINTS_A_PERTURBER_ALEATOIREMENT \
VRAI \
/* Indique si les points a perturber a chaque iteration sont choisis aleatoirement ('VRAI') */ \
/* ou pas ('FAUX'). */
#define PROBABILITE_DE_BASCULER_DU_CHOIX_ALEATOIRE_DES_POINTS_A_UN_CHOIX_LIE_AU_PLUS_MAUVAIS_POINT \
FZERO \
/* Lorsque 'IL_FAUT(choisir_les_points_a_perturber_aleatoirement)', cette decision peut etre */ \
/* inversee par un tirage aleatoire. */
#define NOMBRE_DE_POINTS_A_PERTURBER_A_CHAQUE_ITERATION \
ZERO \
/* Donne le nombre de points a perturber. Si ce nombre est nul, alors le nombre effectif de */ \
/* points a perturber est aleatoire. */
#define NOMBRE_DE_POINTS_DANS_UN_VOISINAGE \
TROIS \
/* Donne le nombre de points constituant le voisinage d'un point. */
#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... */
#define PONDERATION_MINIMALE_DE_L_INTERPOLATION_DE_PERTURBATION_D_UNE_COORDONNEE \
FZERO
#define PONDERATION_MAXIMALE_DE_L_INTERPOLATION_DE_PERTURBATION_D_UNE_COORDONNEE \
FZERO
/* Afin de calculer aleatoirement la ponderation utilisee dans le 'BARY(...)' de */
/* 'PERTURBATION_D_UNE_COORDONNEE(...)'. */
#define EDITER_TOUTES_LES_DISTANCES_MINIMALES \
FAUX \
/* Doit-on editer toutes les distances minimales pour voir l'amelioration comment converge */ \
/* le processus ? */
#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 ? */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* 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"
#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 \
MODF(MUL2(FLOT(nombre_de_periodes_de_temps) \
,DIVZ(FLOT(SOUS(iteration_courante,PREMIERE_ITERATION_D_UN_Komp)) \
,FLOT(SOUS(nombre_d_iterations_d_optimisation,PREMIERE_ITERATION_D_UN_Komp)) \
) \
) \
,COORDONNEE_BARYCENTRIQUE_MINIMALE \
,COORDONNEE_BARYCENTRIQUE_MAXIMALE \
) \
/* Simulation d'un temps dans [0,1]. */
#define C_EST_UN_ANGLE \
VRAI
#define CE_N_EST_PAS_UN_ANGLE \
NOTL(C_EST_UN_ANGLE)
/* Afin de valider les eventuelle interpolations dans 'PERTURBATION_D_UNE_COORDONNEE(...)'. */
DEFV(Local,DEFV(Logical,INIT(les_coordonnees_peuvent_etre_interpolees,VRAI)));
/* Afin de mieux controler 'PERTURBATION_D_UNE_COORDONNEE(...)'. */
#define PERTURBATION_ALEATOIRE(delta_initial,derivee_delta_initial,delta_final,derivee_delta_final) \
MUL2(SOUS(perturbation_aleatoire_de_la_Coordonnee,COORDONNEE_BARYCENTRIQUE_CENTRALE) \
,COND(IL_NE_FAUT_PAS(utiliser_l_interpolation_cubique) \
,INTERPOLATION_LINEAIRE(delta_initial,delta_final,temps) \
,INTERPOLATION_CUBIQUE(delta_initial,derivee_delta_initial,delta_final,derivee_delta_final,temps) \
) \
) \
/* Amplitude de la perturbation isotrope d'une coordonnee (variant avec le temps...). */ \
/* */ \
/* On rappelle la definition de 'INTERPOLATION_LINEAIRE(...)' (defini par 'BARY(...)' : */ \
/* */ \
/* BARY(initial,final,temps) = [(1-temps).initial] + [(temps-0).final] */ \
/* */
#define NOMBRE_MAXIMAL_DE_TENTATIVES_DE_PERTURBATION \
CENT
#define EDITER_LE_MESSAGE_DE_DEPASSEMENT_DES_TENTATIVES_DE_PERTURBATION \
VRAI
#define PERTURBATION_D_UNE_COORDONNEE(Coordonnee \
,delta_initial,derivee_delta_initial \
,delta_final,derivee_delta_final \
,minimum,maximum \
,periodiser \
,negatif \
,positif \
,Coordonnee_de_reference \
,c_est_un_angle \
) \
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_de_la_Coordonnee,FLOT__UNDEF)); \
DEFV(Float,INIT(ponderation_aleatoire_d_interpolation_de_la_Coordonnee,FZERO)); \
\
GENERATION_D_UNE_VALEUR(perturbation_aleatoire_de_la_Coordonnee \
,COND(IL_FAUT(positif) \
,COORDONNEE_BARYCENTRIQUE_CENTRALE \
,COORDONNEE_BARYCENTRIQUE_MINIMALE \
) \
,COND(IL_FAUT(negatif) \
,COORDONNEE_BARYCENTRIQUE_CENTRALE \
,COORDONNEE_BARYCENTRIQUE_MAXIMALE \
) \
); \
/* Generation de la perturbation aleatoire de la coordonnee courante... */ \
\
Test(EST_VRAI(les_coordonnees_peuvent_etre_interpolees)) \
Bblock \
Test(IFNE(ponderation_minimale_de_l_interpolation_de_perturbation_d_une_coordonnee \
,ponderation_maximale_de_l_interpolation_de_perturbation_d_une_coordonnee \
) \
) \
Bblock \
GENERATION_D_UNE_VALEUR(ponderation_aleatoire_d_interpolation_de_la_Coordonnee \
,ponderation_minimale_de_l_interpolation_de_perturbation_d_une_coordonnee \
,ponderation_maximale_de_l_interpolation_de_perturbation_d_une_coordonnee \
); \
/* Generation de la ponderation aleatoire d'interpolation eventuelle entre la coordonnee */ \
/* courante et la coordonnee de reference courante... */ \
Eblock \
ATes \
Bblock \
EGAL(ponderation_aleatoire_d_interpolation_de_la_Coordonnee \
,CHOI(ponderation_minimale_de_l_interpolation_de_perturbation_d_une_coordonnee \
,ponderation_maximale_de_l_interpolation_de_perturbation_d_une_coordonnee \
) \
); \
Eblock \
ETes \
\
Test(EST_VRAI(c_est_un_angle)) \
Bblock \
Test(IFGE(SOUA(Coordonnee,Coordonnee_de_reference) \
,MOIT(SOUA(maximum,minimum)) \
) \
) \
Bblock \
EGAL(ponderation_aleatoire_d_interpolation_de_la_Coordonnee,FZERO); \
/* Pour un angle, l'interpolation eventuelle avec la coordonnee de reference est inhibe */ \
/* (lamda=0 dans 'BARY(...)') dans le cas ou la coordonnee et la coordonnee de reference */ \
/* semblent trop eloignees l'une de l'autre dans [minimum,maximum]. */ \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
\
EGAL(Coordonnee_perturbee \
,BARY(ADD2(Coordonnee \
,PERTURBATION_ALEATOIRE(delta_initial,derivee_delta_initial,delta_final,derivee_delta_final) \
) \
,Coordonnee_de_reference \
,ponderation_aleatoire_d_interpolation_de_la_Coordonnee \
) \
); \
/* Perturbation et/ou interpolation (par rapport a une reference) de la coordonnee courante. */ \
\
Test(IL_FAUT(utiliser_l_interpolation_cubique)) \
Bblock \
EGAL(Coordonnee_perturbee,TRON(Coordonnee_perturbee,minimum,maximum)); \
/* A cause des "rebonds" causes par l'interpolation cubique pres de l'origine et de */ \
/* l'extremite du segment d'interpolation. */ \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
\
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)) \
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 LE_POINT_EST_IL_A_PERTURBER(index) \
gELEMENT_DU_FICHIER(le_point_est_il_a_perturber,index) \
/* Acces a un element courant de 'le_point_est_il_a_perturber'... */
DEFV(Local,DEFV(Logical,DdTb1(POINTERl
,le_point_est_il_a_perturber
,nombre_maximal_d_elements_dans_le_fichier
,ADRESSE_NON_ENCORE_DEFINIE
)
)
);
/* Indique si le point de rang 'i' est a perturber... */
#define VECTEUR_DES_DISTANCES_MINIMALES(index_i) \
IdTb1(vecteur_des_distances_minimales \
,INDX(index_i,PREMIER_ELEMENT_D_UN_FICHIER),nombre_maximal_d_elements_dans_le_fichier \
) \
/* Acces a un element courant de 'vecteur_des_distances_minimales'... */
DEFV(Local,DEFV(Float,DdTb1(POINTERf
,vecteur_des_distances_minimales
,nombre_maximal_d_elements_dans_le_fichier
,ADRESSE_NON_ENCORE_DEFINIE
)
)
);
/* Vecteur des distances minimales du point 'i' aux autres points... */
#define ETUDE_DES_DISTANCES_MINIMALES(minimum_distances_minimales,moyenne_distances_minimales,maximum_distances_minimales) \
Bblock \
DEFV(Int,INIT(DM_index_i,UNDEF)); \
DEFV(Int,INIT(DM_index_j,UNDEF)); \
\
EGAL(minimum_distances_minimales,F_INFINI); \
EGAL(moyenne_distances_minimales,FZERO); \
EGAL(maximum_distances_minimales,F_MOINS_L_INFINI); \
\
DoIn(DM_index_i,PREMIER_ELEMENT_D_UN_FICHIER,DERNIER_ELEMENT_D_UN_FICHIER,I) \
Bblock \
EGAL(VECTEUR_DES_DISTANCES_MINIMALES(DM_index_i),F_INFINI); \
\
DoIn(DM_index_j,PREMIER_ELEMENT_D_UN_FICHIER,DERNIER_ELEMENT_D_UN_FICHIER,I) \
Bblock \
Test(IFNE(DM_index_i,DM_index_j)) \
Bblock \
DEFV(Float,INIT(distance_courante \
,RdisF3D(ELEMENT_DU_FICHIER_LISTE_X(DM_index_i) \
,ELEMENT_DU_FICHIER_LISTE_Y(DM_index_i) \
,ELEMENT_DU_FICHIER_LISTE_Z(DM_index_i) \
,ELEMENT_DU_FICHIER_LISTE_X(DM_index_j) \
,ELEMENT_DU_FICHIER_LISTE_Y(DM_index_j) \
,ELEMENT_DU_FICHIER_LISTE_Z(DM_index_j) \
) \
) \
); \
\
EGAL(VECTEUR_DES_DISTANCES_MINIMALES(DM_index_i) \
,MIN2(VECTEUR_DES_DISTANCES_MINIMALES(DM_index_i),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 \
/* On notera que la diagonale 'DM_index_i=DM_index_j' est toujours a zero (par */ \
/* initialisation...). */ \
Eblock \
ETes \
Eblock \
EDoI \
\
EGAL(minimum_distances_minimales \
,MIN2(minimum_distances_minimales,VECTEUR_DES_DISTANCES_MINIMALES(DM_index_i)) \
); \
INCR(moyenne_distances_minimales \
,VECTEUR_DES_DISTANCES_MINIMALES(DM_index_i) \
); \
EGAL(maximum_distances_minimales \
,MAX2(maximum_distances_minimales,VECTEUR_DES_DISTANCES_MINIMALES(DM_index_i)) \
); \
Eblock \
EDoI \
\
EGAL(moyenne_distances_minimales,DIVI(moyenne_distances_minimales,nombre_d_elements)); \
\
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 U N I F O R 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(Logical,INIT(sortir_les_coordonnees_optimisees,SORTIR_LES_COORDONNEES_OPTIMISEES));
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 ? */
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). */
DEFV(Int,INIT(nombre_maximal_de_tentatives_de_perturbation,NOMBRE_MAXIMAL_DE_TENTATIVES_DE_PERTURBATION));
DEFV(Logical,INIT(editer_le_message_de_depassement_des_tentatives_de_perturbation
,EDITER_LE_MESSAGE_DE_DEPASSEMENT_DES_TENTATIVES_DE_PERTURBATION
)
);
DEFV(Positive,INIT(nombre_de_periodes_de_temps,NOMBRE_DE_PERIODES_DE_TEMPS));
/* Nombre de periode de temps pour calculer un temps d'interpolation periodise. */
DEFV(Logical,INIT(utiliser_l_interpolation_cubique,UTILISER_L_INTERPOLATION_CUBIQUE));
/* Doit-on utiliser 'INTERPOLATION_CUBIQUE(...)' ('VRAI') ou 'INTERPOLATION_LINEAIRE(...)' */
/* ('FAUX') ? */
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(derivee_rho__delta_initial,DERIVEE_RHO__DELTA_INITIAL));
DEFV(Float,INIT(rho__delta_final,RHO__DELTA_FINAL));
DEFV(Float,INIT(derivee_rho__delta_final,DERIVEE_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(derivee_phi__delta_initial,DERIVEE_PHI__DELTA_INITIAL));
DEFV(Float,INIT(phi__delta_final,PHI__DELTA_FINAL));
DEFV(Float,INIT(derivee_phi__delta_final,DERIVEE_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(derivee_theta_delta_initial,DERIVEE_THETA_DELTA_INITIAL));
DEFV(Float,INIT(theta_delta_final,THETA_DELTA_FINAL));
DEFV(Float,INIT(derivee_theta_delta_final,DERIVEE_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(Logical,INIT(choisir_effectivement_les_points_a_perturber_aleatoirement,LUNDEF));
DEFV(Logical,INIT(choisir_les_points_a_perturber_aleatoirement,CHOISIR_LES_POINTS_A_PERTURBER_ALEATOIREMENT));
/* Indique si les points a perturber a chaque iteration sont choisis aleatoirement ('VRAI') */
/* ou pas ('FAUX'). */
DEFV(Float,INIT(probabilite_de_basculer_du_choix_aleatoire_des_points_a_un_choix_lie_au_plus_mauvais_point
,PROBABILITE_DE_BASCULER_DU_CHOIX_ALEATOIRE_DES_POINTS_A_UN_CHOIX_LIE_AU_PLUS_MAUVAIS_POINT
)
);
/* Lorsque 'IL_FAUT(choisir_les_points_a_perturber_aleatoirement)', cette decision peut etre */
/* inversee par un tirage aleatoire */
DEFV(Int,INIT(nombre_de_points_a_perturber_a_chaque_iteration,NOMBRE_DE_POINTS_A_PERTURBER_A_CHAQUE_ITERATION));
/* Donne le nombre de points a perturber. Si ce nombre est nul, alors le nombre effectif de */
/* points a perturber est aleatoire. */
DEFV(Int,INIT(nombre_de_points_dans_un_voisinage,NOMBRE_DE_POINTS_DANS_UN_VOISINAGE));
/* Donne le nombre de points constituant le voisinage d'un point. */
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... */
DEFV(Float,INIT(ponderation_minimale_de_l_interpolation_de_perturbation_d_une_coordonnee
,PONDERATION_MINIMALE_DE_L_INTERPOLATION_DE_PERTURBATION_D_UNE_COORDONNEE
)
);
DEFV(Float,INIT(ponderation_maximale_de_l_interpolation_de_perturbation_d_une_coordonnee
,PONDERATION_MAXIMALE_DE_L_INTERPOLATION_DE_PERTURBATION_D_UNE_COORDONNEE
)
);
/* Afin de calculer aleatoirement la ponderation utilisee dans le 'BARY(...)' de */
/* 'PERTURBATION_D_UNE_COORDONNEE(...)'. */
DEFV(Logical,INIT(editer_toutes_les_distances_minimales,EDITER_TOUTES_LES_DISTANCES_MINIMALES));
/* Doit-on editer toutes les distances minimales pour voir l'amelioration comment converge */
/* le processus ? */
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 ? */
DEFV(Int,INIT(iteration_courante,UNDEF));
/* Index divers... */
DEFV(Float,INIT(minimum_distances_minimales_avant_la_perturbation,FLOT__UNDEF));
DEFV(Float,INIT(moyenne_distances_minimales_avant_la_perturbation,FLOT__UNDEF));
DEFV(Float,INIT(maximum_distances_minimales_avant_la_perturbation,FLOT__UNDEF));
DEFV(Float,INIT(minimum_distances_minimales_apres_la_perturbation,FLOT__UNDEF));
DEFV(Float,INIT(moyenne_distances_minimales_apres_la_perturbation,FLOT__UNDEF));
DEFV(Float,INIT(maximum_distances_minimales_apres_la_perturbation,FLOT__UNDEF));
/* Distances minimales avant et apres une tentative de perturbation... */
DEFV(Logical,INIT(le_processus_semble_converger,FAUX));
/* Pour optimiser le calcul des distances... */
/*..............................................................................................................................*/
#include xrv/champs_5.1A.I"
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);
GET_ARGUMENT_L("cartesiennesR=""cartesienneR=""cR=",utiliser_les_coordonnees_cartesiennes_en_sortie);
GET_ARGUMENT_N("spheriquesR=""spheriqueR=""sR=",utiliser_les_coordonnees_cartesiennes_en_sortie);
GET_ARGUMENT_L("sortir=",sortir_les_coordonnees_optimisees);
GET_ARGUMENT_N("pas_sortir=",sortir_les_coordonnees_optimisees);
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);
GET_ARGUMENT_L("message_trop_de_perturbations=""mtp="
,editer_le_message_de_depassement_des_tentatives_de_perturbation
);
GET_ARGUMENT_I("periodes=",nombre_de_periodes_de_temps);
GET_ARGUMENT_L("interpolation_cubique=""ic=",utiliser_l_interpolation_cubique);
GET_ARGUMENT_N("interpolation_lineaire=""il=",utiliser_l_interpolation_cubique);
GET_ARGUMENT_F("rm=",rho__minimum);
GET_ARGUMENT_F("rM=",rho__maximum);
GET_ARGUMENT_F("rho_delta_initial=""rdi=",rho__delta_initial);
GET_ARGUMENT_F("derivee_rho_delta_initial=""drdi=",derivee_rho__delta_initial);
GET_ARGUMENT_F("rho_delta_final=""rdf=",rho__delta_final);
GET_ARGUMENT_F("derivee_rho_delta_final=""drdf=",derivee_rho__delta_final);
GET_ARGUMENT_L("rho_delta_negatif=""rdn=",rho__delta_doit_etre_negatif);
GET_ARGUMENT_L("rho_delta_positif=""rdp=",rho__delta_doit_etre_positif);
GET_ARGUMENT_F("pm=",phi__minimum);
GET_ARGUMENT_F("pM=",phi__maximum);
GET_ARGUMENT_F("phi_delta_initial=""pdi=",phi__delta_initial);
GET_ARGUMENT_F("derivee_phi_delta_initial=""dpdi=",derivee_phi__delta_initial);
GET_ARGUMENT_F("phi_delta_final=""pdf=",phi__delta_final);
GET_ARGUMENT_F("derivee_phi_delta_final=""dpdf=",derivee_phi__delta_final);
GET_ARGUMENT_L("phi_delta_negatif=""pdn=",phi__delta_doit_etre_negatif);
GET_ARGUMENT_L("phi_delta_positif=""pdp=",phi__delta_doit_etre_positif);
GET_ARGUMENT_F("tm=",theta_minimum);
GET_ARGUMENT_F("tM=",theta_maximum);
GET_ARGUMENT_F("theta_delta_initial=""tdi=",theta_delta_initial);
GET_ARGUMENT_F("derivee_theta_delta_initial=""dtdi=",derivee_theta_delta_initial);
GET_ARGUMENT_F("theta_delta_final=""tdf=",theta_delta_final);
GET_ARGUMENT_F("derivee_theta_delta_final=""dtdf=",derivee_theta_delta_final);
GET_ARGUMENT_L("theta_delta_negatif=""tdn=",theta_delta_doit_etre_negatif);
GET_ARGUMENT_L("theta_delta_positif=""tdp=",theta_delta_doit_etre_positif);
GET_ARGUMENT_L("choix_points_aleatoire=""cpa=",choisir_les_points_a_perturber_aleatoirement);
GET_ARGUMENT_F("probabilite_bascule_choix_points_aleatoire=""pbcpa="
,probabilite_de_basculer_du_choix_aleatoire_des_points_a_un_choix_lie_au_plus_mauvais_point
);
GET_ARGUMENT_I("nombre_points_a_perturber=""npap=",nombre_de_points_a_perturber_a_chaque_iteration);
GET_ARGUMENT_I("nombre_points_voisinage=""npv=",nombre_de_points_dans_un_voisinage);
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_F("ponderation_minimale_interpolation=""pmi="
,ponderation_minimale_de_l_interpolation_de_perturbation_d_une_coordonnee
);
GET_ARGUMENT_F("ponderation_maximale_interpolation=""pMi="
,ponderation_maximale_de_l_interpolation_de_perturbation_d_une_coordonnee
);
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_all=""lia=""editer_all=""eda=",editer_toutes_les_distances_minimales);
GET_ARGUMENT_L("lister_initiale_finale=""liif=""editer_initiale_finale=""edif="
,editer_les_distances_minimales_initiale_et_finale
);
PROCESS_ARGUMENTS_DE_PARAMETRAGE_DE_LA_GENERATION_DE_SUITE_DE_VALEURS_3;
PROCESS_ARGUMENTS_DE_PARAMETRAGE_DE_LA_GENERATION_DE_SUITE_DE_VALEURS_1;
)
);
Test(IFGT(nombre_de_points_a_perturber_a_chaque_iteration,nombre_d_elements))
Bblock
PRINT_ATTENTION("le nombre de points a perturber est superieur au nombre de points, il est donc seuille");
EGAL(nombre_de_points_a_perturber_a_chaque_iteration,NEUT(nombre_d_elements));
CAL1(Prer1("(le nombre de points a perturber vaut donc %d)\n",nombre_de_points_a_perturber_a_chaque_iteration));
Eblock
ATes
Bblock
Eblock
ETes
Test(IFGE(nombre_de_points_dans_un_voisinage,nombre_d_elements))
Bblock
PRINT_ATTENTION("le nombre de points d'un voisinage est superieur ou egal au nombre de points, il est donc seuille");
EGAL(nombre_de_points_dans_un_voisinage,PRED(nombre_d_elements));
CAL1(Prer1("(le nombre de points d'un voisinage vaut donc %d)\n",nombre_de_points_dans_un_voisinage));
Eblock
ATes
Bblock
Eblock
ETes
Test(IFEXff(index_du_point_fixe,PREMIER_ELEMENT_D_UN_FICHIER,DERNIER_ELEMENT_D_UN_FICHIER))
Bblock
PRINT_ATTENTION("l'index du point fixe est incompatible avec les autres arguments, il est donc corrige");
EGAL(index_du_point_fixe,PREMIER_ELEMENT_D_UN_FICHIER);
CAL1(Prer1("(l'index du point fixe vaut donc %d)\n",index_du_point_fixe));
Eblock
ATes
Bblock
Eblock
ETes
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);
MdTb1(le_point_est_il_a_perturber
,nombre_maximal_d_elements_dans_le_fichier
,Logical
,ADRESSE_NON_ENCORE_DEFINIE
);
/* Indique si le point de rang 'i' est a perturber... */
MdTb1(vecteur_des_distances_minimales
,nombre_maximal_d_elements_dans_le_fichier
,Float
,ADRESSE_NON_ENCORE_DEFINIE
);
/* Allocation du vecteur des distances minimales du point 'i' aux autres points... */
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(Int,INIT(index_i,UNDEF));
DEFV(Int,INIT(index_j,UNDEF));
DEFV(Float,INIT(probabilite_courante,FLOT__UNDEF));
/* Probabilite destinee a choisir les points, les mauvaises solutions,... */
EGAL(choisir_effectivement_les_points_a_perturber_aleatoirement,choisir_les_points_a_perturber_aleatoirement);
/* A priori... */
Test(IL_FAUT(choisir_les_points_a_perturber_aleatoirement))
Bblock
GENERATION_D_UNE_VALEUR(probabilite_courante,PROBABILITE_NULLE,PROBABILITE_UNITE);
Test(IFGE(probabilite_courante
,probabilite_de_basculer_du_choix_aleatoire_des_points_a_un_choix_lie_au_plus_mauvais_point
)
)
Bblock
Eblock
ATes
Bblock
EGAL(choisir_effectivement_les_points_a_perturber_aleatoirement
,NOTL(choisir_les_points_a_perturber_aleatoirement)
);
/* En fait, la selection des points a perturber ne sera pas aleatoire... */
Eblock
ETes
Eblock
ATes
Bblock
Eblock
ETes
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(le_processus_semble_converger))
Bblock
Test(IFET(IFEQ(iteration_courante,PREMIERE_ITERATION_D_UN_Komp)
,IZEQ(nombre_de_tentatives_effectuees)
)
)
Bblock
ETUDE_DES_DISTANCES_MINIMALES(minimum_distances_minimales_avant_la_perturbation
,moyenne_distances_minimales_avant_la_perturbation
,maximum_distances_minimales_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(minimum_distances_minimales_avant_la_perturbation,minimum_distances_minimales_apres_la_perturbation);
EGAL(moyenne_distances_minimales_avant_la_perturbation,moyenne_distances_minimales_apres_la_perturbation);
EGAL(maximum_distances_minimales_avant_la_perturbation,maximum_distances_minimales_apres_la_perturbation);
Eblock
ETes
Test(IL_FAUT(editer_toutes_les_distances_minimales))
Bblock
CAL2(Prin0(" DistanceMinimale="));
EDITION_DANS_gOPERATION_SUR_LES_FICHIERS_AVEC_SAUT_DE_LIGNE(moyenne_distances_minimales_avant_la_perturbation);
/* Introduit sous cette forme le 20160804100633... */
Eblock
ATes
Bblock
Test(I3ET(IL_FAUT(editer_les_distances_minimales_initiale_et_finale)
,IFEQ(iteration_courante,PREMIERE_ITERATION_D_UN_Komp)
,IZEQ(nombre_de_tentatives_effectuees)
)
)
Bblock
CAL2(Prin0(" MinimumFinalDistancesMinimales="));
EDITION_DANS_gOPERATION_SUR_LES_FICHIERS_AVEC_SAUT_DE_LIGNE(minimum_distances_minimales_avant_la_perturbation);
/* Introduit sous cette forme le 20160804100633... */
CAL2(Prin0(" MoyenneFinaleDistancesMinimales="));
EDITION_DANS_gOPERATION_SUR_LES_FICHIERS_AVEC_SAUT_DE_LIGNE(moyenne_distances_minimales_avant_la_perturbation);
/* Introduit sous cette forme le 20160804100633... */
CAL2(Prin0(" MaximumFinalDistancesMinimales="));
EDITION_DANS_gOPERATION_SUR_LES_FICHIERS_AVEC_SAUT_DE_LIGNE(maximum_distances_minimales_avant_la_perturbation);
/* Introduit sous cette forme le 20160804100633... */
Eblock
ATes
Bblock
Eblock
ETes
Eblock
ETes
DoIn(index_i,PREMIER_ELEMENT_D_UN_FICHIER,DERNIER_ELEMENT_D_UN_FICHIER,I)
Bblock
EGAL(LE_POINT_EST_IL_A_PERTURBER(index_i),FAUX);
/* A priori... */
Eblock
EDoI
Test(IL_FAUT(choisir_effectivement_les_points_a_perturber_aleatoirement))
Bblock
Test(IZEQ(nombre_de_points_a_perturber_a_chaque_iteration))
Bblock
DoIn(index_i,PREMIER_ELEMENT_D_UN_FICHIER,DERNIER_ELEMENT_D_UN_FICHIER,I)
Bblock
Test(IFET(IL_FAUT(avoir_un_point_fixe)
,IFEQ(index_i,index_du_point_fixe)
)
)
Bblock
Eblock
ATes
Bblock
GENERATION_D_UNE_VALEUR(probabilite_courante,PROBABILITE_NULLE,PROBABILITE_UNITE);
Test(IFLT(probabilite_courante,probabilite_de_perturber_un_point))
Bblock
EGAL(LE_POINT_EST_IL_A_PERTURBER(index_i),VRAI);
/* Le point 'i' est a perturber... */
Eblock
ATes
Bblock
Eblock
ETes
Eblock
ETes
Eblock
EDoI
Eblock
ATes
Bblock
DEFV(Int,INIT(nombre_de_points_a_perturber_a_chaque_iteration_trouves,ZERO));
Tant(IFLT(nombre_de_points_a_perturber_a_chaque_iteration_trouves
,nombre_de_points_a_perturber_a_chaque_iteration
)
)
Bblock
DoIn(index_i,PREMIER_ELEMENT_D_UN_FICHIER,DERNIER_ELEMENT_D_UN_FICHIER,I)
Bblock
Test(IFET(IFLT(nombre_de_points_a_perturber_a_chaque_iteration_trouves
,nombre_de_points_a_perturber_a_chaque_iteration
)
,EST_FAUX(LE_POINT_EST_IL_A_PERTURBER(index_i))
)
)
Bblock
GENERATION_D_UNE_VALEUR(probabilite_courante,PROBABILITE_NULLE,PROBABILITE_UNITE);
Test(IFLT(probabilite_courante,probabilite_de_perturber_un_point))
Bblock
EGAL(LE_POINT_EST_IL_A_PERTURBER(index_i),VRAI);
/* Le point 'i' est a perturber... */
INCR(nombre_de_points_a_perturber_a_chaque_iteration_trouves,I);
/* Et un point de plus... */
Eblock
ATes
Bblock
Eblock
ETes
Eblock
ATes
Bblock
Eblock
ETes
Eblock
EDoI
Eblock
ETan
Eblock
ETes
Eblock
ATes
Bblock
Eblock
ETes
DoIn(index_i,PREMIER_ELEMENT_D_UN_FICHIER,DERNIER_ELEMENT_D_UN_FICHIER,I)
Bblock
Test(EST_VRAI(LE_POINT_EST_IL_A_PERTURBER(index_i)))
Bblock
DEFV(Float,INIT(Rho__perturbe,ELEMENT_DU_FICHIER_LISTE_RHO_(index_i)));
DEFV(Float,INIT(Phi__perturbe,ELEMENT_DU_FICHIER_LISTE_PHI_(index_i)));
DEFV(Float,INIT(Theta_perturbe,ELEMENT_DU_FICHIER_LISTE_THETA(index_i)));
DEFV(Float,INIT(Rho__de_reference,FZERO));
DEFV(Float,INIT(Phi__de_reference,FZERO));
DEFV(Float,INIT(Theta_de_reference,FZERO));
PERTURBATION_D_UNE_COORDONNEE(Rho__perturbe
,rho__delta_initial,derivee_rho__delta_initial
,rho__delta_final,derivee_rho__delta_final
,rho__minimum,rho__maximum
,FAUX
,rho__delta_doit_etre_negatif
,rho__delta_doit_etre_positif
,Rho__de_reference
,CE_N_EST_PAS_UN_ANGLE
);
PERTURBATION_D_UNE_COORDONNEE(Phi__perturbe
,phi__delta_initial,derivee_phi__delta_initial
,phi__delta_final,derivee_phi__delta_final
,phi__minimum,phi__maximum
,FAUX
,phi__delta_doit_etre_negatif
,phi__delta_doit_etre_positif
,Phi__de_reference
,C_EST_UN_ANGLE
);
PERTURBATION_D_UNE_COORDONNEE(Theta_perturbe
,theta_delta_initial,derivee_theta_delta_initial
,theta_delta_final,derivee_theta_delta_final
,theta_minimum,theta_maximum
,FAUX
,theta_delta_doit_etre_negatif
,theta_delta_doit_etre_positif
,Theta_de_reference
,C_EST_UN_ANGLE
);
/* ATTENTION : les coordonnees sont perturbees dans leur version spherique. Ces */
/* version 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_i),Rho__perturbe);
EGAL(ELEMENT_DU_FICHIER_LISTE_PHI_(index_i),Phi__perturbe);
EGAL(ELEMENT_DU_FICHIER_LISTE_THETA(index_i),Theta_perturbe);
/* Perturbation aleatoire des points. */
EGAL(ELEMENT_DU_FICHIER_LISTE_X(index_i)
,Xcartesienne_3D(ELEMENT_DU_FICHIER_LISTE_RHO_(index_i)
,ELEMENT_DU_FICHIER_LISTE_PHI_(index_i)
,ELEMENT_DU_FICHIER_LISTE_THETA(index_i)
)
);
EGAL(ELEMENT_DU_FICHIER_LISTE_Y(index_i)
,Ycartesienne_3D(ELEMENT_DU_FICHIER_LISTE_RHO_(index_i)
,ELEMENT_DU_FICHIER_LISTE_PHI_(index_i)
,ELEMENT_DU_FICHIER_LISTE_THETA(index_i)
)
);
EGAL(ELEMENT_DU_FICHIER_LISTE_Z(index_i)
,Zcartesienne_3D(ELEMENT_DU_FICHIER_LISTE_RHO_(index_i)
,ELEMENT_DU_FICHIER_LISTE_PHI_(index_i)
,ELEMENT_DU_FICHIER_LISTE_THETA(index_i)
)
);
/* Et conversion spherique --> cartesienne... */
Eblock
ATes
Bblock
Eblock
ETes
Eblock
EDoI
ETUDE_DES_DISTANCES_MINIMALES(minimum_distances_minimales_apres_la_perturbation
,moyenne_distances_minimales_apres_la_perturbation
,maximum_distances_minimales_apres_la_perturbation
);
/* Recherche de la distance minimale apres la perturbation. */
Test(IL_FAUT(choisir_effectivement_les_points_a_perturber_aleatoirement))
Bblock
GENERATION_D_UNE_VALEUR(probabilite_courante,PROBABILITE_NULLE,PROBABILITE_UNITE);
Test(IFOU(IFET(IFGE(SOUS(maximum_distances_minimales_apres_la_perturbation
,minimum_distances_minimales_apres_la_perturbation
)
,SOUS(maximum_distances_minimales_avant_la_perturbation
,minimum_distances_minimales_avant_la_perturbation
)
)
,IFLT(probabilite_courante
,probabilite_d_accepter_une_mauvaise_solution
)
)
,IFET(IFLT(SOUS(maximum_distances_minimales_apres_la_perturbation
,minimum_distances_minimales_apres_la_perturbation
)
,SOUS(maximum_distances_minimales_avant_la_perturbation
,minimum_distances_minimales_avant_la_perturbation
)
)
,IFGE(probabilite_courante
,probabilite_de_refuser_une_bonne_solution
)
)
)
)
/* On cherche a reduire l'ecart entre le minimum et le maximum des distances minimales... */
Bblock
EGAL(on_a_trouve_une_bonne_perturbation,VRAI);
/* On va pouvoir arreter la boucle courante 'Tant(...)' des tentatives... */
Eblock
ATes
Bblock
Eblock
ETes
Eblock
ATes
Bblock
EGAL(on_a_trouve_une_bonne_perturbation,VRAI);
/* Lorsque les points perturbes ne sont pas choisis aleatoirement, toute perturbation */
/* est acceptee evidemment. */
Eblock
ETes
Test(EST_FAUX(on_a_trouve_une_bonne_perturbation))
Bblock
EGAL(le_processus_semble_converger,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(le_processus_semble_converger,VRAI);
/* On conserve un etat perturbe qui maximise la distance minimale... */
Eblock
ETes
Test(IL_FAUT(editer_toutes_les_distances_minimales))
Bblock
Eblock
ATes
Bblock
Test(IFET(IL_FAUT(editer_les_distances_minimales_initiale_et_finale)
,IFEQ(iteration_courante,nombre_d_iterations_d_optimisation)
)
)
Bblock
CAL2(Prin0(" MinimumFinalDistancesMinimales="));
EDITION_DANS_gOPERATION_SUR_LES_FICHIERS_AVEC_SAUT_DE_LIGNE(minimum_distances_minimales_avant_la_perturbation);
/* Introduit sous cette forme le 20160804100633... */
CAL2(Prin0(" MoyenneFinaleDistancesMinimales="));
EDITION_DANS_gOPERATION_SUR_LES_FICHIERS_AVEC_SAUT_DE_LIGNE(moyenne_distances_minimales_avant_la_perturbation);
/* Introduit sous cette forme le 20160804100633... */
CAL2(Prin0(" MaximumFinalDistancesMinimales="));
EDITION_DANS_gOPERATION_SUR_LES_FICHIERS_AVEC_SAUT_DE_LIGNE(maximum_distances_minimales_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... */
/* */
/* Introduit sous cette forme le 20160804100633... */
Eblock
ATes
Bblock
Eblock
ETes
Eblock
ETes
INCR(nombre_de_tentatives_effectuees,I);
/* Et une tentative de plus... */
Eblock
ETan
Eblock
EKom
Test(IL_FAUT(sortir_les_coordonnees_optimisees))
Bblock
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
Eblock
ATes
Bblock
Eblock
ETes
FdTb1(vecteur_des_distances_minimales
,nombre_maximal_d_elements_dans_le_fichier
,Float
,ADRESSE_NON_ENCORE_DEFINIE
);
/* Liberation du vecteur des distances minimales du point 'i' aux autres points... */
FdTb1(le_point_est_il_a_perturber
,nombre_maximal_d_elements_dans_le_fichier
,Logical
,ADRESSE_NON_ENCORE_DEFINIE
);
/* Liberation de la liste des points a perturber... */
lGENERATION_D_UN_FICHIER(sauvegarde_liste_initiale_des_Z,FLOT__UNDEF);
lGENERATION_D_UN_FICHIER(sauvegarde_liste_initiale_des_Y,FLOT__UNDEF);
lGENERATION_D_UN_FICHIER(sauvegarde_liste_initiale_des_X,FLOT__UNDEF);
lGENERATION_D_UN_FICHIER(sauvegarde_liste_initiale_des_THETA,FLOT__UNDEF);
lGENERATION_D_UN_FICHIER(sauvegarde_liste_initiale_des_PHI_,FLOT__UNDEF);
lGENERATION_D_UN_FICHIER(sauvegarde_liste_initiale_des_RHO_,FLOT__UNDEF);
lGENERATION_D_UN_FICHIER(liste_initiale_des_Z,Z_IMPLICITE);
lGENERATION_D_UN_FICHIER(liste_initiale_des_Y,Y_IMPLICITE);
lGENERATION_D_UN_FICHIER(liste_initiale_des_X,X_IMPLICITE);
lGENERATION_D_UN_FICHIER(liste_initiale_des_THETA,THETA_IMPLICITE);
lGENERATION_D_UN_FICHIER(liste_initiale_des_PHI_,PHI__IMPLICITE);
lGENERATION_D_UN_FICHIER(liste_initiale_des_RHO_,RHO__IMPLICITE);
RETU_Commande;
Eblock
ECommande