/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        C A L C U L   D E   T R I P L E T S   D E   N O M B R E S   P Y T H A G O R I C I E N S                                    */
/*        F A I T S   U N I Q U E M E N T   D E   N O M B R E S   P R E M I E R S  :                                                 */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*        Author of '$xtc/Pythagore.11$c' :                                                                                          */
/*                                                                                                                                   */
/*                    Jean-Francois Colonna (LACTAMME, 20130304143239).                                                              */
/*                                                                                                                                   */
/*************************************************************************************************************************************/

#include  <stdio.h>

#define   N         9000                                                                                                                \
                                        /* Definition du maximum des trois nombres {a,b,c}.                                          */

#define   STORE(n)                                                                                                                      \
                    {                                                                                                                   \
                    ListeDesNombrePremiers[IndexDesNombrePremiers]=n;                                                                   \
                    IndexDesNombrePremiers++;                                                                                           \
                    }

main()
          {
          int       IndexDesNombrePremiers=0;
          int       ListeDesNombrePremiers[N];
          int       NombreEntierCourant;
          int       index;

          int       a,b,c;
                                        /* Trois nombres entiers courants...                                                         */

          STORE(2);
          NombreEntierCourant=ListeDesNombrePremiers[IndexDesNombrePremiers-1]+1;

          while     (IndexDesNombrePremiers < N)
                    {
                    int       EstPremier=0;

                    for       (index=0 ; index<=IndexDesNombrePremiers-1 ; index++)
                              {
                              if        ((NombreEntierCourant % ListeDesNombrePremiers[index]) == 0)
                                        {
                                        EstPremier=1;
                                        }
                              else
                                        {
                                        }
                              }

                    if        (EstPremier == 0)
                              {
                              STORE(NombreEntierCourant);
                              }
                    else
                              {
                              }

                    NombreEntierCourant=NombreEntierCourant+2;
                    }
                                        /* En faisant ici :                                                                          */
                                        /*                                                                                           */
                                        /*                  for       (index=0 ; index<=IndexDesNombrePremiers-1 ; index++)          */
                                        /*                            {                                                              */
                                        /*                            ListeDesNombrePremiers[index]=index+1;                         */
                                        /*                            }                                                              */
                                        /*                                                                                           */
                                        /* on retombe sur 'v $xtc/Pythagore.01$c'...                                                 */

          for       (a=1 ; a<=N ; a++)
                    {
                    for       (b=a ; b<=N ; b++)
                                        /* En mettant "b=a" au lieu de "b=1", on elimine les solutions "commutees"...                */
                              {
                              for       (c=b ; c<=N ; c++)
                                        {
                                        int       pa=ListeDesNombrePremiers[a-1];
                                        int       pb=ListeDesNombrePremiers[b-1];
                                        int       pc=ListeDesNombrePremiers[c-1];
                                        /* En faisant ici :                                                                          */
                                        /*                                                                                           */
                                        /*                  pa=a;                                                                    */
                                        /*                  pb=b;                                                                    */
                                        /*                  pc=c;                                                                    */
                                        /*                                                                                           */
                                        /* on retombe sur 'v $xtc/Pythagore.01$c'...                                                 */

                                        if        (((pa*pa)+(pb*pb)) == (pc*pc))
                                                  {
                                                  printf("%d*%d + %d*%d = %d*%d\n",pa,pa,pb,pb,pc,pc);
                                                  }
                                        else
                                                  {
                                        /* Il semblerait qu'il n'y ait pas de solutions pour les 9000 premiers nombres premiers...   */
                                                  }
                                        }
                              }
                    }
          }