/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        G E N E R A T I O N   D ' U N   E N S E M B L E   D E   N O M B R E S   Q U A N T I Q U E S   ( n , m , l )  :             */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*                    Cette commande genere une sequence                                                                             */
/*                  de valeurs possibles d'un ou plusieurs                                                                           */
/*                  des nombres quantiques (n,m,l).                                                                                  */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*        Author of '$xrq/nombres_Q.01$K' :                                                                                          */
/*                                                                                                                                   */
/*                    Jean-Francois COLONNA (LACTAMME, 1993??????????).                                                              */
/*                                                                                                                                   */
/*************************************************************************************************************************************/

/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        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_____MODULE_NON_DERIVABLE

/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        F I C H I E R S   D ' I N C L U D E S  :                                                                                   */
/*                                                                                                                                   */
/*************************************************************************************************************************************/
#include  INCLUDES_MINI

#include  xrq/Hspherik.12.I"
#include  xrq/hydrogene.24.I"

/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        P A R A M E T R E S  :                                                                                                     */
/*                                                                                                                                   */
/*************************************************************************************************************************************/
#define   GENERER_n                                                                                                                     \
                    VRAI                                                                                                                \
                                        /* Cet indicateur indique si l'on genere 'n' ('VRAI') ou pas ('FAUX').                       */
#define   GENERER_m                                                                                                                     \
                    FAUX                                                                                                                \
                                        /* Cet indicateur indique si l'on genere 'm' ('VRAI') ou pas ('FAUX').                       */
#define   GENERER_l                                                                                                                     \
                    FAUX                                                                                                                \
                                        /* Cet indicateur indique si l'on genere 'l' ('VRAI') ou pas ('FAUX').                       */

#define   ORDRE_n_DE_DEPART                                                                                                             \
                    ORDRE_n_01
#define   ORDRE_n_D_ARRIVEE                                                                                                             \
                    ORDRE_n_01
                                        /* Definition des bornes implicites du nombre 'n'.                                           */

#define   ORDRE_m_DE_DEPART                                                                                                             \
                    ORDRE_m_00
#define   ORDRE_m_D_ARRIVEE                                                                                                             \
                    ORDRE_m_00
                                        /* Definition des bornes implicites du nombre 'm'.                                           */

#define   ORDRE_l_DE_DEPART                                                                                                             \
                    ORDRE_l_00
#define   ORDRE_l_D_ARRIVEE                                                                                                             \
                    ORDRE_l_00
                                        /* Definition des bornes implicites du nombre 'l'.                                           */

/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        M A C R O S   U T I L E S  :                                                                                               */
/*                                                                                                                                   */
/*************************************************************************************************************************************/
#define   FAUX_ORDRE                                                                                                                    \
                    PRED(MIN3(ORDRE_n_01                                                                                                \
                             ,ORDRE_m_00                                                                                                \
                             ,ORDRE_l_00                                                                                                \
                              )                                                                                                         \
                         )                                                                                                              \
                                        /* Faux ordre destine a indiquer un etat invalide...                                         */

#define   PRINT_ORDRE(ordre,generer_l_ordre)                                                                                            \
                    Bblock                                                                                                              \
                    Test(IL_FAUT(generer_l_ordre))                                                                                      \
                         Bblock                                                                                                         \
                         CAL2(Prin1("%d\n",ordre));                                                                                     \
                         Eblock                                                                                                         \
                    ATes                                                                                                                \
                         Bblock                                                                                                         \
                         Eblock                                                                                                         \
                    ETes                                                                                                                \
                    Eblock                                                                                                              \
                                        /* Edition d'un ordre quelconque...                                                          */

/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        G E N E R A T I O N   D ' U N   E N S E M B L E   D E   N O M B R E S   Q U A N T I Q U E S   ( n , m , l )  :             */
/*                                                                                                                                   */
/*************************************************************************************************************************************/
BCommande(nombre_d_arguments,arguments)
/*-----------------------------------------------------------------------------------------------------------------------------------*/
     Bblock
     DEFV(Logical,INIT(generer_n,GENERER_n));
                                        /* Cet indicateur indique si l'on genere 'n' ('VRAI') ou pas ('FAUX').                       */
     DEFV(Int,INIT(ordre_n,UNDEF));
     DEFV(Int,INIT(ordre_n_de_depart,ORDRE_n_DE_DEPART));
     DEFV(Int,INIT(ordre_n_d_arrivee,ORDRE_n_D_ARRIVEE));
                                        /* Definition de l'ordre 'n'.                                                                */
     DEFV(Logical,INIT(generer_m,GENERER_m));
                                        /* Cet indicateur indique si l'on genere 'm' ('VRAI') ou pas ('FAUX').                       */
     DEFV(Int,INIT(ordre_m,UNDEF));
     DEFV(Int,INIT(ordre_m_de_depart,ORDRE_m_DE_DEPART));
     DEFV(Int,INIT(ordre_m_d_arrivee,ORDRE_m_D_ARRIVEE));
                                        /* Definition de l'ordre 'm'.                                                                */
     DEFV(Logical,INIT(generer_l,GENERER_l));
                                        /* Cet indicateur indique si l'on genere 'l' ('VRAI') ou pas ('FAUX').                       */
     DEFV(Int,INIT(ordre_l,UNDEF));
     DEFV(Int,INIT(ordre_l_de_depart,ORDRE_l_DE_DEPART));
     DEFV(Int,INIT(ordre_l_d_arrivee,ORDRE_l_D_ARRIVEE));
                                        /* Definition de l'ordre 'l'.                                                                */
     /*..............................................................................................................................*/
     GET_ARGUMENTS_(nombre_d_arguments
                   ,BLOC(GET_ARGUMENT_L("n=",generer_n);
                         GET_ARGUMENT_I("nD=",ordre_n_de_depart);
                         GET_ARGUMENT_I("nA=",ordre_n_d_arrivee);

                         GET_ARGUMENT_L("m=",generer_m);
                         GET_ARGUMENT_I("mD=",ordre_m_de_depart);
                         GET_ARGUMENT_I("mA=",ordre_m_d_arrivee);

                         GET_ARGUMENT_L("l=",generer_l);
                         GET_ARGUMENT_I("lD=",ordre_l_de_depart);
                         GET_ARGUMENT_I("lA=",ordre_l_d_arrivee);
                         )
                    );

     DoQu(ordre_n,ordre_n_de_depart,ordre_n_d_arrivee,I)
          Bblock
          DoQu(ordre_m,ordre_m_de_depart,ordre_m_d_arrivee,I)
               Bblock
               DoQu(ordre_l,ordre_l_de_depart,ordre_l_d_arrivee,I)
                    Bblock
                    Test(IFET(IFLT(ordre_l,ordre_n)
                             ,IFLE(ordre_m,ordre_l)
                              )
                         )
                         Bblock
                         VALIDATION_DES_ORDRES_lmn;
                                        /* Validation des demandes...                                                                */

                         PRINT_ORDRE(ordre_n,generer_n);
                         PRINT_ORDRE(ordre_m,generer_m);
                         PRINT_ORDRE(ordre_l,generer_l);
                         Eblock
                    ATes
                         Bblock
                         PRINT_ORDRE(FAUX_ORDRE,generer_n);
                         PRINT_ORDRE(FAUX_ORDRE,generer_m);
                         PRINT_ORDRE(FAUX_ORDRE,generer_l);
                         Eblock
                    ETes
                    Eblock
               EDoQ
               Eblock
          EDoQ
          Eblock
     EDoQ

     RETU_Commande;
     Eblock
ECommande