#######################################################################################################################################
#                                                                                                                                     #
#         G E N E R A T I O N   D ' U N E   V A R I E T E   T R I M E N S I O N N E L L E   " M A I L L A G E "                       #
#         P A R   L A   M E T H O D E   D E S   P R O J E C T O R S  :                                                                #
#                                                                                                                                     #
#                                                                                                                                     #
#         Author of '$xiirs/.PROK.61.1.$U' :                                                                                          #
#                                                                                                                                     #
#                     Jean-Francois Colonna (LACTAMME, 20131010091138).                                                               #
#                                                                                                                                     #
#######################################################################################################################################

$Z                  SET       Premiere=1
$Z                  SET       Derniere=16

$c                  #include  <stdio.h>
$c
$c                  #define   N0        Premiere
$c                  #define   N         Derniere

$c                  #define   OGXY      (+1.0)
$c                  #define   MGXY      (+0.6)
$c                  #define   EGXY      (MGXY-(OGXY-MGXY))

$c                  #define   OGZ       (-0.1)
$c                  #define   EGZ       (+0.1)
$c
$c                  int       main()
$c                            {
$c                            int       n;
$c
$c                            for       (n=N0 ; n<=N ; n++)
$c                                      {
$c                                      double    GXY=((EGXY*(n-N0))+(OGXY*(N-n)))/(N-N0);
$c                                      double    GZ=((EGZ*(n-N0))+(OGZ*(N-n)))/(N-N0);
$c
$c                                      if        (n>N/2)
$c                                                {
$c                                                GXY=MGXY+(MGXY-GXY);
$c                                                }
$c                                      else
$c                                                {
$c                                                }
$c
$c                                      printf("$xci/gauss$X
$c                                                             standard=FAUX
$c                                                                                                                      $formatI  |
$c                                              $xci/normalise.01$X
$c                                                                                                                      $formatI  |
$c                                              $xci/complement$X
$c                                                             standard=FAUX
$c                                                                                                                      $formatI  |
$c                                              $xci/normalise.01$X
$c                                                             o=%f e=1
$c                                                             R=$xTV/GAUSS_XY
$c                                                                         $formatI\n"
$c                                            ,GXY
$c                                             );
$c
$c                                      printf("$xci/gauss$X
$c                                                             standard=FAUX
$c                                                                                                                      $formatI  |
$c                                              $xci/normalise.01$X
$c                                                                                                                      $formatI  |
$c                                              $xci/complement$X
$c                                                             standard=FAUX
$c                                                                                                                      $formatI  |
$c                                              $xci/normalise.01$X
$c                                                             o=0 e=%f
$c                                                             R=$xTV/GAUSS_Z
$c                                                                         $formatI\n"
$c                                            ,GZ
$c                                             );
$c
$c                                      printf("$xci/lineaire$X
$c                                                             standard=FAUX
$c                                                             amplificateur=1 translateur=0
$c                                                             A=1 B=0 C=0
$c                                                             TRANSLATION_OX=0 TRANSLATION_OY=0
$c                                                                                                                      $formatI  |
$c                                              $xci/normalise.01$X
$c                                                                                                                      $formatI  |
$c                                              $xci/multi_02.01$X
$c                                                             standard=FAUX
$c                                                             A1=$xTV/GAUSS_XY
$c                                                                                                                      $formatI  |
$c                                              $xci/scale$X
$c                                                             standard=FAUX
$c                                                             a=2 b=-1
$c                                                             R=$xTV/CHAMP$COORD_X.%04d
$c                                                                         $formatI\n"
$c                                            ,n
$c                                             );
$c                                      printf("$xci/lineaire$X
$c                                                             standard=FAUX
$c                                                             amplificateur=1 translateur=0
$c                                                             A=0 B=1 C=0
$c                                                             TRANSLATION_OX=0 TRANSLATION_OY=0
$c                                                                                                                      $formatI  |
$c                                              $xci/normalise.01$X
$c                                                                                                                      $formatI  |
$c                                              $xci/multi_02.01$X
$c                                                             standard=FAUX
$c                                                             A1=$xTV/GAUSS_XY
$c                                                                                                                      $formatI  |
$c                                              $xci/scale$X
$c                                                             standard=FAUX
$c                                                             a=2 b=-1
$c                                                             R=$xTV/CHAMP$COORD_Y.%04d
$c                                                                         $formatI\n"
$c                                            ,n
$c                                             );
$c                                      printf("$xci/init$X
$c                                                             standard=FAUX
$c                                                             valeur=%f
$c                                                                                                                      $formatI  |
$c                                              $xci/somme_02$X
$c                                                             standard=FAUX
$c                                                             A1=$xTV/GAUSS_Z
$c                                                             R=$xTV/CHAMP$COORD_Z.%04d
$c                                                                         $formatI\n"
$c                                            ,(((-1.0)*((double)(N-n)))+((+1.0)*((double)(n-N0))))/((double)(N-N0))
$c                                            ,n
$c                                             );
$c                                      }
$c                            }



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