```/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        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);
}
}
}
}
}
```