/*************************************************************************************************************************************/
/* */
/* G E N E R A T I O N D ' A R B R E S R E C U R S I F S : */
/* */
/* */
/* Nota tres important : */
/* */
/* Je note le 20160209115226 qu'en ce qui */
/* concerne les numeros de noeuds et leurs */
/* etiquettes, ces deux notions ne sont pas */
/* ce que l'on pourrait attendre intuitivement : */
/* */
/* 1-'numero_du_noeud_courant' : */
/* */
/* On notera qu'un noeud qui est a un embranchement (qui n'est donc pas une feuille) */
/* a plusieurs numeros differents correspondant aux differentes fois ou l'on passe par */
/* lui... */
/* */
/* */
/* 2-'etiquette_du_noeud_courant' : */
/* */
/* L'etiquette du noeud de numero 'n' est definie par rapport a l'etiquette du noeud de */
/* numero 'n-1' selon : */
/* */
/* Etiquette(0) = 1 */
/* Etiquette(n) = Etiquette(n-1) + Increment > 0 */
/* */
/* avec : */
/* */
/* Increment E {-1,0,+1} */
/* */
/* choisi aleatoirement. Ces etiquettes peuvent etre ensuite utilisees pour obtenir un */
/* graphe a partir d'un arbre par un procede de quadrangulation qui est defini dans */
/* 'v $xrv/QuadrangulationArbre.11$K'... */
/* */
/* */
/* Author of '$xci/valeurs_Arbre.01$K' : */
/* */
/* Jean-Francois COLONNA (LACTAMME, 20130330114146). */
/* */
/*************************************************************************************************************************************/
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* 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
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* P A R A M E T R E S : */
/* */
/*************************************************************************************************************************************/
#define COMPATIBILITE_20160216 \
FAUX \
/* Permet d'assurer la compatibilite anterieure au 20160216170712 si besoin est... */
#define MODE_BIDIMENSIONNEL \
VRAI \
/* Doit-on utiliser les fonctions bidimensionnelles ('VRAI') ou tridimensionnelles */ \
/* ('FAUX') ? Ceci a ete introduit le 20130415133426... */
#define SIGNER_LES_VALEURS \
VRAI \
/* Faut-il signer toutes les valeurs ('VRAI') ou pas ('FAUX') ? Ceci a ete introduit */ \
/* le 20150628185445... */
#define EDITER_LES_COORDONNEES_SOUS_FORME_CARTESIENNE \
VRAI \
/* Faut-il editer les coordonnees sous forme cartesienne ('VRAI') ou spheriques ('FAUX') ? */ \
/* Ceci a ete introduit le 20160208131143... */
#define NUMERO_ABSOLU_DES_BRANCHES \
FAUX \
/* Faut-il numeroter en absolu ('VRAI') ou en relatif ('FAUX') les branches ? */
#define NUMEROTER_LES_NOEUDS_DE_L_ARBRE \
FAUX
#define NUMERO_DE_LA_RACINE_DE_L_ARBRE \
UN
#define ETIQUETTER_LES_NOEUDS_DE_L_ARBRE \
FAUX
#define ETIQUETTE_DE_LA_RACINE_DE_L_ARBRE \
UN
#define L_ETIQUETTAGE_EST_EXOTIQUE \
FAUX
/* Le 20150622112341 a ete introduite la possibilite de numeroter et etiquetter les */
/* noeuds de l'arbre... */
/* */
/* Le 20150625105105 a ete introduite la possibilite d'un etiquettage non standard (dit */
/* "exotique")... */
#define BRANCHE_DE_DEPART_X0 \
FZERO
#define BRANCHE_DE_DEPART_Y0 \
FZERO
#define BRANCHE_DE_DEPART_Z0 \
FDU
/* Definition de la racine de quadrangulation (introduite le 20150624082447). */
#define BRANCHE_DE_DEPART_X1 \
FDU
#define BRANCHE_DE_DEPART_Y1 \
FZERO
#define BRANCHE_DE_DEPART_Z1 \
FDU
/* Definition de la racine de l'arbre... */
#define BRANCHE_DE_DEPART_X2 \
BRANCHE_DE_DEPART_X1
#define BRANCHE_DE_DEPART_Y2 \
FDU
#define BRANCHE_DE_DEPART_Z2 \
BRANCHE_DE_DEPART_Z1
/* Definition de la branche de depart. Le 20130402104649 la troisieme dimension a ete */
/* introduite. On notera que cette troisieme dimension 'Z' n'a de sens que sous sa forme */
/* aleatoire ('v $xiirv/TREE.33'). */
#define MARQUER_L_EXTREMITE_DES_BRANCHES \
FAUX \
/* Faut-il marquer l'extremite des branches ('VRAI') ou pas ('FAUX') ? Ceci a ete */ \
/* introduit le 20160209141408. */
#define PROFONDEUR_DE_LA_GENERATION \
DEUX \
/* Profondeur de la generation recursive... */
#define FAIRE_VARIER_ALEATOIREMENT_LA_PROFONDEUR_DE_LA_GENERATION \
FAUX
#define PROBABILITE_D_INTERROMPRE_LA_PROGRESSION_DANS_L_ARBRE \
PROBABILITE_NULLE
/* Le 20150622093648 a ete introduite la possibilite de progresser aleatoirement dans */
/* la profondeur de l'arbre... */
#define NOMBRE_DE_BRANCHES_THETA_EN_CHAQUE_NOEUD \
TROIS
#define EVASEMENT_TOTAL_THETA_DES_BRANCHES \
PI
#define FACTEUR_DE_L_EVASEMENT_THETA_DES_BRANCHES \
FU
#define NOMBRE_DE_BRANCHES_PHI__EN_CHAQUE_NOEUD \
UN
#define EVASEMENT_TOTAL_PHI__DES_BRANCHES \
FZERO
#define FACTEUR_DE_L_EVASEMENT_PHI__DES_BRANCHES \
FU
#define FACTEUR_DE_REDUCTION_DES_BRANCHES \
FDU
/* Definition d'une nouvelle generation de branches. On notera que par defaut, on genere */
/* un arbre ternaire dont les branches sont horizontales ou verticales... */
/* */
/* L'angle 'Phi' a ete introduit le 20130417145751... */
#define CONSERVER_LA_DIRECTION_INITIALE \
FAUX \
/* Indique si la premiere branche "fils" doit avoir la meme direction que sa branche "pere" */ \
/* ('VRAI') ou pas ('FAUX'). Ceci a ete introduit le 20160321092815 et la valeur par defaut */ \
/* garantit la compatibilite anterieure... */
#define GRAINE \
PARE(1789) \
/* Definition du generateur aleatoire... */
#define BORNE_INFERIEURE_PERTURBATION_ALEATOIRE_DU_NOMBRE_DE_BRANCHES_THETA \
ZERO
#define BORNE_SUPERIEURE_PERTURBATION_ALEATOIRE_DU_NOMBRE_DE_BRANCHES_THETA \
ZERO
#define BORNE_INFERIEURE_PERTURBATION_ALEATOIRE_DU_NOMBRE_DE_BRANCHES_PHI_ \
ZERO
#define BORNE_SUPERIEURE_PERTURBATION_ALEATOIRE_DU_NOMBRE_DE_BRANCHES_PHI_ \
ZERO
#define BORNE_INFERIEURE_PERTURBATION_ALEATOIRE_DE_RHO_ \
FZERO
#define BORNE_SUPERIEURE_PERTURBATION_ALEATOIRE_DE_RHO_ \
FZERO
#define BORNE_INFERIEURE_PERTURBATION_ALEATOIRE_DE_THETA \
FZERO
#define BORNE_SUPERIEURE_PERTURBATION_ALEATOIRE_DE_THETA \
FZERO
#define BORNE_INFERIEURE_PERTURBATION_ALEATOIRE_DE_PHI_ \
FZERO
#define BORNE_SUPERIEURE_PERTURBATION_ALEATOIRE_DE_PHI_ \
FZERO
#define BORNE_INFERIEURE_PERTURBATION_ALEATOIRE_DE_Z___ \
FZERO
#define BORNE_SUPERIEURE_PERTURBATION_ALEATOIRE_DE_Z___ \
FZERO
/* Definition des perturbations aleatoires du nombre de branches, de {Rho,Theta} et de 'Z'. */
/* */
/* La perturbation aleatoire de {Phi} a ete introduite le 20130417142344... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* M A C R O S U T I L E S : */
/* */
/*************************************************************************************************************************************/
/* On notera que l'on ne peut utiliser ici : */
/* */
/* #include xci/valeurs.02.I" */
/* #include xci/valeurs.03.I" */
/* */
/* car, en effet, des variables initialisees de facon dynamique y sont definies, par */
/* exemple via 'INIC(...)'. */
#define PRINT(valeur,nom_de_la_valeur,format) \
Bblock \
CAL2(Prin1(Cara(chain_Aconcaten5(" " \
,nom_de_la_valeur \
,"=%" \
,COND(IL_FAUT(signer_les_valeurs),"+",C_VIDE) \
,format \
) \
) \
,valeur \
) \
); \
Eblock \
/* On ne peut donc pas utiliser 'v $xci/valeurs.03.I valeurs_signees'... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* G E N E R A T E U R A L E A T O I R E : */
/* */
/*************************************************************************************************************************************/
SPIRALE_DEFINITION_GENERALE(SPIRALE_DELTA_HORIZONTAL_GLOBAL,SPIRALE_DELTA_VERTICAL_GLOBAL)
DEFV(Int,INIT(graine,GRAINE));
DEFV(pointI_2D,point_courant_de_l_espace_de_parametrage_2D);
/* Definition du generateur aleatoire... */
#define GENERATION_DE_LA_VALEUR_ALEATOIRE_COURANTE(valeur_aleatoire,borne_inf,borne_sup,Fconversion) \
Bblock \
Test(IFLT(borne_inf,borne_sup)) \
Bblock \
EGAL(valeur_aleatoire \
,Fconversion(rdnI2D(ADRESSE(point_courant_de_l_espace_de_parametrage_2D) \
,graine \
,RDN_INIT_AND_GENERE \
,borne_inf,borne_sup \
) \
) \
); \
\
SPIRALE_INITIALISATION; \
/* Initialisation dynamique de 'spirale_nombre_de_points_a_traiter'. */ \
SPIRALE_DEPLACEMENT(ASD1(point_courant_de_l_espace_de_parametrage_2D,x) \
,ASD1(point_courant_de_l_espace_de_parametrage_2D,y) \
); \
/* Deplacement du point courant de la spirale de l'espace de parametrage. */ \
SPIRALE_PARCOURS; \
/* Parcours de la spirale avec rotation eventuelle de PI/2 du bras courant... */ \
Eblock \
ATes \
Bblock \
EGAL(valeur_aleatoire,CHOI(borne_inf,borne_sup)); \
/* Introduit le 20130402104649 afin que le parametrage du generateur aleatoire ne */ \
/* change pas (via 'point_courant_de_l_espace_de_parametrage_2D' lorsque l'aleatoire */ \
/* n'est pas requis (lorsque les bornes inferieure et superieure sont egales ou inversees). */ \
Eblock \
ETes \
Eblock
#define PERTURBER_UNE_VALEUR(nombre_de_repetitions) \
IFOU(IL_NE_FAUT_PAS(conserver_la_direction_initiale) \
,IFET(IL_FAUT(conserver_la_direction_initiale) \
,IFNE(SOUS(compteur_des_repetitions_du_Repe,PREMIERE_ITERATION_D_UN_Repe) \
,MOYS(nombre_de_repetitions,PREMIERE_ITERATION_D_UN_Repe) \
) \
) \
)
#define PAS_DE_PERTURBATION \
FZERO
#define GENERATION_EVENTUELLE_DE_LA_VALEUR_ALEATOIRE_COURANTE(valeur_aleatoire,borne_inf,borne_sup,Fconversion,condition,valeur_defo) \
Bblock \
Test(EST_VRAI(condition)) \
Bblock \
GENERATION_DE_LA_VALEUR_ALEATOIRE_COURANTE(valeur_aleatoire,borne_inf,borne_sup,Fconversion); \
Eblock \
ATes \
Bblock \
EGAL(valeur_aleatoire,valeur_defo); \
Eblock \
ETes \
Eblock
/* Generation eventuelle introduite le 20160321092815... */
DEFV(Logical,INIT(conserver_la_direction_initiale,CONSERVER_LA_DIRECTION_INITIALE));
/* Indique si la premiere branche "fils" doit avoir la meme direction que sa branche "pere" */
/* ('VRAI') ou pas ('FAUX'). Ceci a ete introduit le 20160321092815 et la valeur par defaut */
/* garantit la compatibilite anterieure... */
DEFV(Int,INIT(borne_inferieure_perturbation_aleatoire_du_nombre_de_branches_theta
,BORNE_INFERIEURE_PERTURBATION_ALEATOIRE_DU_NOMBRE_DE_BRANCHES_THETA
)
);
DEFV(Int,INIT(borne_superieure_perturbation_aleatoire_du_nombre_de_branches_theta
,BORNE_SUPERIEURE_PERTURBATION_ALEATOIRE_DU_NOMBRE_DE_BRANCHES_THETA
)
);
DEFV(Int,INIT(borne_inferieure_perturbation_aleatoire_du_nombre_de_branches_phi_
,BORNE_INFERIEURE_PERTURBATION_ALEATOIRE_DU_NOMBRE_DE_BRANCHES_PHI_
)
);
DEFV(Int,INIT(borne_superieure_perturbation_aleatoire_du_nombre_de_branches_phi_
,BORNE_SUPERIEURE_PERTURBATION_ALEATOIRE_DU_NOMBRE_DE_BRANCHES_PHI_
)
);
/* Definition de la perturbation aleatoire du nombre de branches... */
DEFV(Float,INIT(borne_inferieure_perturbation_aleatoire_de_rho_,BORNE_INFERIEURE_PERTURBATION_ALEATOIRE_DE_RHO_));
DEFV(Float,INIT(borne_superieure_perturbation_aleatoire_de_rho_,BORNE_SUPERIEURE_PERTURBATION_ALEATOIRE_DE_RHO_));
DEFV(Float,INIT(borne_inferieure_perturbation_aleatoire_de_theta,BORNE_INFERIEURE_PERTURBATION_ALEATOIRE_DE_THETA));
DEFV(Float,INIT(borne_superieure_perturbation_aleatoire_de_theta,BORNE_SUPERIEURE_PERTURBATION_ALEATOIRE_DE_THETA));
DEFV(Float,INIT(borne_inferieure_perturbation_aleatoire_de_phi_,BORNE_INFERIEURE_PERTURBATION_ALEATOIRE_DE_PHI_));
DEFV(Float,INIT(borne_superieure_perturbation_aleatoire_de_phi_,BORNE_SUPERIEURE_PERTURBATION_ALEATOIRE_DE_PHI_));
/* Definition des perturbations aleatoires de {Rho,Theta}... */
/* */
/* La perturbation aleatoire de {Phi} a ete introduite le 20130417142344... */
DEFV(Float,INIT(borne_inferieure_perturbation_aleatoire_de_Z___,BORNE_INFERIEURE_PERTURBATION_ALEATOIRE_DE_Z___));
DEFV(Float,INIT(borne_superieure_perturbation_aleatoire_de_Z___,BORNE_SUPERIEURE_PERTURBATION_ALEATOIRE_DE_Z___));
/* Definition de la perturbation aleatoire dee 'Z'... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* G E N E R A T I O N R E C U R S I V E D ' A R B R E : */
/* */
/*************************************************************************************************************************************/
DEFV(Logical,INIT(compatibilite_20160216,COMPATIBILITE_20160216));
/* Permet d'assurer la compatibilite anterieure au 20160216170712 si besoin est... */
DEFV(pointF_3D,racine_de_quadrangulation);
/* Definition de la recine de quadrangulation. */
DEFV(vectorF_3D,branche_de_depart);
/* Definition de la branche de depart... */
DEFV(Positive,INIT(profondeur_de_la_generation,PROFONDEUR_DE_LA_GENERATION));
/* Profondeur de la generation recursive... */
#define EDITIONS(numero,etiquette,impression1,sequence1,sequence2,impression2) \
Bblock \
BLOC(impression1); \
\
Test(IL_FAUT(numeroter_les_noeuds_de_l_arbre)) \
Bblock \
BLOC(sequence1); \
\
PRINT(numero,"NumeroNoeud","d"); \
/* Edition introduite le 20150622112341... */ \
/* */ \
/* On notera que l'edition a lieu apres l'incrementation 'INCR(...)' precedente car, en */ \
/* effet, il y a un noeud de plus que de branches : c'est le noeud racine qui est edite */ \
/* avant le premier appel de 'GenerationDeLArbre(...)'. */ \
/* */ \
/* Le signe a ete introduit le 20150624095949... */ \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
\
Test(IL_FAUT(etiquetter_les_noeuds_de_l_arbre)) \
Bblock \
BLOC(sequence2); \
\
PRINT(etiquette,"EtiquetteNoeud","d"); \
/* Edition introduite le 20150622112341... */ \
/* */ \
/* On notera que l'edition a lieu apres l'incrementation 'INCR(...)' precedente car, en */ \
/* effet, il y a un noeud de plus que de branches : c'est le noeud racine qui est edite */ \
/* avant le premier appel de 'GenerationDeLArbre(...)'. */ \
/* */ \
/* Le signe a ete introduit le 20150624095949... */ \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
\
Test(IFOU(IL_FAUT(numeroter_les_noeuds_de_l_arbre),IL_FAUT(etiquetter_les_noeuds_de_l_arbre))) \
Bblock \
BLOC(impression2); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
/* Editions diverses... */
DEFV(Logical,INIT(numeroter_les_noeuds_de_l_arbre,NUMEROTER_LES_NOEUDS_DE_L_ARBRE));
DEFV(Int,INIT(numero_de_la_racine_de_l_arbre,NUMERO_DE_LA_RACINE_DE_L_ARBRE));
DEFV(Int,INIT(numero_du_noeud_courant,UNDEF));
DEFV(Logical,INIT(etiquetter_les_noeuds_de_l_arbre,ETIQUETTER_LES_NOEUDS_DE_L_ARBRE));
DEFV(Int,INIT(etiquette_de_la_racine_de_l_arbre,ETIQUETTE_DE_LA_RACINE_DE_L_ARBRE));
DEFV(Logical,INIT(l_etiquettage_est_exotique,L_ETIQUETTAGE_EST_EXOTIQUE));
/* Le 20150622112341 a ete introduite la possibilite de numeroter et etiquetter les */
/* noeuds de l'arbre... */
/* */
/* Le 20150625105105 a ete introduite la possibilite d'un etiquettage non standard (dit */
/* "exotique")... */
DEFV(Logical,INIT(marquer_l_extremite_des_branches,MARQUER_L_EXTREMITE_DES_BRANCHES));
/* Faut-il marquer l'extremite des branches ('VRAI') ou pas ('FAUX') ? Ceci a ete */
/* introduit le 20160209141408. */
DEFV(Logical,INIT(faire_varier_aleatoirement_la_profondeur_de_la_generation
,FAIRE_VARIER_ALEATOIREMENT_LA_PROFONDEUR_DE_LA_GENERATION
)
);
DEFV(Float,INIT(probabilite_d_interrompre_la_progression_dans_l_arbre,PROBABILITE_D_INTERROMPRE_LA_PROGRESSION_DANS_L_ARBRE));
/* Le 20150622093648 a ete introduite la possibilite de progresser aleatoirement dans */
/* la profondeur de l'arbre... */
DEFV(Logical,INIT(mode_bidimensionnel,MODE_BIDIMENSIONNEL));
/* Doit-on utiliser les fonctions bidimensionnelles ('VRAI') ou tridimensionnelles */
/* ('FAUX') ? Ceci a ete introduit le 20130415133426... */
DEFV(Logical,INIT(signer_les_valeurs,SIGNER_LES_VALEURS));
/* Faut-il signer toutes les valeurs ('VRAI') ou pas ('FAUX') ? Ceci a ete introduit */
/* le 20150628185445... */
DEFV(Logical,INIT(editer_les_coordonnees_sous_forme_cartesienne,EDITER_LES_COORDONNEES_SOUS_FORME_CARTESIENNE));
/* Faut-il editer les coordonnees sous forme cartesienne ('VRAI') ou spheriques ('FAUX') ? */
/* Ceci a ete introduit le 20160208131143... */
DEFV(Positive,INIT(nombre_de_branches_theta_en_chaque_noeud,NOMBRE_DE_BRANCHES_THETA_EN_CHAQUE_NOEUD));
DEFV(Float,INIT(evasement_total_theta_des_branches,EVASEMENT_TOTAL_THETA_DES_BRANCHES));
DEFV(Float,INIT(facteur_de_l_evasement_theta_des_branches,FACTEUR_DE_L_EVASEMENT_THETA_DES_BRANCHES));
DEFV(Positive,INIT(nombre_de_branches_phi__en_chaque_noeud,NOMBRE_DE_BRANCHES_PHI__EN_CHAQUE_NOEUD));
DEFV(Float,INIT(evasement_total_phi__des_branches,EVASEMENT_TOTAL_PHI__DES_BRANCHES));
DEFV(Float,INIT(facteur_de_l_evasement_phi__des_branches,FACTEUR_DE_L_EVASEMENT_PHI__DES_BRANCHES));
DEFV(Float,INIT(facteur_de_reduction_des_branches,FACTEUR_DE_REDUCTION_DES_BRANCHES));
/* Definition d'une nouvelle generation de branches. On notera que par defaut, on genere */
/* un arbre ternaire dont les branches sont horizontales ou verticales... */
DEFV(Logical,INIT(numero_absolu_des_branches,NUMERO_ABSOLU_DES_BRANCHES));
/* Faut-il numeroter en absolu ('VRAI') ou en relatif ('FAUX') les branches ? */
#define NUMERO_INCREMENTAL_DES_BRANCHES \
COND(IL_FAUT(numero_absolu_des_branches) \
,numero_incremental_absolu__des_branches \
,numero_incremental_relatif_des_branches \
)
#define PREMIERE_BRANCHE \
UN
DEFV(Int,INIT(numero_incremental_absolu__des_branches,PREMIERE_BRANCHE));
/* Numero absolu de la branche courante... */
#define EPSILON_DE_COLINEARITE \
GRAND_EPSILON
DEFV(Float,INIT(epsilon_de_colinearite,EPSILON_DE_COLINEARITE));
DEFV(Int,INIT(numero_aligne_des_branches,PREMIERE_BRANCHE));
/* Numero dit "aligne" de la branche courante (introduit le 20160324142723). Ce numero */
/* n'a en fait de sens que si 'IL_FAUT(conserver_la_direction_initiale)' et il permet */
/* de reperer les branches alignees puisqu'en fait il ne change alors que s'il y a */
/* changement de direction (a epsilon pres...). */
#define NOMBRE_EFFECTIF_DE_BRANCHES_THETA_EN_CHAQUE_NOEUD \
ADD2(nombre_de_branches_theta_en_chaque_noeud,perturbation_aleatoire_du_nombre_de_branches_theta_en_chaque_noeud)
#define NOMBRE_EFFECTIF_DE_BRANCHES_PHI__EN_CHAQUE_NOEUD \
ADD2(nombre_de_branches_phi__en_chaque_noeud,perturbation_aleatoire_du_nombre_de_branches_phi__en_chaque_noeud)
#define MODULE_EFFECTIF____________DES_FILS_DE_LA_BRANCHE_COURANTE \
ADD2(module___________des_fils_de_la_branche_courante,perturbation_aleatoire_de_rho_)
#define ORIENTATION_THETA_EFFECTIVE_DES_FILS_DE_LA_BRANCHE_COURANTE \
COND(IL_FAUT(compatibilite_20160216) \
,NEUT(ADD2(orientation_theta_des_fils_de_la_branche_courante,perturbation_aleatoire_de_theta)) \
,MODF(ADD2(orientation_theta_des_fils_de_la_branche_courante,perturbation_aleatoire_de_theta) \
,FZERO \
,CERCLE_TRIGONOMETRIQUE \
) \
)
#define ORIENTATION_PHI__EFFECTIVE_DES_FILS_DE_LA_BRANCHE_COURANTE \
COND(IL_FAUT(compatibilite_20160216) \
,NEUT(ADD2(orientation_phi__des_fils_de_la_branche_courante,perturbation_aleatoire_de_phi_)) \
,MODF(ADD2(orientation_phi__des_fils_de_la_branche_courante,perturbation_aleatoire_de_phi_) \
,FZERO \
,PI \
) \
)
/* On rappelle le 20160216151434 que les notations sont ici inversees, le 'theta' et le */
/* 'phi' etant permutes par rapport a 'v $ximD/definit.1$DEF Xcartesienne_3D.rho.phi.theta'. */
/* Dans ces conditions, on a : */
/* */
/* theta E [0,2.pi] */
/* phi E [0,pi] */
/* */
#define EVASEMENT_EFFECTIF_THETA_DES_BRANCHES \
MUL2(PUIX(facteur_de_l_evasement_theta_des_branches,SOUS(profondeur_de_la_generation,profondeur_courante)) \
,evasement_total_theta_des_branches \
)
#define EVASEMENT_EFFECTIF_PHI__DES_BRANCHES \
MUL2(PUIX(facteur_de_l_evasement_phi__des_branches,SOUS(profondeur_de_la_generation,profondeur_courante)) \
,evasement_total_phi__des_branches \
)
/* Introduit le 20160217171323 afin de permettre, par exemple, avec des facteurs inferieurs */
/* a 1 de resserer les branches au fur et a mesure de la recursivite... */
BFonctionI
DEFV(LoF,DEFV(FonctionI,GenerationDeLArbre(profondeur_courante
,numero_du_pere_de_la_branche_courante
,numero_aligne_de_la_branche_courante
,branche_courante
,etiquette_du_noeud_precedent
,filiation
)
)
)
DEFV(Argument,DEFV(Int,profondeur_courante));
/* Profondeur de la generation courante... */
DEFV(Argument,DEFV(Positive,numero_du_pere_de_la_branche_courante));
DEFV(Argument,DEFV(Positive,numero_aligne_de_la_branche_courante));
DEFV(Argument,DEFV(vectorF_3D,POINTERs(branche_courante)));
DEFV(Argument,DEFV(Int,etiquette_du_noeud_precedent));
/* Definition de la branche courante. Le numero dit "aligne" a ete introduit le */
/* 20160324142723... */
DEFV(Argument,DEFV(CHAR,DTb0(filiation)));
/* Memorisation des filiations... */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
DEFV(Int,INIT(profondeur_courante_effective,profondeur_courante));
/* Profondeur de la generation courante... */
DEFV(Int,INIT(etiquette_du_noeud_courant,etiquette_du_noeud_precedent));
INIT_ERROR;
/*..............................................................................................................................*/
Test(IL_FAUT(faire_varier_aleatoirement_la_profondeur_de_la_generation))
/* En toute generalite, cet indicateur est inutile : il suffirait que par defaut */
/* 'probabilite_d_interrompre_la_progression_dans_l_arbre' soit egale a 0. Mais en fait, */
/* si l'on souhaite garantir la compabilite anterieure, il ne faut pas faire des appels */
/* a 'GENERATION_DE_LA_VALEUR_ALEATOIRE_COURANTE' qui n'existaient pas avant la date */
/* du 20150622093648, sous peine de changer les autres generations aleatoires... */
Bblock
DEFV(Float,INIT(probabilite_de_progresser_dans_l_arbre,FLOT__UNDEF));
GENERATION_DE_LA_VALEUR_ALEATOIRE_COURANTE(probabilite_de_progresser_dans_l_arbre
,PROBABILITE_NULLE
,PROBABILITE_UNITE
,ndNEUT
);
Test(IFGE(probabilite_de_progresser_dans_l_arbre,probabilite_d_interrompre_la_progression_dans_l_arbre))
/* Cas ou la progression (en profondeur) se poursuit... */
Bblock
Eblock
ATes
Bblock
/* Cas ou la progression (en profondeur) doit s'interrompre : */
EGAL(profondeur_courante_effective,ZERO);
/* Ainsi la progression (en profondeur) dans l'arbre est bloquee... */
Eblock
ETes
Eblock
ATes
Bblock
Eblock
ETes
EDITIONS(numero_du_noeud_courant
,etiquette_du_noeud_courant
,BLOC(Bblock
CAL2(Prin1("Arborescence=%s",filiation));
Eblock
)
,BLOC(Bblock
Test(IL_FAUT(numeroter_les_noeuds_de_l_arbre))
Bblock
PRINT(numero_du_pere_de_la_branche_courante,"NumeroPere","d");
/* Edition introduite le 20150622112341... */
Test(IL_FAUT(conserver_la_direction_initiale))
Bblock
PRINT(numero_aligne_de_la_branche_courante,"NumeroAligne","d");
/* Edition introduite le 20160324142723... */
Eblock
ATes
Bblock
Eblock
ETes
Eblock
ATes
Bblock
Eblock
ETes
INCR(numero_du_noeud_courant,I);
Eblock
)
,BLOC(Bblock
DEFV(Float,INIT(selecteur_de_l_increment_de_l_etiquette,FLOT__UNDEF));
DEFV(Int,INIT(increment_de_l_etiquette,UNDEF));
GENERATION_DE_LA_VALEUR_ALEATOIRE_COURANTE(selecteur_de_l_increment_de_l_etiquette
,FZERO
,FTROIS
,ndNEUT
);
Test(EST_FAUX(l_etiquettage_est_exotique))
Bblock
/* Cas de l'etiquettage "standard" : */
Test(IFEQ(etiquette_du_noeud_courant,etiquette_de_la_racine_de_l_arbre))
Bblock
EGAL(increment_de_l_etiquette
,COND(IFLT(selecteur_de_l_increment_de_l_etiquette,MOYE(FU,FDEUX))
,ZERO
,NEUT(UN)
)
);
/* Cas ou l'on est sur la racine, l'etiquette ne peut pas diminuer... */
Eblock
ATes
Bblock
EGAL(increment_de_l_etiquette
,COND(IFLT(selecteur_de_l_increment_de_l_etiquette,FU)
,NEGA(UN)
,COND(IFLT(selecteur_de_l_increment_de_l_etiquette,FDEUX)
,ZERO
,NEUT(UN)
)
)
);
/* Autres cas, la variation est aleatoire dans {-1,0,+1}... */
Eblock
ETes
Eblock
ATes
Bblock
/* Cas de l'etiquettage "exotique" (introduit le 20150625105105) : */
Test(IFEQ(etiquette_du_noeud_courant,etiquette_de_la_racine_de_l_arbre))
Bblock
EGAL(increment_de_l_etiquette,NEUT(UN));
/* Cas ou l'on est sur la racine, il faut alors incrementer l'etiquette... */
Eblock
ATes
Bblock
Test(IZEQ(profondeur_courante_effective))
Bblock
EGAL(increment_de_l_etiquette,NEGA(UN));
/* Cas ou l'on est sur une feuille, il faut alors decrementer l'etiquette... */
Eblock
ATes
Bblock
EGAL(increment_de_l_etiquette
,COND(IFLT(selecteur_de_l_increment_de_l_etiquette,FU)
,NEGA(UN)
,COND(IFLT(selecteur_de_l_increment_de_l_etiquette,FDEUX)
,ZERO
,NEUT(UN)
)
)
);
/* Autres cas, la variation est aleatoire dans {-1,0,+1}... */
Eblock
ETes
Eblock
ETes
Eblock
ETes
INCR(etiquette_du_noeud_courant
,increment_de_l_etiquette
);
/* L'etiquette du noeud de numero 'n' est definie par rapport a l'etiquette du noeud de */
/* numero 'n-1' selon : */
/* */
/* Etiquette(0) = 1 */
/* Etiquette(n) = Etiquette(n-1) + Increment > 0 */
/* */
/* avec : */
/* */
/* Increment E {-1,0,+1} */
/* */
/* choisi aleatoirement. Ces etiquettes peuvent etre ensuite utilisees pour obtenir un */
/* graphe a partir d'un arbre par un procede de quadrangulation qui est defini dans */
/* 'v $xrv/QuadrangulationArbre.11$K'... */
Eblock
)
,BLOC(VIDE;)
);
Test(IL_FAUT(editer_les_coordonnees_sous_forme_cartesienne))
Bblock
PRINT(ASI2(branche_courante,origine,x),"X1",".^^^");
PRINT(ASI2(branche_courante,origine,y),"Y1",".^^^");
PRINT(ASI2(branche_courante,origine,z),"Z1",".^^^");
PRINT(ASI2(branche_courante,extremite,x),"X2",".^^^");
PRINT(ASI2(branche_courante,extremite,y),"Y2",".^^^");
PRINT(ASI2(branche_courante,extremite,z),"Z2",".^^^");
/* On notera qu'en permanence {X2,Y2,Z2} donne les coordonnees du noeud 'NumeroNoeud'... */
Eblock
ATes
Bblock
/* L'edition sous forme spherique a ete introduite le 20160208131143... */
PRINT(Rho_3D(SOUS(ASI2(branche_courante,origine,x),BRANCHE_DE_DEPART_X1)
,SOUS(ASI2(branche_courante,origine,y),BRANCHE_DE_DEPART_Y1)
,SOUS(ASI2(branche_courante,origine,z),BRANCHE_DE_DEPART_Z1)
)
,"R1"
,".^^^"
);
PRINT(Phi_3D(SOUS(ASI2(branche_courante,origine,x),BRANCHE_DE_DEPART_X1)
,SOUS(ASI2(branche_courante,origine,y),BRANCHE_DE_DEPART_Y1)
,SOUS(ASI2(branche_courante,origine,z),BRANCHE_DE_DEPART_Z1)
)
,"P1"
,".^^^"
);
PRINT(Theta_3D(SOUS(ASI2(branche_courante,origine,x),BRANCHE_DE_DEPART_X1)
,SOUS(ASI2(branche_courante,origine,y),BRANCHE_DE_DEPART_Y1)
,SOUS(ASI2(branche_courante,origine,z),BRANCHE_DE_DEPART_Z1)
)
,"T1"
,".^^^"
);
PRINT(Rho_3D(SOUS(ASI2(branche_courante,extremite,x),BRANCHE_DE_DEPART_X1)
,SOUS(ASI2(branche_courante,extremite,y),BRANCHE_DE_DEPART_Y1)
,SOUS(ASI2(branche_courante,extremite,z),BRANCHE_DE_DEPART_Z1)
)
,"R2"
,".^^^"
);
PRINT(Phi_3D(SOUS(ASI2(branche_courante,extremite,x),BRANCHE_DE_DEPART_X1)
,SOUS(ASI2(branche_courante,extremite,y),BRANCHE_DE_DEPART_Y1)
,SOUS(ASI2(branche_courante,extremite,z),BRANCHE_DE_DEPART_Z1)
)
,"P2"
,".^^^"
);
PRINT(Theta_3D(SOUS(ASI2(branche_courante,extremite,x),BRANCHE_DE_DEPART_X1)
,SOUS(ASI2(branche_courante,extremite,y),BRANCHE_DE_DEPART_Y1)
,SOUS(ASI2(branche_courante,extremite,z),BRANCHE_DE_DEPART_Z1)
)
,"T2"
,".^^^"
);
Eblock
ETes
CAL2(Prin0(" "));
/* Un espace a ete introduit a la fin pour 'v $xiirv/.TREE.11.$U' le 20130401083322 et ce */
/* donc afin de faciliter le decoupage... */
CAL2(Prin0("\n"));
/* Edition de la branche courante... */
Test(IZGT(profondeur_courante_effective))
Bblock
DEFV(Int,INIT(numero_incremental_relatif_des_branches,PREMIERE_BRANCHE));
/* Numero relatif de la branche courante... */
DEFV(Int,INIT(perturbation_aleatoire_du_nombre_de_branches_theta_en_chaque_noeud,UNDEF));
DEFV(Float,INIT(module___________de_la_branche_courante
,COND(IL_FAUT(mode_bidimensionnel)
,gRho_2D(ASI2(branche_courante,origine,x)
,ASI2(branche_courante,origine,y)
,ASI2(branche_courante,extremite,x)
,ASI2(branche_courante,extremite,y)
)
,gRho_3D(ASI2(branche_courante,origine,x)
,ASI2(branche_courante,origine,y)
,ASI2(branche_courante,origine,z)
,ASI2(branche_courante,extremite,x)
,ASI2(branche_courante,extremite,y)
,ASI2(branche_courante,extremite,z)
)
)
)
);
DEFV(Float,INIT(orientation_theta_de_la_branche_courante
,COND(IL_FAUT(mode_bidimensionnel)
,gaAngle1_2D(ASI2(branche_courante,origine,x)
,ASI2(branche_courante,origine,y)
,ASI2(branche_courante,extremite,x)
,ASI2(branche_courante,extremite,y)
)
,gaAngle1_3D(ASI2(branche_courante,origine,x)
,ASI2(branche_courante,origine,y)
,ASI2(branche_courante,origine,z)
,ASI2(branche_courante,extremite,x)
,ASI2(branche_courante,extremite,y)
,ASI2(branche_courante,extremite,z)
)
)
)
);
DEFV(Float,INIT(orientation_phi__de_la_branche_courante
,COND(IL_FAUT(mode_bidimensionnel)
,PI_SUR_2
,gaAngle2_3D(ASI2(branche_courante,origine,x)
,ASI2(branche_courante,origine,y)
,ASI2(branche_courante,origine,z)
,ASI2(branche_courante,extremite,x)
,ASI2(branche_courante,extremite,y)
,ASI2(branche_courante,extremite,z)
)
)
)
);
/* Caracterisation de la branche courante... */
DEFV(Float,INIT(module___________des_fils_de_la_branche_courante,FLOT__UNDEF));
DEFV(Float,INIT(orientation_theta_des_fils_de_la_branche_courante,FLOT__UNDEF));
DEFV(Float,INIT(orientation_phi__des_fils_de_la_branche_courante,FLOT__UNDEF));
GENERATION_DE_LA_VALEUR_ALEATOIRE_COURANTE(perturbation_aleatoire_du_nombre_de_branches_theta_en_chaque_noeud
,FLOT(borne_inferieure_perturbation_aleatoire_du_nombre_de_branches_theta)
,FLOT(borne_superieure_perturbation_aleatoire_du_nombre_de_branches_theta)
,INTE
);
EGAL(module___________des_fils_de_la_branche_courante
,MUL2(facteur_de_reduction_des_branches,module___________de_la_branche_courante)
);
EGAL(orientation_theta_des_fils_de_la_branche_courante
,SOUS(orientation_theta_de_la_branche_courante,MOIT(EVASEMENT_EFFECTIF_THETA_DES_BRANCHES))
);
/* Les fils de la branche courante vont etre d'une part plus petit a priori que lui et */
/* d'autre part dans une direction differente... */
Repe(NOMBRE_EFFECTIF_DE_BRANCHES_THETA_EN_CHAQUE_NOEUD)
Bblock
DEFV(vectorF_3D,fils_courant_de_la_branche_courante);
DEFV(Int,INIT(perturbation_aleatoire_du_nombre_de_branches_phi__en_chaque_noeud,UNDEF));
DEFV(Float,INIT(perturbation_aleatoire_de_rho_,FLOT__UNDEF));
DEFV(Float,INIT(perturbation_aleatoire_de_theta,FLOT__UNDEF));
DEFV(Float,INIT(perturbation_aleatoire_de_Z___,FLOT__UNDEF));
GENERATION_DE_LA_VALEUR_ALEATOIRE_COURANTE(perturbation_aleatoire_de_rho_
,borne_inferieure_perturbation_aleatoire_de_rho_
,borne_superieure_perturbation_aleatoire_de_rho_
,ndNEUT
);
#define NOMBRE_EFFECTIF_DE_BRANCHES_THETA \
NOMBRE_EFFECTIF_DE_BRANCHES_THETA_EN_CHAQUE_NOEUD \
/* Pour raccourcir certaines lignes qui suivent... */
GENERATION_EVENTUELLE_DE_LA_VALEUR_ALEATOIRE_COURANTE(perturbation_aleatoire_de_theta
,borne_inferieure_perturbation_aleatoire_de_theta
,borne_superieure_perturbation_aleatoire_de_theta
,ndNEUT
,PERTURBER_UNE_VALEUR(NOMBRE_EFFECTIF_DE_BRANCHES_THETA)
,SOUS(orientation_theta_de_la_branche_courante
,orientation_theta_des_fils_de_la_branche_courante
)
);
Test(IL_FAUT(mode_bidimensionnel))
Bblock
EGAL(perturbation_aleatoire_du_nombre_de_branches_phi__en_chaque_noeud,ZERO);
Eblock
ATes
Bblock
GENERATION_DE_LA_VALEUR_ALEATOIRE_COURANTE(perturbation_aleatoire_du_nombre_de_branches_phi__en_chaque_noeud
,FLOT(borne_inferieure_perturbation_aleatoire_du_nombre_de_branches_phi_)
,FLOT(borne_superieure_perturbation_aleatoire_du_nombre_de_branches_phi_)
,INTE
);
/* Possibilite introduite le 20130417151159... */
Eblock
ETes
GENERATION_EVENTUELLE_DE_LA_VALEUR_ALEATOIRE_COURANTE(perturbation_aleatoire_de_Z___
,borne_inferieure_perturbation_aleatoire_de_Z___
,borne_superieure_perturbation_aleatoire_de_Z___
,ndNEUT
,PERTURBER_UNE_VALEUR(NOMBRE_EFFECTIF_DE_BRANCHES_THETA)
,PAS_DE_PERTURBATION
);
/* On notera l'usage de 'ndNEUT(...)' et non pas de 'NEUT(...)' car, en effet, ce dernier */
/* est un operateur derivable et ne peut donc pas se situer au niveau le plus bas (et donc */
/* dans un '$K')... */
#undef NOMBRE_EFFECTIF_DE_BRANCHES_THETA
EGAL(orientation_phi__des_fils_de_la_branche_courante
,SOUS(orientation_phi__de_la_branche_courante,MOIT(EVASEMENT_EFFECTIF_PHI__DES_BRANCHES))
);
Repe(NOMBRE_EFFECTIF_DE_BRANCHES_PHI__EN_CHAQUE_NOEUD)
/* Boucle sur 'Phi' introduite le 20130417150500... */
Bblock
DEFV(Float,INIT(perturbation_aleatoire_de_phi_,FLOT__UNDEF));
Test(IL_FAUT(mode_bidimensionnel))
Bblock
EGAL(perturbation_aleatoire_de_phi_,FZERO);
Eblock
ATes
Bblock
#define NOMBRE_EFFECTIF_DE_BRANCHES_PHI_ \
NOMBRE_EFFECTIF_DE_BRANCHES_PHI__EN_CHAQUE_NOEUD \
/* Pour raccourcir certaines lignes qui suivent... */
GENERATION_EVENTUELLE_DE_LA_VALEUR_ALEATOIRE_COURANTE(perturbation_aleatoire_de_phi_
,borne_inferieure_perturbation_aleatoire_de_phi_
,borne_superieure_perturbation_aleatoire_de_phi_
,ndNEUT
,PERTURBER_UNE_VALEUR(NOMBRE_EFFECTIF_DE_BRANCHES_PHI_)
,SOUS(orientation_phi__de_la_branche_courante
,orientation_phi__des_fils_de_la_branche_courante
)
);
/* Possibilite introduite le 20130417142344... */
#undef NOMBRE_EFFECTIF_DE_BRANCHES_PHI_
Eblock
ETes
INITIALISATION_VECTEUR_3D(fils_courant_de_la_branche_courante
,ASI2(branche_courante,extremite,x)
,ASI2(branche_courante,extremite,y)
,ASI2(branche_courante,extremite,z)
,ADD2(ASI2(branche_courante,extremite,x)
,Xcartesienne_3D(MODULE_EFFECTIF____________DES_FILS_DE_LA_BRANCHE_COURANTE
,ORIENTATION_THETA_EFFECTIVE_DES_FILS_DE_LA_BRANCHE_COURANTE
,ORIENTATION_PHI__EFFECTIVE_DES_FILS_DE_LA_BRANCHE_COURANTE
)
)
,ADD2(ASI2(branche_courante,extremite,y)
,Ycartesienne_3D(MODULE_EFFECTIF____________DES_FILS_DE_LA_BRANCHE_COURANTE
,ORIENTATION_THETA_EFFECTIVE_DES_FILS_DE_LA_BRANCHE_COURANTE
,ORIENTATION_PHI__EFFECTIVE_DES_FILS_DE_LA_BRANCHE_COURANTE
)
)
,ADD2(ASI2(branche_courante,extremite,z)
,COND(IL_FAUT(mode_bidimensionnel)
,MUL2(facteur_de_reduction_des_branches,perturbation_aleatoire_de_Z___)
,Zcartesienne_3D(MODULE_EFFECTIF____________DES_FILS_DE_LA_BRANCHE_COURANTE
,ORIENTATION_THETA_EFFECTIVE_DES_FILS_DE_LA_BRANCHE_COURANTE
,ORIENTATION_PHI__EFFECTIVE_DES_FILS_DE_LA_BRANCHE_COURANTE
)
)
)
);
/* Generation du fils courant de la branche courante... */
/* */
/* On notera les conventions d'ecritures ci-dessus qui sont contraires a celle de la */
/* definition de 'v $ximD/definit.1$DEF Xcartesienne_3D.rho.phi.theta.' et de */
/* 'v $ximD/definit.1$DEF Ycartesienne_3D.rho.phi.theta.' et ce afin de rappeler */
/* qu'ici 'theta' est l'angle polaire dans le plan {OX,OY}... */
/* */
/* */
/* Le 20160216134258, on notera une certaine "ambiguite". En effet, il y a des */
/* configurations de {theta,phi} qui donnent les memes coordonnees tridimensionnelles. */
/* Ainsi, par exemple, a partir de : */
/* */
/* $xci/valeurs_Arbre.01$X \ */
/* tridimensionnel=VRAI \ */
/* X1=0.5 Y1=0 Z1=0.5 \ */
/* X2=0.5 Y2=0.5 Z2=0.5 \ */
/* iterations=2 \ */
/* nombre_branches_theta=2 evasement_theta=$pis2 \ */
/* nombre_branches_phi=2 evasement_phi=$pis2 \ */
/* facteur_reduction=0.75 */
/* */
/* on obtient en particulier: */
/* */
/* --> theta=-0.000000 phi=-0.000000 */
/* | Xcart_3D(...)=-0.000000 Ycart_3D(...)=0.000000 Zcart_3D(...)=0.281250 */
/* | Arborescence=1/1/1/ */
/* # X1=+0.6875 Y1=+0.6875 Z1=+0.76516504 */
/* | X2=+0.6875 Y2=+0.6875 Z2=+1.046415 <--------------------------------- */
/* | | */
/* --> theta=1.570796 phi=-0.000000 | */
/* Xcart_3D(...)=-0.000000 Ycart_3D(...)=-0.000000 Zcart_3D(...)=0.281250 = */
/* Arborescence=1/1/3/ | */
/* X1=+0.6875 Y1=+0.6875 Z1=+0.76516504 | */
/* X2=+0.6875 Y2=+0.6875 Z2=+1.046415 <--------------------------------- */
/* */
/* Ainsi, avec deux couples differents {theta,phi} (soit {0,0} et {pi/2,0}), on obtient */
/* deux fois le meme point {X2,Y2,Z2}... */
/* */
/* Tout cela a ete verifie en parallele grace a : */
/* */
/* $xrv/RPT_XYZ.01$X \ */
/* ne=1 \ */
/* LISTE_RHO=1 \ */
/* LISTE_PHI=<le 'theta' en fait> \ */
/* LISTE_THETA=<le 'phi' en fait> \ */
/* px=0/1 py=0/1 pz=0/1 */
/* */
/* en n'oubliant donc pas qu'ici {theta,phi} sont inverses par rapport a l'usage habituel... */
begin_nouveau_block
Bblock
DEFV(Positive,INIT(numero_aligne_effectif,UNDEF));
INCR(numero_aligne_des_branches,I);
EGAL(numero_aligne_effectif,numero_aligne_des_branches);
/* A priori, le numero dit "aligne" progresse quitte a annuler cela ensuite si besoin est... */
Test(IL_FAUT(conserver_la_direction_initiale))
Bblock
DEFV(deltaF_3D,delta_branche_courante);
DEFV(deltaF_3D,delta_fils_courant_de_la_branche_courante);
DEFV(deltaF_3D,produit_vectoriel_des_deux_branches_successives);
INITIALISATION_ACCROISSEMENT_3D(delta_branche_courante
,SOUS(ASI2(branche_courante,extremite,x)
,ASI2(branche_courante,origine,x)
)
,SOUS(ASI2(branche_courante,extremite,y)
,ASI2(branche_courante,origine,y)
)
,SOUS(ASI2(branche_courante,extremite,z)
,ASI2(branche_courante,origine,z)
)
);
INITIALISATION_ACCROISSEMENT_3D(delta_fils_courant_de_la_branche_courante
,SOUS(ASD2(fils_courant_de_la_branche_courante,extremite,x)
,ASD2(fils_courant_de_la_branche_courante,origine,x)
)
,SOUS(ASD2(fils_courant_de_la_branche_courante,extremite,y)
,ASD2(fils_courant_de_la_branche_courante,origine,y)
)
,SOUS(ASD2(fils_courant_de_la_branche_courante,extremite,z)
,ASD2(fils_courant_de_la_branche_courante,origine,z)
)
);
PRODUIT_VECTORIEL_ACCROISSEMENT_3D(produit_vectoriel_des_deux_branches_successives
,delta_branche_courante
,delta_fils_courant_de_la_branche_courante
);
Test(IFLE(GpytF3D(ASD1(produit_vectoriel_des_deux_branches_successives,dx)
,ASD1(produit_vectoriel_des_deux_branches_successives,dy)
,ASD1(produit_vectoriel_des_deux_branches_successives,dz)
)
,epsilon_de_colinearite
)
)
Bblock
EGAL(numero_aligne_effectif,numero_aligne_de_la_branche_courante);
/* Lorsque la branche courante ("fils") est alignee (a epsilon pres) avec la branche */
/* "pere", on conserve le numero dit "aligne"... */
DECR(numero_aligne_des_branches,I);
/* Puis on annule le 'INCR(...)' inutile donc fait precedemment... */
Eblock
ATes
Bblock
Eblock
ETes
Eblock
ATes
Bblock
Eblock
ETes
INCR(numero_incremental_absolu__des_branches,I);
CALS(GenerationDeLArbre(PRED(profondeur_courante_effective)
,numero_du_noeud_courant
,numero_aligne_effectif
,ADRESSE(fils_courant_de_la_branche_courante)
,etiquette_du_noeud_courant
,chain_Aconcaten3(filiation,chain_numero_exact(NUMERO_INCREMENTAL_DES_BRANCHES),C_SLASH)
)
);
/* Generation recursive... */
Eblock
end_nouveau_block
INCR(numero_incremental_relatif_des_branches,I);
INCR(orientation_phi__des_fils_de_la_branche_courante
,DIVZ(EVASEMENT_EFFECTIF_PHI__DES_BRANCHES,FLOT(PRED(NOMBRE_EFFECTIF_DE_BRANCHES_PHI__EN_CHAQUE_NOEUD)))
);
/* Le 'PRED(...)' vient du fameux probleme des piquets et des intervalles... */
Eblock
ERep
INCR(orientation_theta_des_fils_de_la_branche_courante
,DIVZ(EVASEMENT_EFFECTIF_THETA_DES_BRANCHES,FLOT(PRED(NOMBRE_EFFECTIF_DE_BRANCHES_THETA_EN_CHAQUE_NOEUD)))
);
/* Le 'PRED(...)' vient du fameux probleme des piquets et des intervalles... */
Eblock
ERep
Eblock
ATes
Bblock
Test(IL_FAUT(marquer_l_extremite_des_branches))
Bblock
/* Edition introduite le 20160209141408... */
CAL2(Prin0("FinDeBranche\n"));
Eblock
ATes
Bblock
Eblock
ETes
Eblock
ETes
EDITIONS(numero_du_noeud_courant
,etiquette_du_noeud_precedent
,BLOC(Bblock
Test(IFOU(IL_FAUT(numeroter_les_noeuds_de_l_arbre),IL_FAUT(etiquetter_les_noeuds_de_l_arbre)))
Bblock
CAL2(Prin1("Retour......=%s",filiation));
Eblock
ATes
Bblock
Eblock
ETes
Eblock
)
,BLOC(Bblock
INCR(numero_du_noeud_courant,I);
/* On notera qu'un noeud qui est a un embranchement (qui n'est donc pas une feuille) */
/* a plusieurs numeros differents correspondant aux differentes fois ou l'on passe par */
/* lui... */
Eblock
)
,BLOC(VIDE;)
,BLOC(Bblock
Test(IL_FAUT(numeroter_les_noeuds_de_l_arbre))
Bblock
PRINT(ASI2(branche_courante,origine,x),"X2",".^^^");
PRINT(ASI2(branche_courante,origine,y),"Y2",".^^^");
PRINT(ASI2(branche_courante,origine,z),"Z2",".^^^");
/* ATTENTION : ce n'ext pas un erreur, c'est bien 'origine' et {X2,Y2,Z2} qu'il faut */
/* utiliser lors du "Retour"... */
/* */
/* On notera qu'en permanence {X2,Y2,Z2} donne les coordonnees du noeud 'NumeroNoeud'... */
CAL2(Prin0(" "));
Eblock
ATes
Bblock
Eblock
ETes
CAL2(Prin0("\n"));
Eblock
)
);
RETU_ERROR;
Eblock
EFonctionI
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* G E N E R A T I O N D ' A R B R E S R E C U R S I F S : */
/* */
/*************************************************************************************************************************************/
#define NUMERO_DE_LA_RACINE_DE_QUADRANGULATION \
PRED(numero_de_la_racine_de_l_arbre)
#define ETIQUETTE_DE_LA_RACINE_DE_QUADRANGULATION \
PRED(etiquette_de_la_racine_de_l_arbre)
BCommande(nombre_d_arguments,arguments)
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
DEFV(CHAR,INIC(POINTERc(filiation),C_VIDE));
/* Definition de la filiation... */
/*..............................................................................................................................*/
INITIALISATION_POINT_3D(racine_de_quadrangulation
,BRANCHE_DE_DEPART_X0,BRANCHE_DE_DEPART_Y0,BRANCHE_DE_DEPART_Z0
);
INITIALISATION_VECTEUR_3D(branche_de_depart
,BRANCHE_DE_DEPART_X1,BRANCHE_DE_DEPART_Y1,BRANCHE_DE_DEPART_Z1
,BRANCHE_DE_DEPART_X2,BRANCHE_DE_DEPART_Y2,BRANCHE_DE_DEPART_Z2
);
GET_ARGUMENTSi(nombre_d_arguments
,BLOC(GET_ARGUMENT_L("compatibilite_20160216=",compatibilite_20160216);
/* Parametre introduit le 20160216170712... */
GET_ARGUMENT_L("bidimensionnel=""2D=",mode_bidimensionnel);
GET_ARGUMENT_N("tridimensionnel=""3D=",mode_bidimensionnel);
/* Parametres introduits le 20130415133426... */
GET_ARGUMENT_L("numeros_absolus=""na=",numero_absolu_des_branches);
GET_ARGUMENT_N("numeros_relatifs=""nr=",numero_absolu_des_branches);
GET_ARGUMENT_L("numeroter=""num=",numeroter_les_noeuds_de_l_arbre);
GET_ARGUMENT_I("numero_racine=""numr=",numero_de_la_racine_de_l_arbre);
GET_ARGUMENT_L("etiquetter=""eti=",etiquetter_les_noeuds_de_l_arbre);
GET_ARGUMENT_I("etiquette_racine=""etir=",etiquette_de_la_racine_de_l_arbre);
GET_ARGUMENT_L("etiquettage_exotique=""exotique=",l_etiquettage_est_exotique);
/* Parametres introduits le 20150622112341 et complete le 20150625105105... */
GET_ARGUMENT_L("marquer_extremite_branches=""meb=",marquer_l_extremite_des_branches);
/* Parametres introduits le 20160209141408... */
GET_ARGUMENT_F("x0=""X0=",ASD1(racine_de_quadrangulation,x));
GET_ARGUMENT_F("y0=""Y0=",ASD1(racine_de_quadrangulation,y));
GET_ARGUMENT_F("z0=""Z0=",ASD1(racine_de_quadrangulation,z));
/* Parametres introduits le 20150624085814... */
GET_ARGUMENT_F("x1=""X1=",ASD2(branche_de_depart,origine,x));
GET_ARGUMENT_F("y1=""Y1=",ASD2(branche_de_depart,origine,y));
GET_ARGUMENT_F("z1=""Z1=",ASD2(branche_de_depart,origine,z));
GET_ARGUMENT_F("x2=""X2=",ASD2(branche_de_depart,extremite,x));
GET_ARGUMENT_F("y2=""Y2=",ASD2(branche_de_depart,extremite,y));
GET_ARGUMENT_F("z2=""Z2=",ASD2(branche_de_depart,extremite,z));
GET_ARGUMENT_F("epsilon_colinearite=""epsilon=",epsilon_de_colinearite);
/* Parametres introduits le 20160324142723... */
GET_ARGUMENT_I("profondeur=""recursivite=""iterations=",profondeur_de_la_generation);
GET_ARGUMENT_L("profondeur_aleatoire=""pa=",faire_varier_aleatoirement_la_profondeur_de_la_generation);
GET_ARGUMENT_N("profondeur_fixe=""pf=",faire_varier_aleatoirement_la_profondeur_de_la_generation);
GET_ARGUMENT_F("probabilite_profondeur=""pp=",probabilite_d_interrompre_la_progression_dans_l_arbre);
/* Parametres introduits le 20150622093648... */
GET_ARGUMENT_I("nombre_branches_theta=""branches_theta=""nbt=",nombre_de_branches_theta_en_chaque_noeud);
GET_ARGUMENT_F("evasement_theta=""anglet=""et=",evasement_total_theta_des_branches);
GET_ARGUMENT_F("facteur_evasement_theta=""facteurt=""ft=",facteur_de_l_evasement_theta_des_branches);
GET_ARGUMENT_I("nombre_branches_phi=""branches_phi=""nbp=",nombre_de_branches_phi__en_chaque_noeud);
GET_ARGUMENT_F("evasement_phi=""anglep=""ep=",evasement_total_phi__des_branches);
GET_ARGUMENT_F("facteur_evasement_phi=""facteurp=""fp=",facteur_de_l_evasement_phi__des_branches);
/* Parametres introduits le 20130417145751 et completes le 20160217171323... */
GET_ARGUMENT_F("facteur_reduction=""facteur=",facteur_de_reduction_des_branches);
GET_ARGUMENT_I("graine=""g=",graine);
GET_ARGUMENT_L("conserver_direction_initiale=""conserver=""cdi=",conserver_la_direction_initiale);
/* Parametres introduits le 20160321092815... */
GET_ARGUMENT_I("borne_inferieure_branches_theta=""bipbt="
,borne_inferieure_perturbation_aleatoire_du_nombre_de_branches_theta
);
GET_ARGUMENT_I("borne_superieure_branches_theta=""bspbt="
,borne_superieure_perturbation_aleatoire_du_nombre_de_branches_theta
);
GET_ARGUMENT_I("borne_inferieure_branches_phi=""bipbp="
,borne_inferieure_perturbation_aleatoire_du_nombre_de_branches_phi_
);
GET_ARGUMENT_I("borne_superieure_branches_phi=""bspbp="
,borne_superieure_perturbation_aleatoire_du_nombre_de_branches_phi_
);
/* Parametres introduits le 20130417151621... */
GET_ARGUMENT_F("borne_inferieure_rho=""bipr=",borne_inferieure_perturbation_aleatoire_de_rho_);
GET_ARGUMENT_F("borne_superieure_rho=""bspr=",borne_superieure_perturbation_aleatoire_de_rho_);
GET_ARGUMENT_F("borne_inferieure_theta=""bipt=",borne_inferieure_perturbation_aleatoire_de_theta);
GET_ARGUMENT_F("borne_superieure_theta=""bspt=",borne_superieure_perturbation_aleatoire_de_theta);
GET_ARGUMENT_F("borne_inferieure_phi=""bipp=",borne_inferieure_perturbation_aleatoire_de_phi_);
GET_ARGUMENT_F("borne_superieure_phi=""bspp=",borne_superieure_perturbation_aleatoire_de_phi_);
GET_ARGUMENT_F("borne_inferieure_Z=""bipz=",borne_inferieure_perturbation_aleatoire_de_Z___);
GET_ARGUMENT_F("borne_superieure_Z=""bspz=",borne_superieure_perturbation_aleatoire_de_Z___);
GET_ARGUMENT_L("signer_valeurs=""signe=",signer_les_valeurs);
/* Parametres introduits le 20150628185445... */
GET_ARGUMENT_L("cartesiennes=""cartesienne=",editer_les_coordonnees_sous_forme_cartesienne);
GET_ARGUMENT_N("spheriques=""spherique=",editer_les_coordonnees_sous_forme_cartesienne);
)
);
EGAL(numero_du_noeud_courant,numero_de_la_racine_de_l_arbre);
EDITIONS(NUMERO_DE_LA_RACINE_DE_QUADRANGULATION
,ETIQUETTE_DE_LA_RACINE_DE_QUADRANGULATION
,BLOC(Bblock
Test(IFOU(IL_FAUT(numeroter_les_noeuds_de_l_arbre),IL_FAUT(etiquetter_les_noeuds_de_l_arbre)))
Bblock
CAL2(Prin0("RacineQuadrangulation"));
Eblock
ATes
Bblock
Eblock
ETes
Eblock
)
,BLOC(VIDE;)
,BLOC(VIDE;)
,BLOC(Bblock
Test(IL_FAUT(numeroter_les_noeuds_de_l_arbre))
Bblock
PRINT(ASD1(racine_de_quadrangulation,x),"X2",".^^^");
PRINT(ASD1(racine_de_quadrangulation,y),"Y2",".^^^");
PRINT(ASD1(racine_de_quadrangulation,z),"Z2",".^^^");
/* On notera qu'en permanence {X2,Y2,Z2} donne les coordonnees du noeud 'NumeroNoeud'... */
CAL2(Prin0(" "));
Eblock
ATes
Bblock
Eblock
ETes
CAL2(Prin0("\n"));
Eblock
)
);
EDITIONS(numero_de_la_racine_de_l_arbre
,etiquette_de_la_racine_de_l_arbre
,BLOC(Bblock
Test(IFOU(IL_FAUT(numeroter_les_noeuds_de_l_arbre),IL_FAUT(etiquetter_les_noeuds_de_l_arbre)))
Bblock
CAL2(Prin0("RacineArbre"));
Eblock
ATes
Bblock
Eblock
ETes
Eblock
)
,BLOC(Bblock
Test(IL_FAUT(numeroter_les_noeuds_de_l_arbre))
Bblock
PRINT(NUMERO_DE_LA_RACINE_DE_QUADRANGULATION,"NumeroPere","d");
Eblock
ATes
Bblock
Eblock
ETes
Eblock
)
,BLOC(VIDE;)
,BLOC(Bblock
Test(IL_FAUT(numeroter_les_noeuds_de_l_arbre))
Bblock
PRINT(BRANCHE_DE_DEPART_X1,"X2",".^^^");
PRINT(BRANCHE_DE_DEPART_Y1,"Y2",".^^^");
PRINT(BRANCHE_DE_DEPART_Z1,"Z2",".^^^");
/* ATTENTION : ce n'ext pas un erreur, c'est bien {X1,Y,Z1} et {X2,Y2,Z2} qu'il faut */
/* utiliser pour la racine de l'arbre... */
/* */
/* On notera qu'en permanence {X2,Y2,Z2} donne les coordonnees du noeud 'NumeroNoeud'... */
CAL2(Prin0(" "));
Eblock
ATes
Bblock
Eblock
ETes
CAL2(Prin0("\n"));
Eblock
)
);
SPIRALE_VALIDATION;
INITIALISATION_POINT_2D(point_courant_de_l_espace_de_parametrage_2D,Xmin,Ymin);
CALS(GenerationDeLArbre(profondeur_de_la_generation
,numero_de_la_racine_de_l_arbre
,numero_aligne_des_branches
,ADRESSE(branche_de_depart)
,etiquette_de_la_racine_de_l_arbre
,chain_Aconcaten3(filiation,chain_numero_exact(numero_incremental_absolu__des_branches),C_SLASH)
)
);
/* Initialisation de la recursivite... */
RETU_Commande;
Eblock
ECommande