/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        C A L C U L   D E S   N O M B R E S   P R E M I E R S   " C O M P L E X E S "  :                                           */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*        Author of '$xtc/PremiersComplexes.01$c' :                                                                                  */
/*                                                                                                                                   */
/*                    Jean-Francois COLONNA (LACTAMME, 20250303135743).                                                              */
/*                                                                                                                                   */
/*************************************************************************************************************************************/

#include  "INCLUDES.01.I"

#define   PRECIS    double
#include  "NombresComplexes.01.I"

#define   DIMENSION                                                                                                                     \
                    7

#define   XC01                                                                                                                          \
                    2
#define   XC02                                                                                                                          \
                    0
#define   YC0                                                                                                                           \
                    0

#define   dimX      DIMENSION
#define   Xmin      0
#define   Xmax      (Xmin + (dimX-1))
                                        /* Definition des abscisses.                                                                 */
#define   dimY      DIMENSION
#define   Ymin      0
#define   Ymax      (Ymin + (dimY-1))
                                        /* Definition des ordonnees.                                                                 */

#define   IMAGE(x,y)                                                                                                                    \
                    (*(image + (((y-Ymin)*dimX) + (x-Xmin))))                                                                           \
                                        /* Acces a un point de l'image.                                                              */

#define   store(n,x,y)                                                                                                                  \
                    {                                                                                                                   \
                    IMAGE(x,y) = n;                                                                                                     \
                    }                                                                                                                   \
                                        /* Rangement d'un point valide d'une image.                                                  */

int       tester_la_factorisation=FAUX;

int       editer_1=FAUX;
int       editer_2=FAUX;
int       editer_3=FAUX;
int       editer_4=VRAI;
int       il_faut_editer=VRAI;
#define   EDITION__(editer,print)                                                                                                       \
                    {                                                                                                                   \
                    if        ((editer == VRAI) && (il_faut_editer == VRAI))                                                            \
                              {                                                                                                         \
                              print;                                                                                                    \
                              }                                                                                                         \
                    else                                                                                                                \
                              {                                                                                                         \
                              }                                                                                                         \
                    }                                                                                                                   \
                                        /* Edition d'un message...                                                                   */

main()
          {
          complexe  ListePremiersComplexes[dimX*dimY];
          int       index_rangement=0;
          int       nc;
          int       Xcourant,Ycourant;

          int                 x,y;
          unsigned  char      *image;
          image=malloc(dimY*dimX);
                                        /* Definition de l'image a generer...                                                        */

          for       (y=Ymin ; y<=Ymax ; y++)
                    {
                    for       (x=Xmin ; x<=Xmax ; x++)
                              {
                              store(NOIR,x,y);
                              }
                    }

          for       (nc=XC01 ; nc < DIMENSION ; nc++)
                    {
                    int       iterer=VRAI;

                    Xcourant=nc;
                    Ycourant=YC0;

                    while     (iterer == VRAI)
                              {
                              int       index;
                              int       NombreDiviseurs=0;
                              complexe  Z_ATester;

                              Cinit(Z_ATester,Xcourant,Ycourant);

                              for       (index=0 ; index < index_rangement ; index++)
                                        {
                                        complexe  Z_Diviseur;
                                        complexe  Z_Quotient;

                                        Cegal(Z_Diviseur,ListePremiersComplexes[index]);

                                        if        (    (Reelle(Z_Diviseur) != Reelle(Z_ATester))
                                                  &&   (Imaginaire(Z_Diviseur) != Imaginaire(Z_ATester))
                                                   )
                                                  {
                                                  Cquotient(Z_Quotient,Z_ATester,Z_Diviseur);

                                                  EDITION__(editer_1
                                                           ,printf("(%f,%f)/(%f,%f)=(%f,%f)\n"
                                                                  ,Reelle(Z_ATester),Imaginaire(Z_ATester)
                                                                  ,Reelle(Z_Diviseur),Imaginaire(Z_Diviseur)
                                                                  ,Reelle(Z_Quotient),Imaginaire(Z_Quotient)
                                                                   );
                                                            );

                                                  if        (    (Reelle(Z_Quotient) == (int)Reelle(Z_Quotient))
                                                            &&   (Imaginaire(Z_Quotient) == (int)Imaginaire(Z_Quotient))
                                                             )
                                                            {
                                                            NombreDiviseurs++;

                                                            EDITION__(editer_2
                                                                     ,printf("     (%d,%d) divise (%d,%d)\n"
                                                                            ,(int)Reelle(Z_Diviseur),(int)Imaginaire(Z_Diviseur)
                                                                            ,(int)Reelle(Z_ATester),(int)Imaginaire(Z_ATester)
                                                                   );
                                                                      );
                                                            }
                                                  else
                                                            {
                                                            EDITION__(editer_3
                                                                     ,printf("     (%d,%d) ne divise pas (%d,%d)\n"
                                                                            ,(int)Reelle(Z_Diviseur),(int)Imaginaire(Z_Diviseur)
                                                                            ,(int)Reelle(Z_ATester),(int)Imaginaire(Z_ATester)
                                                                             );
                                                                      );
                                                            }
                                                  }
                                        else
                                                  {
                                                  }
                                        }

                              if        (NombreDiviseurs == 0)
                                        {
                                        if        (    (Imaginaire(Z_ATester) == 0)
                                                  &&   (    (Reelle(Z_ATester) == 0)
                                                       ||   (Reelle(Z_ATester) == 1)
                                                        )
                                                   )
                                                  {
                                        /* L'origine (0,0) et l'unite (1,0) sont eliminees a priori...                               */
                                                  }
                                        else
                                                  {
                                                  Cegal(ListePremiersComplexes[index_rangement],Z_ATester);
                                                  index_rangement++;
                                                  }
                                        }
                              else
                                        {
                                        }

                              if        (Ycourant < nc)
                                        {
                                        Ycourant++;
                                        }
                              else
                                        {
                                        if        (Xcourant > XC02)
                                                  {
                                                  Xcourant--;
                                                  }
                                        else
                                                  {
                                                  iterer=FAUX;
                                                  }
                                        }
                              }
                    }

          if        (index_rangement > 0)
                    {
                    int       index;
                    int       diagonale2=(dimX*dimX)+(dimY*dimY);

                    for       (index=0 ; index<index_rangement ; index++)
                              {
                              int       X=(int)Reelle(ListePremiersComplexes[index]);
                              int       Y=(int)Imaginaire(ListePremiersComplexes[index]);
                              double    alpha=0.9;

                              store((int)((alpha*BLANC*+(Cmodule2(ListePremiersComplexes[index])/diagonale2))+((1-alpha)*BLANC)),X,Y);

                              EDITION__(editer_4
                                       ,printf("Le nombre (%d,%d) est 'complexe entier premier'.\n",X,Y);
                                        );
                                        /* On notera :                                                                               */
                                        /*                                                                                           */
                                        /* 1-Sur l'axe Reel, tous les nombres entiers ne sont pas "complexes premiers" : c'est ainsi */
                                        /* le cas de 5, (5,0) etant divisible par (2,1)...                                           */
                                        /*                                                                                           */
                                        /* 1-Sur l'axe Imaginaire, il n'y a pas de "complexes premiers". Ainsi, par exemple,         */
                                        /* (4,1) divise (0,17)...                                                                    */
                                        /*                                                                                           */
                              }
                    }
          else
                    {
                    }

          if        (il_faut_editer == FAUX)
                    {
                    write(1,image,dimX*dimY);
                                        /* Sortie de l'image...                                                                      */
                    }
          else
                    {
                    if        (tester_la_factorisation == VRAI)
                              {
                              for       (Xcourant=XC02 ; Xcourant < DIMENSION ; Xcourant++)
                                        {
                                        for       (Ycourant=YC0 ; Ycourant < DIMENSION ; Ycourant++)
                                                  {
                                                  complexe  Z_ATester;
                                                  int       index;

                                                  Cinit(Z_ATester,Xcourant,Ycourant);

                                                  for       (index=0 ; index<index_rangement ; index++)
                                                            {
                                                            complexe  Z_Diviseur;
                                                            complexe  Z_Quotient;

                                                            Cegal(Z_Diviseur,ListePremiersComplexes[index]);
                                                            Cquotient(Z_Quotient,Z_ATester,Z_Diviseur);

                                                            EDITION__(VRAI
                                                                     ,printf("(%f,%f)/(%f,%f)=(%f,%f)\n"
                                                                            ,Reelle(Z_ATester),Imaginaire(Z_ATester)
                                                                            ,Reelle(Z_Diviseur),Imaginaire(Z_Diviseur)
                                                                            ,Reelle(Z_Quotient),Imaginaire(Z_Quotient)
                                                                             );
                                                                      );
                                        /* Et on voit ainsi que, malheureusement, ces nombres "complexes entiers premiers" ne        */
                                        /* permettent la factorisation comme c'est le cas avec les nombres entiers premiers...       */
                                                            }
                                                  }
                                        }
                              }
                    else
                              {
                              }
                    }
          }