/*************************************************************************************************************************************/
/* */
/* 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 C A R T E S I E N N 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 */
/* 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 : */
/* */
/* */
/* Author of '$xrv/optimise.23$K' : */
/* */
/* Jean-Francois COLONNA (LACTAMME, 20150617150031). */
/* */
/*************************************************************************************************************************************/
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* 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 SORTIR_LES_COORDONNEES_OPTIMISEES \
VRAI
#define NOMBRE_D_ITERATIONS_D_OPTIMISATION \
CENT_MILLE \
/* Nombre d'iterations maximum... */
#define UTILISER_UNE_DISTANCE_DE_REFERENCE \
VRAI
#define EVALUER_LA_DISTANCE_DE_REFERENCE \
VRAI
#define DISTANCE_DE_REFERENCE \
FU
/* Definition de la distance dite "de reference" vers laquelle doivent converger les */
/* extrema de toutes les distances. Si elle est evaluee automatiquement, sa valeur est */
/* moyenne des extrema de toutes les distances. */
/* */
/* La possibilite de ne pas employer de distance de reference a ete introduite le */
/* 20150730121008... */
#define X_MINIMUM \
F_MOINS_L_INFINI
#define X_MAXIMUM \
F_INFINI
#define X_DELTA_INITIAL \
NEGA(GRO5(FRA10(FRA10(FU))))
#define X_DELTA_FINAL \
NEUT(GRO5(FRA10(FRA10(FU))))
/* Definition de la coordonnee cartesienne 'X'. */
#define Y_MINIMUM \
F_MOINS_L_INFINI
#define Y_MAXIMUM \
F_INFINI
#define Y_DELTA_INITIAL \
NEGA(GRO5(FRA10(FRA10(FU))))
#define Y_DELTA_FINAL \
NEUT(GRO5(FRA10(FRA10(FU))))
/* Definition de la coordonnee cartesienne 'Y'. */
#define Z_MINIMUM \
F_MOINS_L_INFINI
#define Z_MAXIMUM \
F_INFINI
#define Z_DELTA_INITIAL \
NEGA(GRO5(FRA10(FRA10(FU))))
#define Z_DELTA_FINAL \
NEUT(GRO5(FRA10(FRA10(FU))))
/* Definition de la coordonnee cartesienne 'Z'. */
#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 EDITER_LE_MESSAGE_DE_RISQUE_DE_NON_PERTURBATION \
FAUX \
/* Afin de pouvoir inhiber le message de risque de non perturbation... */
#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 EPSILON_DE_CONVERGENCE \
igEPSILON \
/* Epsilon permettant d'arreter le processus lorsque le minimum et le maximum des */ \
/* des distances minimales sont proches l'un de l'autre... */
#define EDITER_TOUTES_LES_DISTANCES_EXTREMALES \
FAUX \
/* Doit-on editer toutes les distances extremales pour voir l'amelioration comment converge */ \
/* le processus ? */
#define EDITER_LES_DISTANCES_EXTREMALES_INITIALES_ET_FINALES \
FAUX \
/* Doit-on editer les distances extremales initiale et finale pour voir l'amelioration ? */
#define EDITER_TOUTES_LES_DISTANCES_INITIALES_ET_FINALES \
FAUX \
/* Doit-on editer toutes les distances pour valider le processu ? Ceci a ete introduit le */ \
/* 20150801091712... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* 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 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_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. */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N D E S F I C H I E R S D E C O N N E X I O N : */
/* */
/*************************************************************************************************************************************/
#define NOMBRE_MAXIMAL_DE_PERIODES_DE_LA_SIMULATION \
CENT_MILLE \
/* Definition du nombre d'elements de chacun des treize vecteurs suivants... */ \
/* */ \
/* ATTENTION : evidemment 'NOMBRE_MAXIMAL_DE_PERIODES_DE_LA_SIMULATION' est en fait le */ \
/* nombre maximal de substitutions et non pas un nombre maximal de periodes qui n'a pas */ \
/* de sens ici... */
#include xrq/particle.M2.I"
#include xrq/nucleon.L3.I"
#include xrq/nucleon.Lf.2.I"
dfTRANSFORMAT_31(liste_pA_X,fichier_LISTE_XA,LISTE_XA_IMPLICITE,FZERO)
dfTRANSFORMAT_31(liste_pA_Y,fichier_LISTE_YA,LISTE_YA_IMPLICITE,FZERO)
dfTRANSFORMAT_31(liste_pA_Z,fichier_LISTE_ZA,LISTE_ZA_IMPLICITE,FZERO)
#define ELEMENT_DU_FICHIER_LISTE_XA(index) \
sTRANSFORMAT_31(index,liste_pA_X)
#define ELEMENT_DU_FICHIER_LISTE_YA(index) \
sTRANSFORMAT_31(index,liste_pA_Y)
#define ELEMENT_DU_FICHIER_LISTE_ZA(index) \
sTRANSFORMAT_31(index,liste_pA_Z)
dfTRANSFORMAT_31(liste_pB_X,fichier_LISTE_XB,LISTE_XB_IMPLICITE,FZERO)
dfTRANSFORMAT_31(liste_pB_Y,fichier_LISTE_YB,LISTE_YB_IMPLICITE,FZERO)
dfTRANSFORMAT_31(liste_pB_Z,fichier_LISTE_ZB,LISTE_ZB_IMPLICITE,FZERO)
#define ELEMENT_DU_FICHIER_LISTE_XB(index) \
sTRANSFORMAT_31(index,liste_pB_X)
#define ELEMENT_DU_FICHIER_LISTE_YB(index) \
sTRANSFORMAT_31(index,liste_pB_Y)
#define ELEMENT_DU_FICHIER_LISTE_ZB(index) \
sTRANSFORMAT_31(index,liste_pB_Z)
dTRANSFORMAT_31(liste_des_points_A);
dTRANSFORMAT_31(liste_des_points_B);
/* Listes permettant de passer des index des points 'A' et 'B' a leurs coordonnees {X,Y,Z} */
/* contenues dans les listes {LISTE_X,LISTE_Y,LISTE_Z}... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* M A C R O S U T I L E S : */
/* */
/*************************************************************************************************************************************/
#define RECHERCHE_DES_CONNEXIONS(indice,point) \
Bblock \
DoIn(index`indice,PREMIER_ELEMENT_D_UN_FICHIER,DERNIER_ELEMENT_D_UN_FICHIER,I) \
/* Parcours de la liste des points (tous differents) : */ \
Bblock \
Test(IFEQ_Rpoints3D(ELEMENT_DU_FICHIER_LISTE_X(index`indice) \
,ELEMENT_DU_FICHIER_LISTE_Y(index`indice) \
,ELEMENT_DU_FICHIER_LISTE_Z(index`indice) \
,sTRANSFORMAT_31(index_c,liste`point`X) \
,sTRANSFORMAT_31(index_c,liste`point`Y) \
,sTRANSFORMAT_31(index_c,liste`point`Z) \
) \
) \
Bblock \
Test(EST_FAUX(index`indice`est_valide)) \
Bblock \
EGAL(save_index`indice,index`indice); \
EGAL(index`indice`est_valide,VRAI); \
Eblock \
ATes \
Bblock \
PRINT_ATTENTION("un point est present plusieurs fois"); \
CAL1(Prer1("(son index est %d)\n",index`indice)); \
Eblock \
ETes \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
EDoI \
Eblock \
/* Etablissement partiel de la liste des connexions... */
#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,delta_final,minimum,maximum) \
Bblock \
DEFV(Int,INIT(compteur_de_tentatives_de_perturbation,ZERO)); \
DEFV(Logical,INIT(perturber,VRAI)); \
DEFV(Float,INIT(Coordonnee_perturbee,FLOT__UNDEF)); \
\
Tant(IL_FAUT(perturber)) \
Bblock \
DEFV(Float,INIT(perturbation_aleatoire_de_la_Coordonnee,FLOT__UNDEF)); \
\
GENERATION_D_UNE_VALEUR(perturbation_aleatoire_de_la_Coordonnee,delta_initial,delta_final); \
/* Generation de la perturbation aleatoire de la coordonnee courante... */ \
\
EGAL(Coordonnee_perturbee \
,ADD2(Coordonnee \
,perturbation_aleatoire_de_la_Coordonnee \
) \
); \
/* Perturbation... */ \
\
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 NUMERO_DE_LA_PREMIERE_CONNEXION \
NUMERO_DE_LA_PREMIERE_PERIODE_DE_LA_SIMULATION
#define nombre_de_connexions \
nombre_de_periodes_de_la_simulation
#define DISTANCE_NON_DEFINIE \
F_INFINI
#define ETUDE_DES_DISTANCES_EXTREMALES(minimum_distances,maximum_distances) \
Bblock \
DEFV(Int,INIT(index_c,UNDEF)); \
\
EGAL(minimum_distances,F_INFINI); \
EGAL(maximum_distances,F_MOINS_L_INFINI); \
\
DoIn(index_c,NUMERO_DE_LA_PREMIERE_CONNEXION,LSTX(NUMERO_DE_LA_PREMIERE_CONNEXION,nombre_de_connexions),I) \
Bblock \
DEFV(Float,INIT(distance_courante \
,RdisF3D(ELEMENT_DU_FICHIER_LISTE_X(INTE(sTRANSFORMAT_31(index_c,liste_des_points_A))) \
,ELEMENT_DU_FICHIER_LISTE_Y(INTE(sTRANSFORMAT_31(index_c,liste_des_points_A))) \
,ELEMENT_DU_FICHIER_LISTE_Z(INTE(sTRANSFORMAT_31(index_c,liste_des_points_A))) \
,ELEMENT_DU_FICHIER_LISTE_X(INTE(sTRANSFORMAT_31(index_c,liste_des_points_B))) \
,ELEMENT_DU_FICHIER_LISTE_Y(INTE(sTRANSFORMAT_31(index_c,liste_des_points_B))) \
,ELEMENT_DU_FICHIER_LISTE_Z(INTE(sTRANSFORMAT_31(index_c,liste_des_points_B))) \
) \
) \
); \
\
EGAL(minimum_distances,MIN2(minimum_distances,distance_courante)); \
EGAL(maximum_distances,MAX2(maximum_distances,distance_courante)); \
/* Le minimum et le maximum sont calcules. */ \
Eblock \
EDoI \
Eblock \
/* Calcul des distances extremales a un instant donne. */
#define SAUVEGARDE_DE_L_ETAT_COURANT \
Bblock \
DEFV(Int,INIT(index,UNDEF)); \
\
DoIn(index,PREMIER_ELEMENT_D_UN_FICHIER,DERNIER_ELEMENT_D_UN_FICHIER,I) \
Bblock \
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 {X,Y,Z}. */ \
Eblock \
EDoI \
\
EGAL(sauvegarde_de_minimum_distances_avant_la_perturbation,minimum_distances_avant_la_perturbation); \
EGAL(sauvegarde_de_maximum_distances_avant_la_perturbation,maximum_distances_avant_la_perturbation); \
Eblock
#define RESTAURATION_DE_L_ETAT_COURANT \
Bblock \
DEFV(Int,INIT(index,UNDEF)); \
\
DoIn(index,PREMIER_ELEMENT_D_UN_FICHIER,DERNIER_ELEMENT_D_UN_FICHIER,I) \
Bblock \
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 {X,Y,Z}. */ \
Eblock \
EDoI \
\
EGAL(minimum_distances_avant_la_perturbation,sauvegarde_de_minimum_distances_avant_la_perturbation); \
EGAL(maximum_distances_avant_la_perturbation,sauvegarde_de_maximum_distances_avant_la_perturbation); \
Eblock
#define EDITION_DES_DISTANCES_EXTREMALES(condition) \
Bblock \
Test(condition) \
Bblock \
CAL3(Prme1("MinimumDistances=%+.^^^",minimum_distances_avant_la_perturbation)); \
CAL3(Prme1(" MaximumDistances=%+.^^^",maximum_distances_avant_la_perturbation)); \
CAL3(Prme1(" MaximumDistances-MinimumDistances=%+.^^^" \
,SOUS(maximum_distances_avant_la_perturbation \
,minimum_distances_avant_la_perturbation \
) \
) \
); \
CALS(Fsauts_de_lignes(UN)); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock
#define EDITION_DE_TOUTES_LES_DISTANCES_INITIALES_ET_FINALES \
Bblock \
Test(IL_FAUT(editer_toutes_les_distances_initiales_et_finales)) \
Bblock \
DEFV(Int,INIT(index,UNDEF)); \
\
DoIn(index,NUMERO_DE_LA_PREMIERE_CONNEXION,LSTX(NUMERO_DE_LA_PREMIERE_CONNEXION,nombre_de_connexions),I) \
Bblock \
DEFV(Float,INIT(distance_courante \
,RdisF3D(ELEMENT_DU_FICHIER_LISTE_X(INTE(sTRANSFORMAT_31(index,liste_des_points_A))) \
,ELEMENT_DU_FICHIER_LISTE_Y(INTE(sTRANSFORMAT_31(index,liste_des_points_A))) \
,ELEMENT_DU_FICHIER_LISTE_Z(INTE(sTRANSFORMAT_31(index,liste_des_points_A))) \
,ELEMENT_DU_FICHIER_LISTE_X(INTE(sTRANSFORMAT_31(index,liste_des_points_B))) \
,ELEMENT_DU_FICHIER_LISTE_Y(INTE(sTRANSFORMAT_31(index,liste_des_points_B))) \
,ELEMENT_DU_FICHIER_LISTE_Z(INTE(sTRANSFORMAT_31(index,liste_des_points_B))) \
) \
) \
); \
CAL3(Prme1("Iteration=%d",iteration_courante)); \
CAL3(Prme1(" Index=%d",index)); \
CAL3(Prme1(" Distance=%+.^^^",distance_courante)); \
CALS(Fsauts_de_lignes(UN)); \
Eblock \
EDoI \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* 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 C A R T E S I E N N 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 */
/* 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(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(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(Logical,INIT(utiliser_une_distance_de_reference,UTILISER_UNE_DISTANCE_DE_REFERENCE));
DEFV(Logical,INIT(evaluer_la_distance_de_reference,EVALUER_LA_DISTANCE_DE_REFERENCE));
DEFV(Float,INIT(distance_de_reference,DISTANCE_DE_REFERENCE));
/* Definition de la distance dite "de reference" vers laquelle doivent converger les */
/* extrema de toutes les distances. Si elle est evaluee automatiquement, sa valeur est */
/* moyenne des extrema de toutes les distances. */
/* */
/* La possibilite de ne pas employer de distance de reference a ete introduite le */
/* 20150730121008... */
DEFV(Float,INIT(X_minimum,X_MINIMUM));
DEFV(Float,INIT(X_maximum,X_MAXIMUM));
DEFV(Float,INIT(X_delta_initial,X_DELTA_INITIAL));
DEFV(Float,INIT(X_delta_final,X_DELTA_FINAL));
/* Definition de la coordonnee cartesienne 'X'. */
DEFV(Float,INIT(Y_minimum,Y_MINIMUM));
DEFV(Float,INIT(Y_maximum,Y_MAXIMUM));
DEFV(Float,INIT(Y_delta_initial,Y_DELTA_INITIAL));
DEFV(Float,INIT(Y_delta_final,Y_DELTA_FINAL));
/* Definition de la coordonnee cartesienne 'Y'. */
DEFV(Float,INIT(Z_minimum,Z_MINIMUM));
DEFV(Float,INIT(Z_maximum,Z_MAXIMUM));
DEFV(Float,INIT(Z_delta_initial,Z_DELTA_INITIAL));
DEFV(Float,INIT(Z_delta_final,Z_DELTA_FINAL));
/* Definition de la coordonnee cartesienne 'Z'. */
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(Logical,INIT(editer_le_message_de_risque_de_non_perturbation,EDITER_LE_MESSAGE_DE_RISQUE_DE_NON_PERTURBATION));
/* Afin de pouvoir inhiber le message de risque de non perturbation... */
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(Float,INIT(epsilon_de_convergence,EPSILON_DE_CONVERGENCE));
/* Epsilon permettant d'arreter le processus lorsque le minimum et le maximum des */
/* des distances minimales sont proches l'un de l'autre... */
DEFV(Logical,INIT(editer_toutes_les_distances_extremales,EDITER_TOUTES_LES_DISTANCES_EXTREMALES));
/* Doit-on editer toutes les distances extremales pour voir l'amelioration comment converge */
/* le processus ? */
DEFV(Logical,INIT(editer_les_distances_extremales_initiales_et_finales,EDITER_LES_DISTANCES_EXTREMALES_INITIALES_ET_FINALES));
/* Doit-on editer les distances extremales initiale et finale pour voir l'amelioration ? */
DEFV(Logical,INIT(editer_toutes_les_distances_initiales_et_finales,EDITER_TOUTES_LES_DISTANCES_INITIALES_ET_FINALES));
/* Doit-on editer toutes les distances pour valider le processu ? Ceci a ete introduit le */
/* 20150801091712... */
DEFV(Logical,INIT(iterer,VRAI));
DEFV(Int,INIT(iteration_courante,PREMIERE_ITERATION_D_UN_Komp));
/* Controle des iterations... */
DEFV(Float,INIT(minimum_distances_avant_la_perturbation,FLOT__UNDEF));
DEFV(Float,INIT(maximum_distances_avant_la_perturbation,FLOT__UNDEF));
DEFV(Float,INIT(sauvegarde_de_minimum_distances_avant_la_perturbation,FLOT__UNDEF));
DEFV(Float,INIT(sauvegarde_de_maximum_distances_avant_la_perturbation,FLOT__UNDEF));
DEFV(Float,INIT(minimum_distances_apres_la_perturbation,FLOT__UNDEF));
DEFV(Float,INIT(maximum_distances_apres_la_perturbation,FLOT__UNDEF));
/* Distances minimales avant et apres une tentative de perturbation... */
/*..............................................................................................................................*/
#include xrv/champs_5.1A.I"
iTRANSFORMAT_31(liste_pA_X,LISTE_XA_IMPLICITE);
iTRANSFORMAT_31(liste_pA_Y,LISTE_YA_IMPLICITE);
iTRANSFORMAT_31(liste_pA_Z,LISTE_ZA_IMPLICITE);
iTRANSFORMAT_31(liste_pB_X,LISTE_XB_IMPLICITE);
iTRANSFORMAT_31(liste_pB_Y,LISTE_YB_IMPLICITE);
iTRANSFORMAT_31(liste_pB_Z,LISTE_ZB_IMPLICITE);
iTRANSFORMAT_31(liste_des_points_A,UNDEF);
iTRANSFORMAT_31(liste_des_points_B,UNDEF);
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("sortir=",sortir_les_coordonnees_optimisees);
GET_ARGUMENT_N("pas_sortir=",sortir_les_coordonnees_optimisees);
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
);
PROCESS_ARGUMENT_I("nombre_connexions=""nc=",nombre_de_connexions
,BLOC(VIDE;)
,BLOC(
Bblock
PRINT_AVERTISSEMENT("'ns=' doit etre defini avant tout fichier");
Eblock
)
);
PROCESS_ARGUMENT_FICHIER("CONNEXION_XA="
,fichier_LISTE_XA
,liste_pA_X
,LISTE_XA_IMPLICITE
,gTRANSFORMAT_31
);
PROCESS_ARGUMENT_FICHIER("CONNEXION_YA="
,fichier_LISTE_YA
,liste_pA_Y
,LISTE_YA_IMPLICITE
,gTRANSFORMAT_31
);
PROCESS_ARGUMENT_FICHIER("CONNEXION_ZA="
,fichier_LISTE_ZA
,liste_pA_Z
,LISTE_ZA_IMPLICITE
,gTRANSFORMAT_31
);
PROCESS_ARGUMENT_FICHIER("CONNEXION_XB="
,fichier_LISTE_XB
,liste_pB_X
,LISTE_XB_IMPLICITE
,gTRANSFORMAT_31
);
PROCESS_ARGUMENT_FICHIER("CONNEXION_YB="
,fichier_LISTE_YB
,liste_pB_Y
,LISTE_YB_IMPLICITE
,gTRANSFORMAT_31
);
PROCESS_ARGUMENT_FICHIER("CONNEXION_ZB="
,fichier_LISTE_ZB
,liste_pB_Z
,LISTE_ZB_IMPLICITE
,gTRANSFORMAT_31
);
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_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_L("utiliser_distance_reference=""udr=",utiliser_une_distance_de_reference);
GET_ARGUMENT_L("evaluer_distance_reference=""edr=",evaluer_la_distance_de_reference);
GET_ARGUMENT_F("distance_reference=""dr=",distance_de_reference);
GET_ARGUMENT_F("Xm=",X_minimum);
GET_ARGUMENT_F("XM=",X_maximum);
GET_ARGUMENT_F("X_delta_initial=""Xdi=",X_delta_initial);
GET_ARGUMENT_F("X_delta_final=""Xdf=",X_delta_final);
GET_ARGUMENT_F("Ym=",Y_minimum);
GET_ARGUMENT_F("YM=",Y_maximum);
GET_ARGUMENT_F("Y_delta_initial=""Ydi=",Y_delta_initial);
GET_ARGUMENT_F("Y_delta_final=""Ydf=",Y_delta_final);
GET_ARGUMENT_F("Zm=",Z_minimum);
GET_ARGUMENT_F("ZM=",Z_maximum);
GET_ARGUMENT_F("Z_delta_initial=""Zdi=",Z_delta_initial);
GET_ARGUMENT_F("Z_delta_final=""Zdf=",Z_delta_final);
GET_ARGUMENT_F("probabilite_perturber_point=""ppp=",probabilite_de_perturber_un_point);
GET_ARGUMENT_F("probabilite_refuser_bonne_solution=""prbs=",probabilite_de_refuser_une_bonne_solution);
GET_ARGUMENT_F("probabilite_accepter_mauvaise_solution=""pams=",probabilite_d_accepter_une_mauvaise_solution);
GET_ARGUMENT_L("message_risque_non_perturbation=""mrnp="
,editer_le_message_de_risque_de_non_perturbation
);
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_F("epsilon_convergence=""epscon=",epsilon_de_convergence);
GET_ARGUMENT_L("lister_all=""lia=""editer_all=""eda=",editer_toutes_les_distances_extremales);
GET_ARGUMENT_L("lister_initiale_finale=""liif=""editer_initiale_finale=""edif="
,editer_les_distances_extremales_initiales_et_finales
);
GET_ARGUMENT_L("lister_distances=""ld=""editer_distances=""ed="
,editer_toutes_les_distances_initiales_et_finales
);
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_connexions,NOMBRE_MAXIMAL_DE_PERIODES_DE_LA_SIMULATION))
/* Test manquant introduit le 20150705005819... */
Bblock
PRINT_ERREUR("la simulation demandee est trop longue");
EGAL(nombre_de_connexions,NOMBRE_MAXIMAL_DE_PERIODES_DE_LA_SIMULATION);
/* Et on seuille le nombre de periodes... */
Eblock
ATes
Bblock
Eblock
ETes
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);
Test(IFLT(probabilite_de_perturber_un_point,INVE(FLOT(nombre_d_elements))))
Bblock
Test(IL_FAUT(editer_le_message_de_risque_de_non_perturbation))
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
Eblock
ATes
Bblock
Eblock
ETes
begin_nouveau_block
Bblock
DEFV(Int,INIT(index_c,UNDEF));
DoIn(index_c
,NUMERO_DE_LA_PREMIERE_CONNEXION
,LSTX(NUMERO_DE_LA_PREMIERE_CONNEXION,nombre_de_connexions)
,I
)
/* Parcours des listes de connexion ('A' --> 'B') : */
Bblock
DEFV(Int,INIT(index_i,UNDEF));
DEFV(Int,INIT(save_index_i,UNDEF));
DEFV(Logical,INIT(index_i_est_valide,FAUX));
DEFV(Int,INIT(index_j,UNDEF));
DEFV(Int,INIT(save_index_j,UNDEF));
DEFV(Logical,INIT(index_j_est_valide,FAUX));
RECHERCHE_DES_CONNEXIONS(i,pA);
RECHERCHE_DES_CONNEXIONS(j,pB);
/* Etablissement de la liste des connexions entre les points 'pA' et 'pB'. */
Test(IFET(EST_VRAI(index_i_est_valide),EST_VRAI(index_j_est_valide)))
Bblock
EGAL(sTRANSFORMAT_31(index_c,liste_des_points_A),FLOT(save_index_i));
EGAL(sTRANSFORMAT_31(index_c,liste_des_points_B),FLOT(save_index_j));
/* Memorisation de la connexion {i,j}... */
Eblock
ATes
Bblock
PRINT_ATTENTION("une connexion n'a pas ete recuperee");
CAL1(Prer7("(il s'agit de la connexion {%+.^^^,%+.^^^,%+.^^^} --> {%+.^^^,%+.^^^,%+.^^^} dont l'index est c=%d)\n"
,sTRANSFORMAT_31(index_c,liste_pA_X)
,sTRANSFORMAT_31(index_c,liste_pA_Y)
,sTRANSFORMAT_31(index_c,liste_pA_Z)
,sTRANSFORMAT_31(index_c,liste_pB_X)
,sTRANSFORMAT_31(index_c,liste_pB_Y)
,sTRANSFORMAT_31(index_c,liste_pB_Z)
,index_c
)
);
Eblock
ETes
Eblock
EDoI
Eblock
end_nouveau_block
ETUDE_DES_DISTANCES_EXTREMALES(minimum_distances_avant_la_perturbation
,maximum_distances_avant_la_perturbation
);
/* Recherche des extrema des distances avant la perturbation. */
EDITION_DE_TOUTES_LES_DISTANCES_INITIALES_ET_FINALES;
SAUVEGARDE_DE_L_ETAT_COURANT;
Test(IFET(IL_FAUT(utiliser_une_distance_de_reference),IL_FAUT(evaluer_la_distance_de_reference)))
Bblock
EGAL(distance_de_reference
,MOYE(minimum_distances_avant_la_perturbation,maximum_distances_avant_la_perturbation)
);
Eblock
ATes
Bblock
Eblock
ETes
Tant(IL_FAUT(iterer))
Bblock
DEFV(Logical,INIT(on_a_trouve_une_bonne_perturbation,FAUX));
EDITION_DES_DISTANCES_EXTREMALES(IFOU(IL_FAUT(editer_toutes_les_distances_extremales)
,IFET(IL_FAUT(editer_les_distances_extremales_initiales_et_finales)
,IFEQ(iteration_courante,PREMIERE_ITERATION_D_UN_Komp)
)
)
);
begin_nouveau_block
Bblock
DEFV(Int,INIT(index,UNDEF));
DEFV(Float,INIT(probabilite_courante,FLOT__UNDEF));
SAUVEGARDE_DE_L_ETAT_COURANT;
DoIn(index,PREMIER_ELEMENT_D_UN_FICHIER,DERNIER_ELEMENT_D_UN_FICHIER,I)
Bblock
GENERATION_D_UNE_VALEUR(probabilite_courante,PROBABILITE_NULLE,PROBABILITE_UNITE);
Test(IFLT(probabilite_courante,probabilite_de_perturber_un_point))
Bblock
DEFV(Float,INIT(X_perturbe,ELEMENT_DU_FICHIER_LISTE_X(index)));
DEFV(Float,INIT(Y_perturbe,ELEMENT_DU_FICHIER_LISTE_Y(index)));
DEFV(Float,INIT(Z_perturbe,ELEMENT_DU_FICHIER_LISTE_Z(index)));
PERTURBATION_D_UNE_COORDONNEE(X_perturbe
,X_delta_initial
,X_delta_final
,X_minimum,X_maximum
);
PERTURBATION_D_UNE_COORDONNEE(Y_perturbe
,Y_delta_initial
,Y_delta_final
,Y_minimum,Y_maximum
);
PERTURBATION_D_UNE_COORDONNEE(Z_perturbe
,Z_delta_initial
,Z_delta_final
,Z_minimum,Z_maximum
);
EGAL(ELEMENT_DU_FICHIER_LISTE_X(index),X_perturbe);
EGAL(ELEMENT_DU_FICHIER_LISTE_Y(index),Y_perturbe);
EGAL(ELEMENT_DU_FICHIER_LISTE_Z(index),Z_perturbe);
/* Perturbation aleatoire des points. */
Eblock
ATes
Bblock
Eblock
ETes
Eblock
EDoI
ETUDE_DES_DISTANCES_EXTREMALES(minimum_distances_apres_la_perturbation
,maximum_distances_apres_la_perturbation
);
/* Recherche de la distance minimale apres la perturbation. */
Test(IFOU(IFET(IL_FAUT(utiliser_une_distance_de_reference)
,IFET(IFLE(SOUA(minimum_distances_apres_la_perturbation,distance_de_reference)
,SOUA(minimum_distances_avant_la_perturbation,distance_de_reference)
)
,IFLE(SOUA(maximum_distances_apres_la_perturbation,distance_de_reference)
,SOUA(maximum_distances_avant_la_perturbation,distance_de_reference)
)
)
)
,IFET(IL_NE_FAUT_PAS(utiliser_une_distance_de_reference)
,IFLT(SOUS(maximum_distances_apres_la_perturbation
,minimum_distances_apres_la_perturbation
)
,SOUS(maximum_distances_avant_la_perturbation
,minimum_distances_avant_la_perturbation
)
)
)
)
)
Bblock
/* Cas ou les choses s'ameliorent (ce qui semble exceptionnel des qu'il y a beaucoup */
/* de points) : */
GENERATION_D_UNE_VALEUR(probabilite_courante,PROBABILITE_NULLE,PROBABILITE_UNITE);
Test(IFGE(probabilite_courante,probabilite_de_refuser_une_bonne_solution))
Bblock
EGAL(on_a_trouve_une_bonne_perturbation,VRAI);
/* On va pouvoir arreter la boucle courante 'Tant(...)' des tentatives... */
EGAL(minimum_distances_avant_la_perturbation,minimum_distances_apres_la_perturbation);
EGAL(maximum_distances_avant_la_perturbation,maximum_distances_apres_la_perturbation);
/* Il y a une amelioration, on change donc les extrema de type "avant"... */
Eblock
ATes
Bblock
/* Cas ou une bonne solution est refusee... */
Eblock
ETes
Eblock
ATes
/* Cas ou les choses se deteriorent : */
Bblock
GENERATION_D_UNE_VALEUR(probabilite_courante,PROBABILITE_NULLE,PROBABILITE_UNITE);
Test(IFLT(probabilite_courante,probabilite_d_accepter_une_mauvaise_solution))
Bblock
EGAL(on_a_trouve_une_bonne_perturbation,VRAI);
/* Cas ou une mauvaise solution est malgre tout acceptee... */
Eblock
ATes
Bblock
Eblock
ETes
Eblock
ETes
Eblock
end_nouveau_block
Test(EST_VRAI(on_a_trouve_une_bonne_perturbation))
Bblock
Test(IZEQ_a_peu_pres(SOUS(maximum_distances_apres_la_perturbation
,minimum_distances_apres_la_perturbation
)
,epsilon_de_convergence
)
)
Bblock
EGAL(iterer,FAUX);
/* On arrete le processus... */
Eblock
ATes
Bblock
Eblock
ETes
Eblock
ATes
Bblock
RESTAURATION_DE_L_ETAT_COURANT;
Eblock
ETes
Test(IFLT(iteration_courante,nombre_d_iterations_d_optimisation))
Bblock
INCR(iteration_courante,I);
Eblock
ATes
Bblock
EGAL(iterer,FAUX);
/* On arrete le processus... */
Eblock
ETes
Eblock
ETan
EDITION_DES_DISTANCES_EXTREMALES(IL_FAUT(editer_les_distances_extremales_initiales_et_finales));
/* 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... */
EDITION_DE_TOUTES_LES_DISTANCES_INITIALES_ET_FINALES;
Test(IL_FAUT(sortir_les_coordonnees_optimisees))
Bblock
DoIn(index
,PREMIER_ELEMENT_D_UN_FICHIER
,DERNIER_ELEMENT_D_UN_FICHIER
,I
)
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}. */
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
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(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);
RETU_Commande;
Eblock
ECommande