/*************************************************************************************************************************************/
/* */
/* 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)... */
/* */
/* */
/* Nota : */
/* */
/* Si l'on souhaite utiliser ce programme */
/* uniquement pour calculer les distances deux */
/* a deux triees par ordre croissant entre les */
/* points d'un ensemble {X,Y,Z} (par exemple...), */
/* il suffira d'appeler ce programme avec les */
/* arguments suivants : */
/* */
/* ne=... */
/* LISTE_X=... */
/* LISTE_Y=... */
/* LISTE_Z=... */
/* */
/* cartesienneA=VRAI */
/* cartesienneR=VRAI */
/* */
/* uniquement_matrice_distances=VRAI */
/* nombre_points_matrice_distances_triee=... */
/* */
/* et le tour est joue... */
/* */
/* */
/* Author of '$xrv/optimise.02$K' : */
/* */
/* Jean-Francois COLONNA (LACTAMME, 20080228105849). */
/* */
/*************************************************************************************************************************************/
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* 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. Ceci fut introduit le */ \
/* 20080228190114 au cas ou aucun argument de type 'lTRANSFORMAT_0d(...)' ne serait */ \
/* introduit auquel cas 'nombre_maximal_d_elements_dans_le_fichier' a comme valeur ce */ \
/* parametre. Cela provoque alors un defaut d'allocation memoire dans les 'MdTb2(...)' */ \
/* qui suivent... */
#define FAIRE_UNIQUEMENT_CALCUL_ET_EDITION_MATRICE_DES_DISTANCES_TRIEE_SANS_ITERATIONS \
FAUX \
/* Introduit le 20080307081422 afin de permettre de calculer et d'editer la matrice des */ \
/* distances triees associee a un ensemble initial {X(i),Y(i),Z(i)} (ou evidemment */ \
/* {Rho(i),Theta(i),Phi(i)}) sans enclencher le processus d'optimisation... */
#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 \
/* Introduit le 20080307100250 afin d'etre utilise en conjonction avec l'option */ \
/* 'faire_uniquement_le_calcul_et_l_edition_de_la_matrice_des_distances_triee_sans_...'. */
#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... */ \
/* */ \
/* 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. Ceci fut */ \
/* introduit le 20080225134521 afin que 'PERTURBATION_ALEATOIRE(...)' puisse reprendre */ \
/* periodiquement des valeurs egales aux valeurs initiales... */
#define UTILISER_L_INTERPOLATION_CUBIQUE \
FAUX \
/* Doit-on utiliser 'INTERPOLATION_CUBIQUE(...)' ('VRAI') ou 'INTERPOLATION_LINEAIRE(...)' */ \
/* ('FAUX') ? Ceci fut introduit le 20080224104855 pour ameliorer les performances... */
#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 PLUS_PETITE_DISTANCE_MINIMALE_AUTORISEE \
FZERO
#define PLUS_GRANDE_DISTANCE_MINIMALE_AUTORISEE \
F_INFINI
/* Definitions des bornes de la distance minimale (introduites le 20150616135554). */
#define FORCER_LE_CALCUL_DE_LA_MATRICE_DES_VOISINS \
FAUX \
/* Indique si la calcul de la matrice des voisins doit etre fait meme s'il n'est pas utile */ \
/* ('VRAI')ou pas ('FAUX'). Ceci fut introduit le 20080301095446 afin des fins de mise au */ \
/* point... */
#define CHOISIR_LES_POINTS_A_PERTURBER_ALEATOIREMENT \
VRAI \
/* Indique si les points a perturber a chaque iteration sont choisis aleatoirement ('VRAI') */ \
/* ou pas ('FAUX'). Ceci fut introduit le 20080228095755... */
#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 (introduit le 20080303100321...). */
#define CHOISIR_LES_POINTS_A_PERTURBER_DANS_LE_VOISINAGE_DU_PLUS_MAUVAIS_POINT \
VRAI \
/* Indique si les points a perturber sont a choisir en fonction du voisinage du plus mauvais */ \
/* point ('VRAI') ou autrement ('FAUX') ? */
#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. Ceci fut introduit le 20080228095755... */
#define NOMBRE_DE_POINTS_DANS_UN_VOISINAGE \
TROIS \
/* Donne le nombre de points constituant le voisinage d'un point. Ceci fut introduit */ \
/* le 20080304085009... */
#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 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(...)'. Ceci fut introduit de facon deterministe le */
/* 20080228205916 et de facon aleatoire le 20080229183023... */
#define EDITER_TOUTES_LES_DISTANCES_MINIMALES \
FAUX \
/* Doit-on editer toutes les distances minimales pour voir l'amelioration comment converge */ \
/* le processus (possibilite introduite le 20080224095738) ? */
#define EDITER_LES_DISTANCES_MINIMALES_INITIALE_ET_FINALE \
FAUX \
/* Doit-on editer les distances minimales initiale et finale pour voir l'amelioration ? */
#define EDITER_LA_MATRICE_DES_DISTANCES \
FAUX
#define EDITER_LA_MATRICE_DES_DISTANCES_TRIEE_SUIVANT_LA_MATRICE_DES_VOISINS \
FAUX
#define NOMBRE_ELEMENTS_MATRICE_DES_DISTANCES_TRIEE_SUIVANT_LA_MATRICE_DES_VOISINS \
TROIS
#define EDITER_LA_MATRICE_DES_VOISINS \
FAUX
/* Doit-on editer les matrices des distances et des vosins (introduit le 20080227180930)... */
#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 \
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]. */ \
/* */ \
/* Le 20080301192904 'DIVI(...)' a ete remplace par 'DIVZ(...)' pour traiter le cas ou */ \
/* il n'y a qu'une seule iteration... */
#define C_EST_UN_ANGLE \
VRAI
#define CE_N_EST_PAS_UN_ANGLE \
NOTL(C_EST_UN_ANGLE)
/* Introduit le 20080302094151 afin de valider les eventuelle interpolations ci-apres */ \
/* dans 'PERTURBATION_D_UNE_COORDONNEE(...)'. */
DEFV(Local,DEFV(Logical,INIT(les_coordonnees_peuvent_etre_interpolees,VRAI)));
/* Introduit le 20080303095038 pour 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 \
/* Introduit le 20080303151721... */
#define EDITER_LE_MESSAGE_DE_DEPASSEMENT_DES_TENTATIVES_DE_PERTURBATION \
VRAI \
/* Introduit le 20150615161855... */
#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 \
) \
/* 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_de_la_Coordonnee,FLOT__UNDEF)); \
DEFV(Float,INIT(ponderation_aleatoire_d_interpolation_de_la_Coordonnee,FZERO)); \
/* Le 20080303095038, la valeur par defaut est passee de 'FLOT__UNDEF' a 'FZERO' afin */ \
/* de faciliter le cas 'EST_FAUX(les_coordonnees_peuvent_etre_interpolees)'... */ \
\
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)) \
/* Test introduit le 20080303095038. */ \
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]. Ceci fut introduit */ \
/* le 20080302094151... */ \
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 (ceci fut introduit le 20080224113729...). */ \
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(IFET(IFGE(compteur_de_tentatives_de_perturbation,nombre_maximal_de_tentatives_de_perturbation) \
,IL_NE_FAUT_PAS(faire_uniquement_calcul_et_edition_matrice_des_distances_triee_sans_iterations) \
) \
) \
/* Le 20080318112943 a ete ajoute le test relatif a l'absence d'iterations... */ \
Bblock \
Test(IL_FAUT(editer_le_message_de_depassement_des_tentatives_de_perturbation)) \
/* Possibilite introduite le 20150615161855... */ \
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 MATRICE_DES_DISTANCES(index_i,index_j) \
IdTb2(matrice_des_distances \
,INDX(index_i,PREMIER_ELEMENT_D_UN_FICHIER),nombre_maximal_d_elements_dans_le_fichier \
,INDX(index_j,PREMIER_ELEMENT_D_UN_FICHIER),nombre_maximal_d_elements_dans_le_fichier \
) \
/* Acces a un element courant de 'matrice_des_distances'... */
DEFV(Local,DEFV(Float,DdTb2(POINTERf
,matrice_des_distances
,nombre_maximal_d_elements_dans_le_fichier,nombre_maximal_d_elements_dans_le_fichier
,ADRESSE_NON_ENCORE_DEFINIE
)
)
);
/* Matrice des distances des points deux a deux (introduite le 20080225161158)... */
#define MATRICE_DES_VOISINS(index_i,index_j) \
IdTb2(matrice_des_voisins \
,INDX(index_i,PREMIER_ELEMENT_D_UN_FICHIER),nombre_maximal_d_elements_dans_le_fichier \
,INDX(index_j,PREMIER_ELEMENT_D_UN_FICHIER),nombre_maximal_d_elements_dans_le_fichier \
) \
/* Acces a un element courant de 'matrice_des_voisins'... */
DEFV(Local,DEFV(Int,DdTb2(POINTERi
,matrice_des_voisins
,nombre_maximal_d_elements_dans_le_fichier,nombre_maximal_d_elements_dans_le_fichier
,ADRESSE_NON_ENCORE_DEFINIE
)
)
);
/* Matrice des voisins de chaque point (introduite le 20080227101546). L'element {i,j} */
/* donne le j-ieme voisin du point d'index 'i'. */
DEFV(Local,DEFV(Logical,INIT(la_matrice_des_voisins_est_necessaire,FAUX)));
/* Indique si 'matrice_des_voisins' est necessaire ou pas... */
DEFV(Local,DEFV(Int,INIT(le_plus_mauvais_point_a_ete_trouve,LUNDEF)));
DEFV(Local,DEFV(Int,INIT(en_fait_le_plus_mauvais_point_a_ete_tire_au_sort,LUNDEF)));
DEFV(Local,DEFV(Int,INIT(index_du_plus_mauvais_point,UNDEF)));
/* Definition du plus mauvais point, c'est-a-dire celui qui est le plus loin de son plus */
/* proche voisin... */
/* */
/* On notera le 20080229090506 que lorsque tous les points occupent initialement la meme */
/* position, alors le plus mauvais point reste constamment le premier point qui ne bouge */
/* alors pas (meme si ce n'est pas l'eventuel point fixe...) si l'on a de plus : */
/* */
/* choisir_les_points_a_perturber_aleatoirement = FAUX */
/* choisir_les_points_a_perturber_dans_le_voisinage_du_plus_mauvais_point = VRAI */
/* ponderation_minimale_de_l_interpolation_de_perturbation_d_une_coordonnee = 1 */
/* ponderation_maximale_de_l_interpolation_de_perturbation_d_une_coordonnee = 1 */
/* */
/* et ainsi tous les points restent confondus avec le premier (qui est le plus mauvais...). */
#define LISTE_DES_DISTANCES_DU_POINT_i_AUX_AUTRES_POINTS(index) \
gELEMENT_DU_FICHIER(liste_des_distances_du_point_i_aux_autres_points,index) \
/* Acces a un element courant de 'liste_des_distances_du_point_i_aux_autres_points'... */
#define LISTE_DES_VOISINS_DU_POINT_i(index) \
gELEMENT_DU_FICHIER(liste_des_voisins_du_point_i,index) \
/* Acces a un element courant de 'liste_des_voisins_du_point_i'... */
#define ACCES_DISTANCE(liste,index) \
IdTb1(liste,index,nombre_maximal_d_elements_dans_le_fichier) \
/* Afin de pouvoir utiliser 'TRI_D_UNE_LISTE_QUELCONQUE(...)'. */
#define COMPATIBILITE_20080305 \
FAUX \
/* Permet de faire des calculs compatibles a ceux faits anterieurement au 20080305114954... */
#define DISTANCE_MINIMALE(distance_minimale) \
Bblock \
DEFV(Int,INIT(DM_index_i,UNDEF)); \
DEFV(Int,INIT(DM_index_j,UNDEF)); \
\
EGAL(distance_minimale,F_INFINI); \
\
DoIn(DM_index_i,PREMIER_ELEMENT_D_UN_FICHIER,DERNIER_ELEMENT_D_UN_FICHIER,I) \
Bblock \
DoIn(DM_index_j,PREMIER_ELEMENT_D_UN_FICHIER,DERNIER_ELEMENT_D_UN_FICHIER,I) \
Bblock \
Test(IFGT(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(MATRICE_DES_DISTANCES(DM_index_i,DM_index_j),distance_courante); \
EGAL(MATRICE_DES_DISTANCES(DM_index_j,DM_index_i),distance_courante); \
/* Memorisation de la distance entre les points {DM_index_i,DM_index_j} qui est evidemment */ \
/* egale a celle entre les points {DM_index_j,DM_index_i}... */ \
\
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 \
/* On notera que la diagonale 'DM_index_i=DM_index_j' est toujours a zero (par */ \
/* initialisation...). */ \
Eblock \
ETes \
Eblock \
EDoI \
Eblock \
EDoI \
\
Test(IFOU(IL_FAUT(forcer_le_calcul_de_la_matrice_des_voisins) \
,EST_VRAI(la_matrice_des_voisins_est_necessaire) \
) \
) \
/* Test introduit le 20080225163034. */ \
Bblock \
DEFV(Float,INIT(distance_maximale,F_MOINS_L_INFINI)); \
\
EGAL(le_plus_mauvais_point_a_ete_trouve,FAUX); \
/* A priori, pas de plus mauvais point (introduit le 20080226091236). */ \
\
DoIn(DM_index_i,PREMIER_ELEMENT_D_UN_FICHIER,DERNIER_ELEMENT_D_UN_FICHIER,I) \
Bblock \
gGENERATION_D_UN_FICHIER_liste(liste_des_distances_du_point_i_aux_autres_points); \
gGENERATION_D_UN_FICHIER_liste(liste_des_voisins_du_point_i); \
\
iGENERATION_D_UN_FICHIER(liste_des_distances_du_point_i_aux_autres_points,FLOT__UNDEF); \
iGENERATION_D_UN_FICHIER(liste_des_voisins_du_point_i,UNDEF); \
\
DoIn(DM_index_j,PREMIER_ELEMENT_D_UN_FICHIER,DERNIER_ELEMENT_D_UN_FICHIER,I) \
Bblock \
EGAL(LISTE_DES_DISTANCES_DU_POINT_i_AUX_AUTRES_POINTS(DM_index_j) \
,MATRICE_DES_DISTANCES(DM_index_i,DM_index_j) \
); \
/* Recuperation de la liste des distances du point 'DM_index_i' a tous les autres (y compris */ \
/* lui-meme...). */ \
EGAL(LISTE_DES_VOISINS_DU_POINT_i(DM_index_j),DM_index_j); \
/* Et initialisation de la future liste des index tries... */ \
Eblock \
EDoI \
\
TRI_D_UNE_LISTE_QUELCONQUE(liste_des_distances_du_point_i_aux_autres_points \
,liste_des_voisins_du_point_i \
,PREMIER_ELEMENT_D_UN_FICHIER \
,DERNIER_ELEMENT_D_UN_FICHIER \
,EST_CE_LE_TRI_AUTOMATIQUE_D_UNE_LISTE_QUELCONQUE \
,EST_CE_LE_TRI_N_AU_CARRE_D_UNE_LISTE_QUELCONQUE \
,ACCES_DISTANCE \
); \
/* L'argument 'EST_CE_LE_TRI_AUTOMATIQUE_D_UNE_LISTE_QUELCONQUE' a ete introduit le */ \
/* 20170608104350... */ \
\
DoIn(DM_index_j,PREMIER_ELEMENT_D_UN_FICHIER,DERNIER_ELEMENT_D_UN_FICHIER,I) \
Bblock \
EGAL(MATRICE_DES_VOISINS(DM_index_i,DM_index_j) \
,LISTE_DES_VOISINS_DU_POINT_i(DM_index_j) \
); \
/* Generation de la liste des voisins du point 'i' : en toute logique, le premier element */ \
/* de cette liste doit donner 'i' lui-meme (puisque chaque point est evidemment son plus */ \
/* proche voisin -a distance nulle-) ; le deuxieme element donnera le point le plus proche */ \
/* (different de 'i') et ainsi de suite... */ \
Eblock \
EDoI \
\
lGENERATION_D_UN_FICHIER(liste_des_voisins_du_point_i,UNDEF); \
lGENERATION_D_UN_FICHIER(liste_des_distances_du_point_i_aux_autres_points,FLOT__UNDEF); \
Eblock \
EDoI \
\
DoIn(DM_index_i,PREMIER_ELEMENT_D_UN_FICHIER,DERNIER_ELEMENT_D_UN_FICHIER,I) \
Bblock \
DEFV(Float,INIT(distance_minimale_ou_maximale_au_point_i,F_INFINI)); \
DEFV(Logical,INIT(la_distance_minimale_ou_maximale_au_point_i_a_ete_evaluee,FAUX)); \
\
DoIn(DM_index_j \
,SUCC(PREMIER_ELEMENT_D_UN_FICHIER) \
,SUCC(LSTX(PREMIER_ELEMENT_D_UN_FICHIER,nombre_de_points_dans_un_voisinage)) \
,I \
) \
Bblock \
DEFV(Float,INIT(distance_courante \
,MATRICE_DES_DISTANCES(DM_index_i,MATRICE_DES_VOISINS(DM_index_i,DM_index_j)) \
) \
); \
\
Test(IZGT(distance_courante)) \
Bblock \
EGAL(distance_minimale_ou_maximale_au_point_i \
,COND(IL_FAUT(compatibilite_20080305) \
,MIN2(distance_minimale_ou_maximale_au_point_i \
,distance_courante \
) \
,MAX2(distance_minimale_ou_maximale_au_point_i \
,distance_courante \
) \
) \
); \
EGAL(la_distance_minimale_ou_maximale_au_point_i_a_ete_evaluee,VRAI); \
/* On recherche ici la distance minimale du point 'DM_index_i' a ses plus proches */ \
/* voisins {MATRICE_DES_VOISINS(DM_index_i,DM_index_j)}. */ \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
EDoI \
\
Test(EST_VRAI(la_distance_minimale_ou_maximale_au_point_i_a_ete_evaluee)) \
Bblock \
Test(IZGT(distance_minimale_ou_maximale_au_point_i)) \
/* Le 20080226091236 a ete ajoute ce test. Ainsi, on ignore les distances nulles qui */ \
/* correspondent bien souvent a des conditions initiales particulieres ou tous les points */ \
/* sont confondus. Cela permet donc d'attendre qu'ils se soient alors eloignes tous les */ \
/* uns des autres... */ \
Bblock \
Test(IFGT(distance_minimale_ou_maximale_au_point_i,distance_maximale)) \
Bblock \
EGAL(distance_maximale,distance_minimale_ou_maximale_au_point_i); \
EGAL(index_du_plus_mauvais_point,DM_index_i); \
EGAL(le_plus_mauvais_point_a_ete_trouve,VRAI); \
EGAL(en_fait_le_plus_mauvais_point_a_ete_tire_au_sort,FAUX); \
/* On recherche ici le plus mauvais point, c'est-a-dire celui qui est le plus loin */ \
/* ('distance_maximale') de l'un de ses plus proches voisins -le premier ou le dernier- */ \
/* ('distance_minimale_ou_maximale_au_point_i')... */ \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
EDoI \
\
Test(EST_FAUX(le_plus_mauvais_point_a_ete_trouve)) \
Bblock \
GENERATION_D_UNE_VALEUR(index_du_plus_mauvais_point \
,FLOT(PREMIER_ELEMENT_D_UN_FICHIER) \
,ADD2(FLOT(DERNIER_ELEMENT_D_UN_FICHIER) \
,SOUS(FU,mgEPSILON) \
) \
); \
EGAL(le_plus_mauvais_point_a_ete_trouve,VRAI); \
EGAL(en_fait_le_plus_mauvais_point_a_ete_tire_au_sort,VRAI); \
/* Lorsque le "vrai" plus mauvais point n'a pas ete trouve, on en tire au sort... */ \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
/* Calcul de la distance minimale a un instant donne. */
#define EDITION_DE_LA_MATRICE_DES_DISTANCES \
Bblock \
Test(IL_FAUT(editer_la_matrice_des_distances)) \
Bblock \
DEFV(Int,INIT(EMD_index_i,UNDEF)); \
DEFV(Int,INIT(EMD_index_j,UNDEF)); \
/* Index de parcours des matrices... */ \
\
Test(IL_NE_FAUT_PAS(editer_la_matrice_des_distances_triee_suivant_la_matrice_des_voisins)) \
Bblock \
DoIn(EMD_index_i,PREMIER_ELEMENT_D_UN_FICHIER,DERNIER_ELEMENT_D_UN_FICHIER,I) \
Bblock \
DoIn(EMD_index_j \
,PREMIER_ELEMENT_D_UN_FICHIER \
,DERNIER_ELEMENT_D_UN_FICHIER \
,I \
) \
Bblock \
CAL3(Prme4(" d(%0*d,%0*d)=" \
,NOMBRE_DE_CHIFFRES_DECIMAUX(nombre_d_elements) \
,EMD_index_i \
,NOMBRE_DE_CHIFFRES_DECIMAUX(nombre_d_elements) \
,EMD_index_j \
) \
); \
gEDITION_DANS_gOPERATION_SUR_LES_FICHIERS(MATRICE_DES_DISTANCES(EMD_index_i,EMD_index_j) \
,CAL3,Prme1,Prme2 \
); \
Eblock \
EDoI \
\
CALS(Fsauts_de_lignes(UN)); \
Eblock \
EDoI \
Eblock \
ATes \
Bblock \
Test(IFOU(IL_FAUT(forcer_le_calcul_de_la_matrice_des_voisins) \
,EST_VRAI(la_matrice_des_voisins_est_necessaire) \
) \
) \
Bblock \
DoIn(EMD_index_i \
,PREMIER_ELEMENT_D_UN_FICHIER \
,DERNIER_ELEMENT_D_UN_FICHIER \
,I \
) \
Bblock \
DoIn(EMD_index_j \
,SUCC(PREMIER_ELEMENT_D_UN_FICHIER) \
,SUCC(LSTX(PREMIER_ELEMENT_D_UN_FICHIER \
,nombre_elements_matrice_des_distances_triee_suivant_la_matrice_des_voisins \
) \
) \
,I \
) \
Bblock \
DEFV(Int,INIT(index_j_trie,MATRICE_DES_VOISINS(EMD_index_i,EMD_index_j))); \
\
CAL3(Prme4(" d(%0*d,%0*d)=" \
,NOMBRE_DE_CHIFFRES_DECIMAUX(nombre_d_elements) \
,EMD_index_i \
,NOMBRE_DE_CHIFFRES_DECIMAUX(nombre_d_elements) \
,index_j_trie \
) \
); \
gEDITION_DANS_gOPERATION_SUR_LES_FICHIERS(MATRICE_DES_DISTANCES(EMD_index_i,index_j_trie) \
,CAL3,Prme1,Prme2 \
); \
Eblock \
EDoI \
\
CALS(Fsauts_de_lignes(UN)); \
Eblock \
EDoI \
Eblock \
ATes \
Bblock \
PRINT_ATTENTION("l'edition de la matrice des distances triees suivant les voisins n'a pas de sens"); \
Eblock \
ETes \
Eblock \
ETes \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
/* Edition de la matrice des distances (introduite sous cette forme le 20080229211010). */
#define EDITION_DE_LA_MATRICE_DES_VOISINS \
Bblock \
Test(IL_FAUT(editer_la_matrice_des_voisins)) \
Bblock \
Test(IFOU(IL_FAUT(forcer_le_calcul_de_la_matrice_des_voisins) \
,EST_VRAI(la_matrice_des_voisins_est_necessaire) \
) \
) \
Bblock \
DEFV(Int,INIT(EMV_index_i,UNDEF)); \
DEFV(Int,INIT(EMV_index_j,UNDEF)); \
/* Index de parcours des matrices... */ \
\
DoIn(EMV_index_i,PREMIER_ELEMENT_D_UN_FICHIER,DERNIER_ELEMENT_D_UN_FICHIER,I) \
Bblock \
DoIn(EMV_index_j \
,PREMIER_ELEMENT_D_UN_FICHIER \
,DERNIER_ELEMENT_D_UN_FICHIER \
,I \
) \
Bblock \
CAL3(Prme6(" v(%0*d,%0*d)=%0*d" \
,NOMBRE_DE_CHIFFRES_DECIMAUX(nombre_d_elements) \
,EMV_index_i \
,NOMBRE_DE_CHIFFRES_DECIMAUX(nombre_d_elements) \
,EMV_index_j \
,NOMBRE_DE_CHIFFRES_DECIMAUX(nombre_d_elements) \
,MATRICE_DES_VOISINS(EMV_index_i,EMV_index_j) \
) \
); \
Eblock \
EDoI \
\
CALS(Fsauts_de_lignes(UN)); \
Eblock \
EDoI \
\
CAL3(Prme1("PlusMauvaisPoint=%d\n",index_du_plus_mauvais_point)); \
/* Edition introduite le 20080229211010... */ \
CALS(Fsauts_de_lignes(UN)); \
Eblock \
ATes \
Bblock \
PRINT_ATTENTION("l'edition de la matrice des voisins n'a pas de sens ici"); \
Eblock \
ETes \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
/* Edition de la matrice des voisins (introduite sous cette forme le 20080229211010). */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* 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(faire_uniquement_calcul_et_edition_matrice_des_distances_triee_sans_iterations
,FAIRE_UNIQUEMENT_CALCUL_ET_EDITION_MATRICE_DES_DISTANCES_TRIEE_SANS_ITERATIONS
)
);
/* Introduit le 20080307081422 afin de permettre de calculer et d'editer la matrice des */
/* distances triees associee a un ensemble initial {X(i),Y(i),Z(i)} (ou evidemment */
/* {Rho(i),Theta(i),Phi(i)}) sans enclencher le processus d'optimisation... */
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));
/* Introduit le 20080307100250 afin d'etre utilise en conjonction avec l'option */
/* 'faire_uniquement_le_calcul_et_l_edition_de_la_matrice_des_distances_triee_sans_...'. */
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... */
/* */
/* Ce parametre est en fait un garde-fou destine a limiter le nombre des 'Tant(...)'s */
/* qui l'utilisent... */
DEFV(Int,INIT(nombre_maximal_de_tentatives_de_perturbation,NOMBRE_MAXIMAL_DE_TENTATIVES_DE_PERTURBATION));
/* Introduit le201506151618550 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 20150615161855... */
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. Ceci fut */
/* introduit le 20080225134521 afin que 'PERTURBATION_ALEATOIRE(...)' puisse reprendre */
/* periodiquement des valeurs egales aux valeurs initiales... */
DEFV(Logical,INIT(utiliser_l_interpolation_cubique,UTILISER_L_INTERPOLATION_CUBIQUE));
/* Doit-on utiliser 'INTERPOLATION_CUBIQUE(...)' ('VRAI') ou 'INTERPOLATION_LINEAIRE(...)' */
/* ('FAUX') ? Ceci fut introduit le 20080224104855 pour ameliorer les performances... */
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(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 20150616135554). */
DEFV(Logical,INIT(forcer_le_calcul_de_la_matrice_des_voisins,FORCER_LE_CALCUL_DE_LA_MATRICE_DES_VOISINS));
/* Indique si la calcul de la matrice des voisins doit etre fait meme s'il n'est pas utile */
/* ('VRAI')ou pas ('FAUX'). Ceci fut introduit le 20080301095446 afin des fins de mise au */
/* point... */
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'). Ceci fut introduit le 20080228095755... */
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 (introduit le 20080303100321...). */
DEFV(Logical,INIT(choisir_effectivement_les_points_a_perturber_dans_le_voisinage_du_plus_mauvais_point,LUNDEF));
DEFV(Logical,INIT(choisir_les_points_a_perturber_dans_le_voisinage_du_plus_mauvais_point
,CHOISIR_LES_POINTS_A_PERTURBER_DANS_LE_VOISINAGE_DU_PLUS_MAUVAIS_POINT
)
);
/* Indique si les points a perturber sont a choisir en fonction du voisinage du plus mauvais */
/* point ('VRAI') ou autrement ('FAUX') ? */
/* */
/* On notera le 20080229090506 que lorsque tous les points occupent initialement la meme */
/* position, alors le plus mauvais point reste constamment le premier point qui ne bouge */
/* alors pas (meme si ce n'est pas l'eventuel point fixe...) si l'on a de plus : */
/* */
/* choisir_les_points_a_perturber_aleatoirement = FAUX */
/* choisir_les_points_a_perturber_dans_le_voisinage_du_plus_mauvais_point = VRAI */
/* ponderation_minimale_de_l_interpolation_de_perturbation_d_une_coordonnee = 1 */
/* ponderation_maximale_de_l_interpolation_de_perturbation_d_une_coordonnee = 1 */
/* */
/* et ainsi tous les points restent confondus avec le premier (qui est le plus mauvais...). */
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. Ceci fut introduit le 20080228095755... */
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. Ceci fut introduit */
/* le 20080304085009... */
DEFV(Logical,INIT(compatibilite_20080305,COMPATIBILITE_20080305));
/* Permet de faire des calculs compatibles a ceux faits anterieurement au 20080305114954... */
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(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(...)'. Ceci fut introduit de facon deterministe le */
/* 20080228205916 et de facon aleatoire le 20080229183023... */
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 (possibilite introduite le 20080224095738) ? */
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(editer_la_matrice_des_distances,EDITER_LA_MATRICE_DES_DISTANCES));
DEFV(Logical,INIT(editer_la_matrice_des_distances_triee_suivant_la_matrice_des_voisins
,EDITER_LA_MATRICE_DES_DISTANCES_TRIEE_SUIVANT_LA_MATRICE_DES_VOISINS
)
);
DEFV(Int,INIT(nombre_elements_matrice_des_distances_triee_suivant_la_matrice_des_voisins
,NOMBRE_ELEMENTS_MATRICE_DES_DISTANCES_TRIEE_SUIVANT_LA_MATRICE_DES_VOISINS
)
);
DEFV(Logical,INIT(editer_la_matrice_des_voisins,EDITER_LA_MATRICE_DES_VOISINS));
/* Doit-on editer les matrices des distances et des vosins (introduit le 20080227180930)... */
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(GET_ARGUMENT_L("compatibilite_20080305=",compatibilite_20080305);
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("uniquement_matrice_distances=""umd=""pas_d_iterations=""no_iterations=""ni="
,faire_uniquement_calcul_et_edition_matrice_des_distances_triee_sans_iterations
);
GET_ARGUMENT_N("faire_des_iterations=""fdi="
,faire_uniquement_calcul_et_edition_matrice_des_distances_triee_sans_iterations
);
/* Possibilite introduite le 20080307081422... */
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 20080229171215 et les abbreviations */
/* le 20080307081422... */
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 20080229171215 et les abbreviations */
/* le 20080307081422... */
GET_ARGUMENT_L("sortir=",sortir_les_coordonnees_optimisees);
GET_ARGUMENT_N("pas_sortir=",sortir_les_coordonnees_optimisees);
/* Parametres introduits le 20080307100250... */
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 20150615161855... */
GET_ARGUMENT_L("message_trop_de_perturbations=""mtp="
,editer_le_message_de_depassement_des_tentatives_de_perturbation
);
/* Parametres introduits le 20150615161855... */
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_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 20150616135554... */
GET_ARGUMENT_L("forcer_la_matrice_des_voisins=""fmv=",forcer_le_calcul_de_la_matrice_des_voisins);
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_L("plus_mauvais_point=""pmp="
,choisir_les_points_a_perturber_dans_le_voisinage_du_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
);
GET_ARGUMENT_L("editer_matrice_distances=""emd=",editer_la_matrice_des_distances);
GET_ARGUMENT_L("editer_matrice_distances_triee=""emdt=""emdv="
,editer_la_matrice_des_distances_triee_suivant_la_matrice_des_voisins
);
GET_ARGUMENT_I("nombre_points_matrice_distances_triee=""npmdt=""npmdv="
,nombre_elements_matrice_des_distances_triee_suivant_la_matrice_des_voisins
);
GET_ARGUMENT_L("editer_matrice_voisins=""emv=",editer_la_matrice_des_voisins);
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... */
)
);
Test(IL_FAUT(faire_uniquement_calcul_et_edition_matrice_des_distances_triee_sans_iterations))
/* Possibilite introduite le 20080307081422... */
Bblock
EGAL(nombre_d_iterations_d_optimisation,UN);
EGAL(forcer_le_calcul_de_la_matrice_des_voisins,VRAI);
EGAL(choisir_les_points_a_perturber_aleatoirement,FAUX);
EGAL(rho__delta_initial,FZERO);
EGAL(rho__delta_final,FZERO);
EGAL(phi__delta_initial,FZERO);
EGAL(phi__delta_final,FZERO);
EGAL(theta_delta_initial,FZERO);
EGAL(theta_delta_final,FZERO);
EGAL(ponderation_minimale_de_l_interpolation_de_perturbation_d_une_coordonnee,FZERO);
EGAL(ponderation_maximale_de_l_interpolation_de_perturbation_d_une_coordonnee,FZERO);
EGAL(sortir_les_coordonnees_optimisees,FAUX);
EGAL(editer_la_matrice_des_distances,VRAI);
EGAL(editer_la_matrice_des_distances_triee_suivant_la_matrice_des_voisins,VRAI);
Eblock
ATes
Bblock
Eblock
ETes
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
Test(IL_FAUT(editer_la_matrice_des_distances))
Bblock
Test(IL_FAUT(editer_la_matrice_des_distances_triee_suivant_la_matrice_des_voisins))
Bblock
Test(IFGE(nombre_elements_matrice_des_distances_triee_suivant_la_matrice_des_voisins,nombre_d_elements))
Bblock
PRINT_ATTENTION("le nombre de points a editer est superieur ou egal au nombre de points, il est donc seuille");
EGAL(nombre_elements_matrice_des_distances_triee_suivant_la_matrice_des_voisins,PRED(nombre_d_elements));
CAL1(Prer1("(le nombre de points a editer vaut donc %d)\n"
,nombre_elements_matrice_des_distances_triee_suivant_la_matrice_des_voisins
)
);
Eblock
ATes
Bblock
Eblock
ETes
Eblock
ATes
Bblock
Eblock
ETes
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);
/* Ceci est rendu obligatoire par l'allocation dynamique de la memoire (le 20060214192917). */
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... */
MdTb2(matrice_des_distances
,nombre_maximal_d_elements_dans_le_fichier,nombre_maximal_d_elements_dans_le_fichier
,Float
,ADRESSE_NON_ENCORE_DEFINIE
);
/* Allocation de la matrice des distances des points deux a deux... */
MdTb2(matrice_des_voisins
,nombre_maximal_d_elements_dans_le_fichier,nombre_maximal_d_elements_dans_le_fichier
,Int
,ADRESSE_NON_ENCORE_DEFINIE
);
/* Allocation de la matrice des voisins de chaque point... */
begin_nouveau_block
Bblock
DEFV(Int,INIT(index_i,UNDEF));
DEFV(Int,INIT(index_j,UNDEF));
/* Index de parcours des matrices... */
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
EGAL(MATRICE_DES_DISTANCES(index_i,index_j),FZERO);
/* Par precaution ; cela est surtout destine a nettoyer la diagonale qui sans cela ne */
/* serait jamais initialisee et zero est de plus la bonne valeur puisque : */
/* */
/* distance(i,j) = 0 */
/* */
/* pour i=j... */
EGAL(MATRICE_DES_VOISINS(index_i,index_j),UNDEF);
/* Par precaution... */
Eblock
EDoI
Eblock
EDoI
Eblock
end_nouveau_block
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);
EGAL(choisir_effectivement_les_points_a_perturber_dans_le_voisinage_du_plus_mauvais_point
,choisir_les_points_a_perturber_dans_le_voisinage_du_plus_mauvais_point
);
/* 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)
);
EGAL(choisir_effectivement_les_points_a_perturber_dans_le_voisinage_du_plus_mauvais_point
,NOTL(choisir_les_points_a_perturber_dans_le_voisinage_du_plus_mauvais_point)
);
/* En fait, la selection des points a perturber ne sera pas aleatoire... */
Eblock
ETes
Eblock
ATes
Bblock
Eblock
ETes
Test(IFET(IL_NE_FAUT_PAS(choisir_effectivement_les_points_a_perturber_aleatoirement)
,IL_FAUT(choisir_effectivement_les_points_a_perturber_dans_le_voisinage_du_plus_mauvais_point)
)
)
Bblock
EGAL(la_matrice_des_voisins_est_necessaire,VRAI);
Eblock
ATes
Bblock
EGAL(la_matrice_des_voisins_est_necessaire,FAUX);
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(la_distance_minimale_vient_d_augmenter))
Bblock
Test(IFET(IFEQ(iteration_courante,PREMIERE_ITERATION_D_UN_Komp)
,IZEQ(nombre_de_tentatives_effectuees)
)
)
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(IL_FAUT(editer_toutes_les_distances_minimales))
Bblock
CAL2(Prin0(" DistanceMinimale="));
EDITION_DANS_gOPERATION_SUR_LES_FICHIERS_AVEC_SAUT_DE_LIGNE(distance_minimale_avant_la_perturbation);
/* Introduit sous cette forme le 20160804100115... */
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(" DistanceMinimaleInitiale="));
EDITION_DANS_gOPERATION_SUR_LES_FICHIERS_AVEC_SAUT_DE_LIGNE(distance_minimale_avant_la_perturbation);
/* Introduit sous cette forme le 20160804100115... */
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
Test(IL_FAUT(choisir_effectivement_les_points_a_perturber_dans_le_voisinage_du_plus_mauvais_point))
Bblock
Test(EST_VRAI(le_plus_mauvais_point_a_ete_trouve))
Bblock
DoIn(index_i
,SUCC(PREMIER_ELEMENT_D_UN_FICHIER)
,SUCC(LSTX(PREMIER_ELEMENT_D_UN_FICHIER,nombre_de_points_dans_un_voisinage))
,I
)
Bblock
EGAL(LE_POINT_EST_IL_A_PERTURBER(MATRICE_DES_VOISINS(index_du_plus_mauvais_point,index_i))
,VRAI
);
/* Le point 'i' est a perturber car, en effet, il est un des premiers voisins du plus */
/* mauvais point... */
Eblock
EDoI
Eblock
ATes
Bblock
PRINT_ATTENTION("il n'y a pas de plus mauvais point (1)");
Eblock
ETes
Eblock
ATes
Bblock
PRINT_ATTENTION("le choix non aleatoire des points a perturber n'est pas encore implemente");
Eblock
ETes
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));
Test(IL_NE_FAUT_PAS(choisir_effectivement_les_points_a_perturber_aleatoirement))
Bblock
Test(IL_FAUT(choisir_effectivement_les_points_a_perturber_dans_le_voisinage_du_plus_mauvais_point))
Bblock
Test(EST_VRAI(le_plus_mauvais_point_a_ete_trouve))
Bblock
EGAL(Rho__de_reference,ELEMENT_DU_FICHIER_LISTE_RHO_(index_du_plus_mauvais_point));
EGAL(Phi__de_reference,ELEMENT_DU_FICHIER_LISTE_PHI_(index_du_plus_mauvais_point));
EGAL(Theta_de_reference,ELEMENT_DU_FICHIER_LISTE_THETA(index_du_plus_mauvais_point));
Eblock
ATes
Bblock
PRINT_ATTENTION("il n'y a pas de plus mauvais point (2)");
/* Message introduit le 20080307162828... */
Eblock
ETes
Eblock
ATes
Bblock
Eblock
ETes
Eblock
ATes
Bblock
Eblock
ETes
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 : je note le 20150615161855 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_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
DISTANCE_MINIMALE(distance_minimale_apres_la_perturbation);
/* Recherche de la distance minimale apres la perturbation. */
Test(IL_FAUT(choisir_effectivement_les_points_a_perturber_aleatoirement))
/* Ce test fut introduit le 20080301175424... */
Bblock
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... */
/* */
/* On rappelle le 20080302104543 que l'on maximise la distance minimale, ce qui signifie */
/* que l'on cherche a augmenter celle-ci, c'est-a-dire qu'a priori, il faut que l'on ait */
/* ici : */
/* */
/* Dapres >= Davant */
/* */
/* (ou "Dxxxxx" signifie evidemment "distance_minimale_xxxxx_la_perturbation"). Avec les */
/* valeurs par defaut des probabilites, le 'Test(...)' precedent est VRAI si : */
/* */
/* (Dapres < Davant) .AND. (P < 0.05) [1] */
/* */
/* .OR. : */
/* */
/* (Dapres >= Davant) .AND. (P >= 0) [2] */
/* */
/* (ou "P" designe "probabilite_courante"), la condition [2] signifiant que toutes les */
/* solutions maximisant 'Dapres' (Dapres >= Davant) sont acceptees (puisque evidemment */
/* on a toujours 'P >= 0'...). */
/* */
/* Le 20150616135554 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 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 (ceci fut introduit le 20080301175424...). */
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(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(" DistanceMinimaleFinale="));
EDITION_DANS_gOPERATION_SUR_LES_FICHIERS_AVEC_SAUT_DE_LIGNE(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... */
/* */
/* Introduit sous cette forme le 20160804100115... */
Eblock
ATes
Bblock
Eblock
ETes
Eblock
ETes
INCR(nombre_de_tentatives_effectuees,I);
/* Et une tentative de plus... */
Eblock
ETan
Eblock
EKom
EDITION_DE_LA_MATRICE_DES_DISTANCES;
/* Edition eventuelle introduite le 20080227180930... */
EDITION_DE_LA_MATRICE_DES_VOISINS;
/* Edition eventuelle introduite le 20080227180930... */
Test(IL_FAUT(sortir_les_coordonnees_optimisees))
/* Possibilite introduite le 20080307100250... */
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
FdTb2(matrice_des_voisins
,nombre_maximal_d_elements_dans_le_fichier,nombre_maximal_d_elements_dans_le_fichier
,Int
,ADRESSE_NON_ENCORE_DEFINIE
);
/* Matrice des voisins de chaque point (introduite le 20080227101546). L'element {i,j} */
/* donne le j-ieme voisin du point d'index 'i'. */
FdTb2(matrice_des_distances
,nombre_maximal_d_elements_dans_le_fichier,nombre_maximal_d_elements_dans_le_fichier
,Float
,ADRESSE_NON_ENCORE_DEFINIE
);
/* Liberation de la matrice des distances des points deux a deux (introduite le */
/* 20080226090233...). */
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