/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        Q U E L Q U E S   D E F I N T I O N S   U T I L E S  :                                                                     */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*        Author of '$xtc/INCLUDES.01$I' :                                                                                           */
/*                                                                                                                                   */
/*                    Jean-Francois Colonna (LACTAMME, 20051108171308).                                                              */
/*                                                                                                                                   */
/*************************************************************************************************************************************/

#include  <stdlib.h>
                                        /* Introduit le 20130129101445...                                                            */
#include  <stdio.h>
#include  <string.h>
                                        /* Introduit le 20141208105602...                                                            */
#include  <math.h>

#include  <sys/types.h>
#include  <sys/stat.h>
#include  <unistd.h>
#include  <fcntl.h>
                                        /* Introduits le 20151227105222...                                                           */

#define   BIT                                                                                                                           \
                    1                                                                                                                   \
                                        /* Introduit le 20151202111119...                                                            */

#define   OK                                                                                                                            \
                    0
#define   NOK                                                                                                                           \
                    (OK+1)
                                        /* Introduit le 20130129100912...                                                            */

#define   FAUX                                                                                                                          \
                    (0 == 1)
#define   VRAI                                                                                                                          \
                    (1 == 1)
                                        /* Les definitions 'VRAI' et 'FAUX' furent introduites le 20080307101318 et "modernisees"    */
                                        /* le 20130128092957...                                                                      */

#define   PI                                                                                                                            \
                    3.141592653589793
#define   PI_SUR_2                                                                                                                      \
                    (PI/2)
#define   PI_SUR_3                                                                                                                      \
                    (PI/3)
#define   DEUX_PI                                                                                                                       \
                    (2*PI)

#define   COND(condition,valeur_si_vrai,valeur_si_faux)                                                                                 \
                    ((condition) ? (valeur_si_vrai) : (valeur_si_faux))

#define   IFOU(condition_1,condition_2)                                                                                                 \
                    ((condition_1) || (condition_2))
#define   IFET(condition_1,condition_2)                                                                                                 \
                    ((condition_1) && (condition_2))

#define   PARE(x)                                                                                                                       \
                    (x)                                                                                                                 \
                                        /* Introduit le 20101227094326...                                                            */

#define   SE13(x1,x2,x3)                                                                                                                \
                    (x1)
#define   SE23(x1,x2,x3)                                                                                                                \
                    (x2)
#define   SE33(x1,x2,x3)                                                                                                                \
                    (x3)
                                        /* Introduits le 20130128092957...                                                           */

#define   IFEQ(x,a)                                                                                                                     \
                    ((x) == (a))
                                        /* Introduit le 20120702135449...                                                            */
#define   IFNE(x,a)                                                                                                                     \
                    ((x) != (a))
#define   IFGE(x,a)                                                                                                                     \
                    ((x) >= (a))
#define   IZNE(x)                                                                                                                       \
                    IFNE(x,0)
#define   IZGE(x)                                                                                                                       \
                    IFGE(x,0)

#define   OUIN(a,b)                                                                                                                     \
                    ((a)|(b))
#define   OUEX(a,b)                                                                                                                     \
                    ((a)^(b))
#define   ETLO(a,b)                                                                                                                     \
                    ((a)&(b))
                                        /* Introduits le 20130514142719...                                                           */

#define   DECD(a,b)                                                                                                                     \
                    ((a)>>(b))
#define   DECG(a,b)                                                                                                                     \
                    ((a)<<(b))
                                        /* Introduits le 20130514143845...                                                           */

#define   ABSO(x)                                                                                                                       \
                    COND(((x)>0),NEUT(x),NEGA(x))
#define   NEUT(x)                                                                                                                       \
                    (x)
#define   NEGA(x)                                                                                                                       \
                    SOUS(0,x)

#define   MIN2(a,b)                                                                                                                     \
                    COND(((a)<=(b)),(a),(b))
#define   MAX2(a,b)                                                                                                                     \
                    COND(((a)>=(b)),(a),(b))

#define   ADD2(a,b)                                                                                                                     \
                    ((a)+(b))
#define   ADD3(a,b,c)                                                                                                                   \
                    ADD2(a,ADD2(b,c))
#define   ADD4(a,b,c,d)                                                                                                                 \
                    ADD2(a,ADD3(b,c,d))
#define   SOUS(a,b)                                                                                                                     \
                    ((a)-(b))
#define   bSOU(a,b)                                                                                                                     \
                    SOUS(a,b)                                                                                                           \
                                        /* Introduit le 20101227094326...                                                            */

#define   MUL2(a,b)                                                                                                                     \
                    ((a)*(b))

#define   GRO2(a)                                                                                                                       \
                    MUL2(2,a)
#define   GRO3(a)                                                                                                                       \
                    MUL2(3,a)
#define   GRO4(a)                                                                                                                       \
                    MUL2(4,a)
                                        /* Introduits le 20101231090947...                                                           */

#define   EXP2(x)                                                                                                                       \
                    MUL2(x,x)
#define   EXP3(x)                                                                                                                       \
                    MUL2(x,EXP2(x))
#define   EXP4(x)                                                                                                                       \
                    MUL2(x,EXP3(x))
#define   EXP5(x)                                                                                                                       \
                    MUL2(x,EXP4(x))
#define   EXP6(x)                                                                                                                       \
                    MUL2(x,EXP5(x))
#define   EXP7(x)                                                                                                                       \
                    MUL2(x,EXP6(x))
#define   EXP8(x)                                                                                                                       \
                    MUL2(x,EXP7(x))

#define   DIVI(a,b)                                                                                                                     \
                    ((a)/(b))
#define   REST(a,b)                                                                                                                     \
                    ((a)%(b))

#define   INVE(a)                                                                                                                       \
                    DIVI(1,a)
#define   MOIT(a)                                                                                                                       \
                    DIVI(a,2)
#define   AXPB(a,x,b)                                                                                                                   \
                    ADD2(MUL2(a,x),b)
#define   BARY(origine,extremite,lambda)                                                                                                \
                    ADD2(MUL2(SOUS(1,lambda),origine),MUL2(lambda,extremite))

#define   EST_PAIR(nombre)                                                                                                              \
                    (REST(nombre,2) == 0)

#define   HOMO(x,origine1,extremite1,origine2,extremite2)                                                                               \
                    ADD2(SCAL(SOUS(x,origine1),SOUS(extremite1,origine1),SOUS(extremite2,origine2)),origine2)
#define   SCAL(x,ancien_intervalle,nouvel_intervalle)                                                                                   \
                    SCAZ(x,ancien_intervalle,nouvel_intervalle,x)
#define   SCAZ(x,ancien_intervalle,nouvel_intervalle,exception)                                                                         \
                    MUL2(DIVI(FLOT(x),FLOT(ancien_intervalle)),FLOT(nouvel_intervalle))

#define   DET1(a11)                                                                                                                     \
                    NEUT(a11)
#define   DET2(a11,a12,a21,a22)                                                                                                         \
                    NEUT(ADD2(MUL2(NEUT(a11),DET1(a22))                                                                                 \
                             ,MUL2(NEGA(a12),DET1(a21))                                                                                 \
                              )                                                                                                         \
                         )
#define   DET3(a11,a12,a13,a21,a22,a23,a31,a32,a33)                                                                                     \
                    NEUT(ADD3(MUL2(NEUT(a11),DET2(a22,a23,a32,a33))                                                                     \
                             ,MUL2(NEGA(a12),DET2(a21,a23,a31,a33))                                                                     \
                             ,MUL2(NEUT(a13),DET2(a21,a22,a31,a32))                                                                     \
                              )                                                                                                         \
                         )
#define   DET4(a11,a12,a13,a14,a21,a22,a23,a24,a31,a32,a33,a34,a41,a42,a43,a44)                                                         \
                    NEUT(ADD4(MUL2(NEUT(a11),DET3(a22,a23,a24,a32,a33,a34,a42,a43,a44))                                                 \
                             ,MUL2(NEGA(a12),DET3(a21,a23,a24,a31,a33,a34,a41,a43,a44))                                                 \
                             ,MUL2(NEUT(a13),DET3(a21,a22,a24,a31,a32,a34,a41,a42,a44))                                                 \
                             ,MUL2(NEGA(a14),DET3(a21,a22,a23,a31,a32,a33,a41,a42,a43))                                                 \
                              )                                                                                                         \
                         )

#define   HORNER_1_02(x,a,b,c)                                                                                                          \
                    (((a)*(x)+(b))*(x)+(c))                                                                                             \
                                        /* Methode de Horner pour les polynomes a une variable (1) du deuxieme (2) degre             */ \
                                        /* (introduite le 20130415162125)...                                                         */
#define   HORNER_1_03(x,a,b,c,d)                                                                                                        \
                    ((((a)*(x)+(b))*(x)+(c))*(x)+(d))                                                                                   \
                                        /* Methode de Horner pour les polynomes a une variable (1) du troisieme (3) degre            */ \
                                        /* (introduite le 20130415162125)...                                                         */

extern    int                 atoi();
extern    long      int       atol();
extern    char                *getenv();

#define   gGet(valeur_de_la_variable,nom_de_la_variable,valeur_par_defaut)                                                              \
                    {                                                                                                                   \
                    valeur_de_la_variable = COND((getenv(nom_de_la_variable) == 0),valeur_par_defaut,atoi(getenv(nom_de_la_variable))); \
                    }                                                                                                                   \
                                        /* Procedure Generale de recuperation de variables d'environnement entieres courtes          */ \
                                        /* (introduite le 20130205133824).                                                           */
#define   Get(valeur_de_la_variable,nom_de_la_variable)                                                                                 \
                    {                                                                                                                   \
                    valeur_de_la_variable = atoi(getenv(nom_de_la_variable));                                                           \
                    }                                                                                                                   \
                                        /* Procedure de recuperation de variables d'environnement entiere courte.                    */
#define   gGetl(valeur_de_la_variable,nom_de_la_variable,valeur_par_defaut)                                                             \
                    {                                                                                                                   \
                    valeur_de_la_variable = COND((getenv(nom_de_la_variable) == 0),valeur_par_defaut,atol(getenv(nom_de_la_variable))); \
                    }                                                                                                                   \
                                        /* Procedure Generale de recuperation de variables d'environnement entieres longues          */ \
                                        /* (introduite le 20130314113433).                                                           */
#define   Getl(valeur_de_la_variable,nom_de_la_variable)                                                                                \
                    {                                                                                                                   \
                    valeur_de_la_variable = atol(getenv(nom_de_la_variable));                                                           \
                    }                                                                                                                   \
                                        /* Procedure de recuperation de variables d'environnement entieres longues (introduite le    */ \
                                        /* 20130314113433).                                                                          */

#define   INDEX0                                                                                                                        \
                    0                                                                                                                   \
                                        /* Introduit le 20130128155254...                                                            */
#define   IndexVersNombre(index)                                                                                                        \
                    (((index)-INDEX0)+1)
#define   NombreVersIndex(nombre)                                                                                                       \
                    (INDEX0+((nombre)-1))
                                        /* Introduit le 20130204182939...                                                            */

#define   NBITOC                                                                                                                        \
                    8                                                                                                                   \
                                        /* Introduit le 20130509210504...                                                            */
#define   NOCMO                                                                                                                         \
                    4                                                                                                                   \
                                        /* Introduit le 20151203144126...                                                            */
#define   NBITMO                                                                                                                        \
                    (NOCMO*NBITOC)                                                                                                      \
                                        /* Introduit le 20151203144126...                                                            */
#define   MASKO                                                                                                                         \
                    255                                                                                                                 \
                                        /* Introduit le 20141214175319...                                                            */

#define   NOIR                                                                                                                          \
                    0
#define   BLANC                                                                                                                         \
                    MASKO
#define   COULEURS                                                                                                                      \
                    ADD2(SOUS(BLANC,NOIR),1)



Copyright (c) Jean-François Colonna, 2019.
Copyright (c) CMAP (Centre de Mathématiques APpliquées) UMR CNRS 7641 / Ecole Polytechnique, 2019.