/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        R E C H E R C H E   D E   P O I N T S   R A T I O N N E L S   S U R   U N E   C O U R B E   E L L I P T I Q U E  :         */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*        Author of '$xtc/CourbesElliptiques.01$c' :                                                                                 */
/*                                                                                                                                   */
/*                    Jean-Francois Colonna (LACTAMME, 20211122110528).                                                              */
/*                                                                                                                                   */
/*************************************************************************************************************************************/

#include  "INCLUDES.01.I"

#include  "CourbesElliptiques.01.I"
                                        /* Definition du polynome :                                                                  */
                                        /*                                                                                           */
                                        /*                     3      2      1      0                                                */
                                        /*                  A.x  + B.x  + C.x  + D.x                                                 */
                                        /*                                                                                           */

#define   XnD                                                                                                                           \
                    (-10)
#define   XnA                                                                                                                           \
                    (+10)
#define   XdD                                                                                                                           \
                    (+1)
#define   XdA                                                                                                                           \
                    (+10)

#define   YnD                                                                                                                           \
                    (-10)
#define   YnA                                                                                                                           \
                    (+10)
#define   YdD                                                                                                                           \
                    (+1)
#define   YdA                                                                                                                           \
                    (+10)

#define   NOMBRE                                                                                                                        \
                    MAX2(((XnA-XnD+1)*(XdA-XdD+1)),((YnA-YnD+1)*(YdA-YdD+1)))

#define   factorisation(a,b)                                                                                                            \
                    {                                                                                                                   \
                    int       racine_carree=(int)sqrt((double)a);                                                                       \
                    int       diviseur_courant=2;                                                                                       \
                    int       nombre_de_facteurs=0;                                                                                     \
                                                                                                                                        \
                    while     (diviseur_courant <= racine_carree)                                                                       \
                              {                                                                                                         \
                              if        ((a%diviseur_courant) == 0)                                                                     \
                                        {                                                                                               \
                                        a = a/diviseur_courant;                                                                         \
                                        nombre_de_facteurs++;                                                                           \
                                        if        ((b%diviseur_courant) == 0)                                                           \
                                                  {                                                                                     \
                                                  b = b/diviseur_courant;                                                               \
                                                  pgcd_courant = pgcd_courant*diviseur_courant;                                         \
                                                  }                                                                                     \
                                        else                                                                                            \
                                                  {                                                                                     \
                                                  }                                                                                     \
                                        }                                                                                               \
                              else                                                                                                      \
                                        {                                                                                               \
                                        diviseur_courant++;                                                                             \
                                        }                                                                                               \
                              }                                                                                                         \
                                                                                                                                        \
                    if        (nombre_de_facteurs == 0)                                                                                 \
                                   {                                                                                                    \
                                   }                                                                                                    \
                    else                                                                                                                \
                                   {                                                                                                    \
                                   }                                                                                                    \
                    }

int       pgcd(x,y)
int       x,y;
          {
          int       Ax=ABSO(x);
          int       Ay=ABSO(y);

          int       Vx;
          int       Vy;

          int       pgcd_courant=1;

          Vx=Ax;
          Vy=Ay;

          factorisation(Ax,Ay);
          factorisation(Ay,Ax);

          return(pgcd_courant);
          }

#define   POLYNOME(yn,yd,xn,xd)                                                                                                         \
                    {                                                                                                                   \
                    int       pgcdx,xni,xdi;                                                                                            \
                    int       y2n,y2ni;                                                                                                 \
                    int       y2d,y2di;                                                                                                 \
                    int       pgcdy,yni,ydi;                                                                                            \
                    int       Pxni,Pxdi;                                                                                                \
                                        /* Le "i" en queue de certains noms signifie "Irreductible" (voir le 'PGCD'...).             */ \
                                                                                                                                        \
                    y2n=yn*yn;                                                                                                          \
                    y2d=yd*yd;                                                                                                          \
                                                                                                                                        \
                    pgcdx=pgcd(xn,xd);                                                                                                  \
                    pgcdy=pgcd(yn,yd);                                                                                                  \
                                                                                                                                        \
                    xni=xn/pgcdx;                                                                                                       \
                    xdi=xd/pgcdx;                                                                                                       \
                    yni=yn/pgcdy;                                                                                                       \
                    ydi=yd/pgcdy;                                                                                                       \
                    y2ni=y2n/(pgcdy*pgcdy);                                                                                             \
                    y2di=y2d/(pgcdy*pgcdy);                                                                                             \
                                                                                                                                        \
                    Pxni=(A*xni*xni*xni)+(B*xni*xni*xdi)+(C*xni*xdi*xdi)+(D*xdi*xdi*xdi);                                               \
                    Pxdi=xdi*xdi*xdi;                                                                                                   \
                                        /* Calcul du Numerateur et du Denominateur du Polynome avec la variable Irreductible (N/D).  */ \
                                                                                                                                        \
                    if        ((Pxni == y2ni) && (Pxdi == y2di))                                                                        \
                              {                                                                                                         \
                              int       index_courant=0;                                                                                \
                              int       DejaRencontre=FAUX;                                                                             \
                                                                                                                                        \
                              while     ((index_courant <= index_maximal) && (DejaRencontre == FAUX))                                   \
                                        {                                                                                               \
                                        if        (    (xni == Liste_xni[index_courant]) && (yni == Liste_yni[index_courant])           \
                                                  &&   (xdi == Liste_xdi[index_courant]) && (ydi == Liste_ydi[index_courant])           \
                                                   )                                                                                    \
                                                  {                                                                                     \
                                                  DejaRencontre=VRAI;                                                                   \
                                                  }                                                                                     \
                                        else                                                                                            \
                                                  {                                                                                     \
                                                  index_courant++;                                                                      \
                                                  }                                                                                     \
                                        }                                                                                               \
                                                                                                                                        \
                              if        (DejaRencontre == FAUX)                                                                         \
                                        {                                                                                               \
                                        if        (index_maximal < NOMBRE)                                                              \
                                                  {                                                                                     \
                                                  index_maximal++;                                                                      \
                                                  }                                                                                     \
                                        else                                                                                            \
                                                  {                                                                                     \
                                                  printf("Debordement des listes {x,y}\n");                                             \
                                                  }                                                                                     \
                                                                                                                                        \
                                        Liste_xni[index_maximal]=xni;                                                                   \
                                        Liste_xdi[index_maximal]=xdi;                                                                   \
                                        Liste_yni[index_maximal]=yni;                                                                   \
                                        Liste_ydi[index_maximal]=ydi;                                                                   \
                                                                                                                                        \
                                        printf("Point rationnel : x=%d/%d y=%d/%d     y^2=P(x)=%d/%d\n",xni,xdi,yni,ydi,Pxni,Pxdi);     \
                                        }                                                                                               \
                              else                                                                                                      \
                                        {                                                                                               \
                                        }                                                                                               \
                              }                                                                                                         \
                    else                                                                                                                \
                              {                                                                                                         \
                              }                                                                                                         \
                    }

void      main()
          {
          int       index_maximal=0;
          double    Liste_xni[NOMBRE];
          double    Liste_xdi[NOMBRE];
          double    Liste_yni[NOMBRE];
          double    Liste_ydi[NOMBRE];

          int       yn,yd,xn,xd;

          for       (xn=XnD ; xn<=XnA ; xn++)
                    {
                    for       (xd=XdD ; xd<=XdA ; xd++)
                              {
                              for       (yn=YnD ; yn<=YnA ; yn++)
                                        {
                                        for       (yd=YdD ; yd<=YdA ; yd++)
                                                  {
                                                  POLYNOME(yn,yd,xn,xd);
                                                  }
                                        }
                              }
                    }
          }



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