/*************************************************************************************************************************************/
/* */
/* E T U D E D E L A D Y N A M I Q U E D E V E R H U L S T */
/* E N P A S S A N T D E L A D O U B L E A L A S I M P L E */
/* P R E C I S I O N , O U E N C H A N G E A N T D ' O R D I N A T E U R */
/* A V E C E D I T I O N D E X [ N ] : */
/* */
/* */
/* Author of '$xrk/verhulst.01$K' : */
/* */
/* Jean-Francois COLONNA (LACTAMME, 1988??????????). */
/* */
/*************************************************************************************************************************************/
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* 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 : */
/* */
/*************************************************************************************************************************************/
#define PRAGMA_CPP_____AUTORISER_LE_GooF
/* Ceci est essentiel puisque l'on souhaite etudier l'influence de la syntaxe sur les */
/* resultats obtenus. Ceci manquait et a ete introduit le 20040420232732. */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* 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 PRECIS Double \
/* Precision dans laquelle faire les calculs ('Float' ou 'Double'). */
#define NOMBRE_D_ITERATIONS \
PARE(100000) \
/* Nombre d'iterations a effectuer. Nota : le phenomene se produit aussi pour des valeurs */ \
/* plus petites (par exemple 100, ou meme 10...). */
#define PAS_D_EDITION \
PARE(10000) \
/* On editera la valeur de X[n] toutes les 'PAS_D_EDITION' valeurs. */
#define VALEUR_INITIALE_X0 \
PARE(0.5) \
/* Valeur de X[0]. */
#define TAUX_DE_CROISSANCE \
PARE(3.0) \
/* Valeur de 'r'. */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* M A C R O S U T I L E S : */
/* */
/*************************************************************************************************************************************/
#define ITERATION_DE_VERHULST(Xn) \
Bblock \
EGAL(Xn \
,SOUS(MUL2(ADD2(taux_de_croissance,I) \
,Xn \
) \
,MUL2(taux_de_croissance \
,EXP2(Xn) \
) \
) \
); \
/* Nota important : le code genere correspond a : */ \
/* */ \
/* 2 */ \
/* ((1+r).X[n]) - (r.(X[n] )) */ \
/* */ \
/* qui ne donne pas du tout les memes resultats numeriques que : */ \
/* */ \
/* 2 */ \
/* ((1+r).X[n]) - (r.X[n] ) */ \
/* */ \
/* ce qui est dans la logique du chaos deterministe... */ \
Eblock
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* E T U D E D E L A D Y N A M I Q U E D E V E R H U L S T : */
/* */
/* */
/* Definition : */
/* */
/* Considerons la relation de recurrence */
/* suivante : */
/* */
/* 2 */
/* X[n+1] = (1+r).X[n] - r.X[n] */
/* */
/* Cette relation correspond par exemple */
/* a la population annuelle d'une colonie */
/* animale, dont le taux de croissance est R ; */
/* par definition, on a : */
/* */
/* X[n+1] - X[n] */
/* R = ------------- */
/* X[n] */
/* */
/* d'ou : */
/* */
/* X[n+1] = (1+R).X[n] */
/* */
/* le taux de croissance n'est en fait pas */
/* constant, et vaut : */
/* */
/* R = r.(1-X[n]) */
/* */
/* d'ou la premiere formule. */
/* */
/* Celle-ci, bien que strictement deterministe */
/* pour des valeurs de 'r' superieures a 2.57, */
/* donnent pour des grandes valeurs 'N' de 'n' */
/* des series de valeurs completement chaotiques */
/* et qui sont completement sensibles a la valeur */
/* initiale X[0]. */
/* */
/* */
/* Objectif : */
/* */
/* montrer que les resultats changent du */
/* tout au tout soit en changeant d'ordinateur, */
/* soit plus simplement en changeant la precision */
/* des calculs (ce qui est previsible, puisque */
/* cette iteration chaotique depend de tous les */
/* bits, et donc de la representation interne */
/* des nombres flottants)... */
/* */
/* */
/* Resultats obtenus : */
/* */
/* 1 - Calculs effectues en DOUBLE-PRECISION */
/* sur un ordinateur BULL-DPX5000 sous SPIX. */
/* */
/* (pour un taux de croissance : r=3.000000) */
/* */
/* X[ 0] = 0.500000 */
/* X[10000] = 1.144026 */
/* X[20000] = 0.787576 */
/* X[30000] = 0.200866 */
/* X[40000] = 1.185065 */
/* X[50000] = 1.052220 */
/* X[60000] = 0.658518 */
/* X[70000] = 0.000177 */
/* X[80000] = 0.796571 */
/* X[90000] = 0.406592 */
/* */
/* */
/* 2 - Calculs effectues en DOUBLE-PRECISION */
/* sur un ordinateur DEC-VAX8600 sous ULTRIX. */
/* */
/* (pour un taux de croissance : r=3.000000) */
/* */
/* X[ 0] = 0.500000 */
/* X[10000] = 1.302424 */
/* X[20000] = 0.000830 */
/* X[30000] = 0.667811 */
/* X[40000] = 1.256265 */
/* X[50000] = 0.950671 */
/* X[60000] = 0.382921 */
/* X[70000] = 0.107478 */
/* X[80000] = 1.257527 */
/* X[90000] = 0.584826 */
/* */
/* Impressionnant, non ? */
/* */
/* */
/*************************************************************************************************************************************/
BCommande(nombre_d_arguments,arguments)
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
DEFV(PRECIS,INIT(taux_de_croissance,TAUX_DE_CROISSANCE));
DEFV(PRECIS,INIT(Xn,VALEUR_INITIALE_X0));
/* Definition de la recurrence X[n]. */
DEFV(Int,INIT(n,UNDEF));
/* Definition de l'index de la recurrence 'n'. */
/*..............................................................................................................................*/
GET_ARGUMENTS_(nombre_d_arguments
,BLOC(VIDE;)
);
CAL2(Prin1("taux de croissance : r=%g\n\n",taux_de_croissance));
DoIn(n,PRED(UN),PRED(NOMBRE_D_ITERATIONS),I)
Bblock
Test(IZEQ(REST(n,PAS_D_EDITION)))
Bblock
CAL2(Prin2("X[%6d] = %g\n",n,Xn));
Eblock
ATes
Bblock
Eblock
ETes
USs_GooF(BLOC(
Bblock
ITERATION_DE_VERHULST(Xn);
Eblock
)
);
/* Procedure introduite le 20080106095855... */
Eblock
EDoI
CAL2(Prin0("\n"));
RETU_Commande;
Eblock
ECommande