/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        T E S T   D E   L A   F O N C T I O N   ' HORNER_4_01(...) '  :                                                            */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*        Author of '$xtc/HORNER_4_01$c' :                                                                                           */
/*                                                                                                                                   */
/*                    Jean-Francois Colonna (LACTAMME, 20181123115528).                                                              */
/*                                                                                                                                   */
/*************************************************************************************************************************************/

#include  "INCLUDES.01.I"

#define   P3(V1,V3)                     ((((a1111*V1)+a1110)*V3)+(a1101*V1)+a1100)
#define   P2(V1,V3)                     ((((a1011*V1)+a1010)*V3)+(a1001*V1)+a1000)
#define   P1(V1,V3)                     ((((a0111*V1)+a0110)*V3)+(a0101*V1)+a0100)
#define   P0(V1,V3)                     ((((a0011*V1)+a0010)*V3)+(a0001*V1)+a0000)

#define   HORNER_4_01(V1,V2,V3,V4)      (((((P3(V1,V3)*V2)+P2(V1,V3))*V4)+P1(V1,V3))*V2)+P0(V1,V3)

#define   DIVISIBLE(valeur,diviseur,nom)                                                                                                \
          {                                                                                                                             \
          long int  ivaleur=valeur;                                                                                                     \
          long int  idiviseur=diviseur;                                                                                                 \
                                                                                                                                        \
          if        ((ivaleur % idiviseur) == 0)                                                                                        \
                    {                                                                                                                   \
                                                                                                                                        \
                    if        (OnATrouveUnFacteur == VRAI)                                                                              \
                              {                                                                                                         \
                              printf("x");                                                                                              \
                              }                                                                                                         \
                    else                                                                                                                \
                              {                                                                                                         \
                              printf(" = {");                                                                                           \
                              }                                                                                                         \
                                                                                                                                        \
                    printf("%s",nom);                                                                                                   \
                                        /* Ce sont ces sorties qui ont permis l'enrichissement des 'GET_ARGUMENT_F(...)'s de         */ \
                                        /* 'v $ximcf/common$DEF sR_I2xR2xI1xR1' le 20181215103844, en les convertissant en fichiers  */ \
                                        /* de type '$sed' :                                                                          */ \
                                        /*                                                                                           */ \
                                        /*                  :1,$s/\("..\)\(a\)\(1111\)\(=\)/\1\2\3\4"\1_I2xR2xI1xR1=/                */ \
                                        /*                  :1,$s/\("..\)\(a\)\(1110\)\(=\)/\1\2\3\4"\1_I2xR2xI1=/                   */ \
                                        /*                  :1,$s/\("..\)\(a\)\(1101\)\(=\)/\1\2\3\4"\1_I2xI1xR1=/                   */ \
                                        /*                  :1,$s/\("..\)\(a\)\(1100\)\(=\)/\1\2\3\4"\1_I2xI1=/                      */ \
                                        /*                  :1,$s/\("..\)\(a\)\(1011\)\(=\)/\1\2\3\4"\1_I2xR2xR1=/                   */ \
                                        /*                  :1,$s/\("..\)\(a\)\(1010\)\(=\)/\1\2\3\4"\1_I2xR2=/                      */ \
                                        /*                  :1,$s/\("..\)\(a\)\(1001\)\(=\)/\1\2\3\4"\1_I2xR1=/                      */ \
                                        /*                  :1,$s/\("..\)\(a\)\(1000\)\(=\)/\1\2\3\4"\1_I2=/                         */ \
                                        /*                  :1,$s/\("..\)\(a\)\(0111\)\(=\)/\1\2\3\4"\1_R2xI1xR1=/                   */ \
                                        /*                  :1,$s/\("..\)\(a\)\(0110\)\(=\)/\1\2\3\4"\1_R2xI1=/                      */ \
                                        /*                  :1,$s/\("..\)\(a\)\(0101\)\(=\)/\1\2\3\4"\1_I1xR1=/                      */ \
                                        /*                  :1,$s/\("..\)\(a\)\(0100\)\(=\)/\1\2\3\4"\1_I1=/                         */ \
                                        /*                  :1,$s/\("..\)\(a\)\(0011\)\(=\)/\1\2\3\4"\1_R2xR1=/                      */ \
                                        /*                  :1,$s/\("..\)\(a\)\(0010\)\(=\)/\1\2\3\4"\1_R2=/                         */ \
                                        /*                  :1,$s/\("..\)\(a\)\(0001\)\(=\)/\1\2\3\4"\1_R1=/                         */ \
                                        /*                  :1,$s/\("..\)\(a\)\(0000\)\(=\)/\1\2\3\4"\1_=/                           */ \
                                        /*                                                                                           */ \
                                        /* Il en fut de meme pour 'v $xiirc/$Fnota' le 20181215104936 :                              */ \
                                        /*                                                                                           */ \
                                        /*                  :1,$s/\(..\)a1111=/\1_I2xR2xI1xR1=/                                      */ \
                                        /*                  :1,$s/\(..\)a1110=/\1_I2xR2xI1=/                                         */ \
                                        /*                  :1,$s/\(..\)a1101=/\1_I2xI1xR1=/                                         */ \
                                        /*                  :1,$s/\(..\)a1100=/\1_I2xI1=/                                            */ \
                                        /*                  :1,$s/\(..\)a1011=/\1_I2xR2xR1=/                                         */ \
                                        /*                  :1,$s/\(..\)a1010=/\1_I2xR2=/                                            */ \
                                        /*                  :1,$s/\(..\)a1001=/\1_I2xR1=/                                            */ \
                                        /*                  :1,$s/\(..\)a1000=/\1_I2=/                                               */ \
                                        /*                  :1,$s/\(..\)a0111=/\1_R2xI1xR1=/                                         */ \
                                        /*                  :1,$s/\(..\)a0110=/\1_R2xI1=/                                            */ \
                                        /*                  :1,$s/\(..\)a0101=/\1_I1xR1=/                                            */ \
                                        /*                  :1,$s/\(..\)a0100=/\1_I1=/                                               */ \
                                        /*                  :1,$s/\(..\)a0011=/\1_R2xR1=/                                            */ \
                                        /*                  :1,$s/\(..\)a0010=/\1_R2=/                                               */ \
                                        /*                  :1,$s/\(..\)a0001=/\1_R1=/                                               */ \
                                        /*                  :1,$s/\(..\)a0000=/\1_=/                                                 */ \
                                        /*                                                                                           */ \
                                                                                                                                        \
                    OnATrouveUnFacteur=VRAI;                                                                                            \
                    }                                                                                                                   \
          else                                                                                                                          \
                    {                                                                                                                   \
                    }                                                                                                                   \
          }

#define   CALCUL(legende,initialisation,decomposer)                                                                                     \
          {                                                                                                                             \
          double    polynome;                                                                                                           \
                                                                                                                                        \
          a1111=0;                                                                                                                      \
          a1110=0;                                                                                                                      \
          a1101=0;                                                                                                                      \
          a1100=0;                                                                                                                      \
          a1011=0;                                                                                                                      \
          a1010=0;                                                                                                                      \
          a1001=0;                                                                                                                      \
          a1000=0;                                                                                                                      \
          a0111=0;                                                                                                                      \
          a0110=0;                                                                                                                      \
          a0101=0;                                                                                                                      \
          a0100=0;                                                                                                                      \
          a0011=0;                                                                                                                      \
          a0010=0;                                                                                                                      \
          a0001=0;                                                                                                                      \
          a0000=0;                                                                                                                      \
                                                                                                                                        \
          initialisation;                                                                                                               \
                                                                                                                                        \
          polynome=HORNER_4_01(R1,I1,R2,I2);                                                                                            \
                                                                                                                                        \
          printf("HORNER_4_01[%s] = %+g",legende,polynome);                                                                             \
                                                                                                                                        \
          if        (decomposer == VRAI)                                                                                                \
                    {                                                                                                                   \
                    int       OnATrouveUnFacteur=FAUX;                                                                                  \
                                                                                                                                        \
                    DIVISIBLE(polynome,I2,"I2");                                                                                        \
                    DIVISIBLE(polynome,R2,"R2");                                                                                        \
                    DIVISIBLE(polynome,I1,"I1");                                                                                        \
                    DIVISIBLE(polynome,R1,"R1");                                                                                        \
                                        /* On notera qu'on utilise l'ordre {I2,R2,I1,R1} qui correspond a l'ordre (de gauche a       */ \
                                        /* droite) des indices des seize coefficients 'a'...                                         */ \
                                                                                                                                        \
                    if        (OnATrouveUnFacteur == VRAI)                                                                              \
                              {                                                                                                         \
                              printf("}");                                                                                              \
                              }                                                                                                         \
                    else                                                                                                                \
                              {                                                                                                         \
                              }                                                                                                         \
                    }                                                                                                                   \
          else                                                                                                                          \
                    {                                                                                                                   \
                    }                                                                                                                   \
                                                                                                                                        \
          printf("\n");                                                                                                                 \
          }

main()
          {
          double    a1111,a1110,a1101,a1100;
                                        /* Definition du premier polynome.                                                           */
          double    a1011,a1010,a1001,a1000;
                                        /* Definition du second polynome.                                                            */
          double    a0111,a0110,a0101,a0100;
                                        /* Definition du troisieme polynome.                                                         */
          double    a0011,a0010,a0001,a0000;
                                        /* Definition du quatrieme polynome.                                                         */

          double    R1=2,R2=30,I1=4,I2=50;
                                        /* Qautre valeurs arbitraires permettant de valider facilement les calculs qui vont          */
                                        /* etre faits ci-apres...                                                                    */

          CALCUL("R1+R2",a0001=+1;a0010=+1;,FAUX);
                                        /* Definition de la partie Reelle de 'FgCsomme(...)' :                                       */
                                        /*                                                                                           */
                                        /*                  R1+R2                                             -->  +32.0000          */
                                        /*                                                                                           */

          CALCUL("I1+I2",a0100=+1;a1000=+1;,FAUX);
                                        /* Definition de la partie Imaginaire de 'FgCsomme(...)' :                                   */
                                        /*                                                                                           */
                                        /*                  I1+I2                                             -->  +54.0000          */
                                        /*                                                                                           */

          CALCUL("(R1.R2) - (I1.I2)",a0011=+1;a1100=-1;,FAUX);
                                        /* Definition de la partie Reelle de 'FgCproduit(...)' :                                     */
                                        /*                                                                                           */
                                        /*                  (R1.R2) - (I1.I2)                                 -->  -140.000          */
                                        /*                                                                                           */

          CALCUL("(R1.I2) + (R2.I1)",a1001=+1;a0110=+1;,FAUX);
                                        /* Definition de la partie Imaginaire de 'FgCproduit(...)' :                                 */
                                        /*                                                                                           */
                                        /*                  (R1.I2) + (R2.I1)                                 -->  +220.000          */
                                        /*                                                                                           */

          CALCUL("R1+R2 + alpha.(R1.I1)",a0001=+1;a0010=+1;a0101=0.0001;,FAUX);
                                        /* Definition de la partie Reelle "folklorique" (alpha=a0101=0.0001) de 'FgCsomme(...)' :    */
                                        /*                                                                                           */
                                        /*                  R1+R2 + alpha.(R1.I1)                             -->  +32.0008          */
                                        /*                                                                                           */
                                        /* (utilise pour 'v ''$xiMl/JULK.7n.21$ANGLAIS.$m4.$I').                                     */

          CALCUL("I1+I2 + beta.(R2.I1)",a0100=+1;a1000=+1;a0110=0.0001,FAUX);
                                        /* Definition de la partie Imaginaire "folklorique" (beta=a0110=0.0001) de 'FgCsomme(...)' : */
                                        /*                                                                                           */
                                        /*                  I1+I2 + beta.(R2.I1)                              -->  +54.0120          */
                                        /*                                                                                           */
                                        /* (utilise pour 'v ''$xiMl/JULK.7n.21$ANGLAIS.$m4.$I').                                     */

          printf("\n");

          R1=3;
          I1=5;
          R2=7;
          I2=11;
                                        /* On notera que {R1,I1,R2,I2} sont quatre nombres premiers differents, ce qui permet        */
                                        /* de savoir ensuite (par factorisation du polynome) de savoir quel produit a ete calcule    */
                                        /* ci-apres...                                                                               */

          CALCUL("a1111",a1111=1;,VRAI);
          CALCUL("a1110",a1110=1;,VRAI);
          CALCUL("a1101",a1101=1;,VRAI);
          CALCUL("a1100",a1100=1;,VRAI);
          CALCUL("a1011",a1011=1;,VRAI);
          CALCUL("a1010",a1010=1;,VRAI);
          CALCUL("a1001",a1001=1;,VRAI);
          CALCUL("a1000",a1000=1;,VRAI);
          CALCUL("a0111",a0111=1;,VRAI);
          CALCUL("a0110",a0110=1;,VRAI);
          CALCUL("a0101",a0101=1;,VRAI);
          CALCUL("a0100",a0100=1;,VRAI);
          CALCUL("a0011",a0011=1;,VRAI);
          CALCUL("a0010",a0010=1;,VRAI);
          CALCUL("a0001",a0001=1;,VRAI);
          CALCUL("a0000",a0000=1;,VRAI);
          }



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