/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        S U I T E   D E   S Y R A C U S E  :                                                                                       */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*        Author of '$xrv/Syracuse.11$K' :                                                                                           */
/*                                                                                                                                   */
/*                    Jean-Francois COLONNA (LACTAMME, 20150414164957).                                                              */
/*                                                                                                                                   */
/*************************************************************************************************************************************/

/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        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
#include  maths_fonct_NOMBRES_EXT

/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        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_D_ITERATIONS_MAXIMAL                                                                                                   \
                    MILLE                                                                                                               \
                                        /* Nombre maximal d'iterations....                                                           */
#define   RANG_D_APPARITION_DE_LA_SUITE_4_2_1                                                                                           \
                    ZERO                                                                                                                \
                                        /* Pour initialiser 'rang_d_apparition_de_la_suite_4_2_1'.                                   */

#define   DIVISEUR                                                                                                                      \
                    DEUX
#define   ALPHA___                                                                                                                      \
                    TROIS
#define   BETA____                                                                                                                      \
                    UN
                                        /* Definition des parametres.                                                                */
#define   VALEUR_D_ARRET                                                                                                                \
                    UN                                                                                                                  \
                                        /* Valeur d'arret, le '1' de {4,2,1} etant le plus logique.                                  */

/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        D E F I N I T I O N   D E S   F I C H I E R S  :                                                                           */
/*                                                                                                                                   */
/*************************************************************************************************************************************/
#include  xrv/ARITHMET.1d.I"
                                        /* Passage a l'allocation dynamique le 20060214132914...                                     */
#include  xrv/ARITHMET.21.I"
#include  xrv/champs_5.41.I"

#define   VALEUR_IMPLICITE                                                                                                              \
                    FZERO

gGENERATION_D_UN_FICHIER(fichier_des_valeurs,liste_des_valeurs);
                                        /* Definition en memoire des fichiers.                                                       */

#define   ELEMENT_DU_FICHIER(index)                                                                                                     \
                    gELEMENT_DU_FICHIER(liste_des_valeurs,index)
                                        /* Acces a un element courant des fichiers.                                                  */

/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        S U I T E   D E   S Y R A C U S E  :                                                                                       */
/*                                                                                                                                   */
/*************************************************************************************************************************************/
BCommande(nombre_d_arguments,arguments)
/*-----------------------------------------------------------------------------------------------------------------------------------*/
     Bblock
     DEFV(Int,INIT(nombre_d_iterations_maximal,NOMBRE_D_ITERATIONS_MAXIMAL));
                                        /* Nombre maximal d'iterations....                                                           */

     DEFV(Int,INIT(diviseur,DIVISEUR));
     DEFV(Int,INIT(alpha___,ALPHA___));
     DEFV(Int,INIT(beta____,BETA____));
                                        /* Definition des parametres.                                                                */

     DEFV(Int,INIT(valeur_d_arret,VALEUR_D_ARRET));
                                        /* Valeur d'arret, le '1' de {4,2,1} etant le plus logique.                                  */

#include  xrv/ARITHMET.22.I"
#include  xci/valeurs.03.I"
     /*..............................................................................................................................*/
#include  xrv/champs_5.1A.I"

     GET_ARGUMENTS_(nombre_d_arguments
                   ,BLOC(PROCESS_ARGUMENT_I("nombre_elements=""ne=",nombre_d_elements
                                           ,BLOC(VIDE;)
                                           ,BLOC(Bblock
                                                 PRINT_AVERTISSEMENT("'ne=' doit etre defini avant toute entree de fichiers");
                                                 Eblock
                                                 )
                                            );

                         PROCESS_ARGUMENTS_DE_DEFINITION_DES_FICHIERS_01;

                         PROKESF_ARGUMENT_FICHIER("fichier="
                                                 ,fichier_des_valeurs
                                                 ,liste_des_valeurs
                                                 ,VALEUR_IMPLICITE
                                                 ,lTRANSFORMAT_0d
                                                 ,iGENERATION_D_UN_FICHIER
                                                  );

                         GET_ARGUMENT_I("iterations=""max=",nombre_d_iterations_maximal);

                         PROCESS_ARGUMENTS_DE_PARAMETRAGE_DE_LA_GENERATION_DE_SUITE_DE_VALEURS_3;

                         PROCESS_ARGUMENTS_DE_PARAMETRAGE_DE_LA_GENERATION_DE_SUITE_DE_VALEURS_1;

                         PROCESS_ARGUMENTS_DE_PARAMETRAGE_DE_LA_GENERATION_DE_SUITE_DE_VALEURS_5;
                                        /* Cette procedure fut introduite le 20211005105153...                                       */
                         )
                    );

     gOPERATION_SUR_LES_FICHIERS(BLOC(
                                      DEFV(Float,INIT(valeur_courante,ELEMENT_DU_FICHIER(index)));
                                      DEFV(Int,INIT(nombre_courant,UNDEF));
                                        /* Recuperation de la valeur courante dans les fichier.                                      */

                                      DEFV(Int,INIT(U_n,UNDEF));
                                        /* Definition de U(n).                                                                       */

                                      DEFV(Int,INIT(iterations,nombre_d_iterations_maximal));
                                      DEFV(Logical,INIT(on_a_rencontre_la_suite_4_2_1,FAUX));
                                      DEFV(Int,INIT(rang_d_apparition_de_la_suite_4_2_1,RANG_D_APPARITION_DE_LA_SUITE_4_2_1));
                                        /* Donnees de controle des iterations.                                                       */

                                      Test(N_EST_PAS_ENTIER(valeur_courante))
                                           Bblock
                                           PRINT_ERREUR("une valeur n'est pas entiere");
                                           CAL1(Prer1("(il s'agit de %f)\n",valeur_courante));
                                           Eblock
                                      ATes
                                           Bblock
                                           Eblock
                                      ETes

                                      EGAL(nombre_courant,INTE(valeur_courante));

                                      Test(IZLT(nombre_courant))
                                           Bblock
                                           PRINT_ERREUR("une valeur est negative");
                                           CAL1(Prer1("(le nombre %d est negatif)\n",nombre_courant));

                                           EGAL(nombre_courant,ABSO(nombre_courant));
                                        /* On prend donc la valeur absolue des nombres negatifs...                                   */
                                           Eblock
                                      ATes
                                           Bblock
                                           Eblock
                                      ETes

                                      EGAL(U_n,nombre_courant);
                                        /* Definition de 'U(0)'...                                                                   */

                                      Tant(IFET(EST_FAUX(on_a_rencontre_la_suite_4_2_1)
                                               ,IZGT(iterations)
                                                )
                                           )
                                           Bblock
                                           Test(EST_FAUX(on_a_rencontre_la_suite_4_2_1))
                                                Bblock
                                                Test(IFEQ(U_n,valeur_d_arret))
                                                     Bblock
                                                     EGAL(on_a_rencontre_la_suite_4_2_1,VRAI);
                                                     Eblock
                                                ATes
                                                     Bblock
                                                     INCR(rang_d_apparition_de_la_suite_4_2_1,I);
                                                     DECR(iterations,I);
                                                     Eblock
                                                ETes
                                                Eblock
                                           ATes
                                                Bblock
                                                Eblock
                                           ETes

                                           EGAL(U_n
                                               ,COND(EST_PAIR(U_n)
                                                    ,DIVI(U_n,diviseur)
                                                    ,AXPB(alpha___,U_n,beta____)
                                                     )
                                                );
                                        /* Calcul de la suite de Syracuse :                                                          */
                                        /*                                                                                           */
                                        /*                  U  = U    / D       si U    est pair,                                    */
                                        /*                   n    n-1               n-1                                              */
                                        /*                                                                                           */
                                        /*                  U  = A * U    + B   si U    est impair,                                  */
                                        /*                   n        n-1           n-1                                              */
                                        /*                                                                                           */
                                        /* avec :                                                                                    */
                                        /*                                                                                           */
                                        /*                  D = diviseur = 2                                                         */
                                        /*                  A = alpha    = 3                                                         */
                                        /*                  B = beta     = 1                                                         */
                                        /*                                                                                           */
                                        /* et :                                                                                      */
                                        /*                                                                                           */
                                        /*                  U  = 1                                                                   */
                                        /*                   0                                                                       */
                                        /*                                                                                           */
                                        /* Tout ceci est "inspire" de 'v $xci/valeurs_Syra$K'...                                     */
                                           Eblock
                                      ETan

                                      Test(EST_FAUX(on_a_rencontre_la_suite_4_2_1))
                                           Bblock
                                           Test(IFEQ(valeur_d_arret,VALEUR_D_ARRET))
                                                Bblock
                                                PRINT_ATTENTION("la suite {4,2,1} n'a pas ete atteinte");
                                                Eblock
                                           ATes
                                                Bblock
                                                PRINT_ATTENTION("la valeur d'arret n'a pas ete atteinte");
                                                Eblock
                                           ETes
                                           Eblock
                                      ATes
                                           Bblock
                                           Eblock
                                      ETes
                                      )
                                ,FLOT(rang_d_apparition_de_la_suite_4_2_1)
                                ,EDITER_LA_VALEUR_RESULTANTE_DANS_gOPERATION_SUR_LES_FICHIERS
                                ,nombre_d_exemplaires_du_resultat_de_l_operation_sur_les_valeurs_courantes
                                 );
                                        /* Rang d'apparition de la suite {4,2,1} du fichier argument.                                */

     lGENERATION_D_UN_FICHIER(liste_des_valeurs,VALEUR_IMPLICITE);

     RETU_Commande;
     Eblock
ECommande



Copyright © Jean-François COLONNA, 2019-2024.
Copyright © CMAP (Centre de Mathématiques APpliquées) UMR CNRS 7641 / École polytechnique, Institut Polytechnique de Paris, 2019-2024.