/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        T E S T   D E   L A   C O N J E C T U R E   D E   ' Gilbreath '   A V E C   U N E   S U I T E                              */
/*        D E   N O M B R E S   I M P A I R S   C R O I S S A N T S   A L A   P L A C E                                              */
/*        D E S   N O M B R E S   P R E M I E R S  :                                                                                 */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*        Author of '$xtc/Gilbreath.02$c' :                                                                                          */
/*                                                                                                                                   */
/*                    Jean-Francois COLONNA (LACTAMME, 20250816170518).                                                              */
/*                                                                                                                                   */
/*************************************************************************************************************************************/

#include  "INCLUDES.01.I"
                                        /* Quelques definitions : en particulier de 'VRAI' et 'FAUX', mais aussi de la procedure     */
                                        /* 'ABSO(...)' qui calcule la valeur absolue...                                              */

#define   I0        0
                                        /* Index du premier "nombre premier".                                                        */
#define   I1        30
                                        /* Index du "nombre premier" dit "catastrophique".                                           */
#define   I2        39
                                        /* Index du dernier "nombre premier".                                                        */
#define   N         ((I2-I0)+1)
                                        /* Nombre de "nombres premiers" generes...                                                   */

#define   INITIALISATION(valeur,index)                                                                                                  \
                    {                                                                                                                   \
                    tableau[index] = valeur;                                                                                            \
                    }

int       editer=FAUX;
int       simuler=VRAI;
                                        /* Indicateurs de controle des operations effectuees.                                        */

extern    void      srand48();
extern    double    drand48();
extern    double    log();

#define   GRAINE    1947
#define   ALPHA     3.3068
                                        /* Cette valeur donne pour N=9999 et GRAINE=1947 la valeur 104729 au nombre aleatoire numero */
                                        /* 100000 (=N+1), c'est-a-dire le nombre premier numero 100000...                            */
#define   BETA      1
#define   DELTA     (I1+(int)ALPHA+4)
                                        /* Logiquement, vu comme un seuil, 'DELTA' doit etre une fonction de 'I1' et de 'ALPHA'...   */
                                        /* Cette definition est le resultat d'experiences.                                           */
                                        /*                                                                                           */
                                        /* Faire DELTA=0 supprime la discontinuite catastrophique.                                   */
#define   RANDOM(index)                                                                                                                 \
                    {                                                                                                                   \
                    long      int       ValeurAleatoire=((int)(((ALPHA-BETA)*drand48()*log((double)index+1))+BETA));                    \
                                        /* Le parametre 'BETA' garantit que 'ValeurAleatoire' ne peut etre nul. De plus l'usage      */ \
                                        /* du 'log(...)' fait que progressivement les nombres generes sont de plus en plus "rares",  */ \
                                        /* de plus en plus eloignes les uns des autres...                                            */ \
                                                                                                                                        \
                    if        (index == I1)                                                                                             \
                                        /* Est-ce le moment de creer une catastrophe ?                                               */ \
                              {                                                                                                         \
                              NombreAleatoireEntierCourant = NombreAleatoireEntierCourant + DELTA;                                      \
                                        /* Le parametre 'DELTA' regle l'amplitude de la discontinuite "catastrophique"...            */ \
                              }                                                                                                         \
                              else                                                                                                      \
                              {                                                                                                         \
                              }                                                                                                         \
                                                                                                                                        \
                    NombreAleatoireEntierCourant = (2*((NombreAleatoireEntierCourant+ValeurAleatoire)/2)+1);                            \
                                        /* La division par 2, puis la multiplication par 2 avec incrementation de 1 permettent       */ \
                                        /* d'obtenir des nombres aleatoires impairs, le cumul via 'NombreAleatoireEntierCourant'     */ \
                                        /* donnant finalement une liste de nombres aleatoires entiers, impairs et croissants...      */ \
                                                                                                                                        \
                    INITIALISATION(NombreAleatoireEntierCourant,index);                                                                 \
                    }

#define   RANDOM1   2
#define   RANDOM2   3
                                        /* Definition des deux premiers nombres premiers a forcer...                                 */

void      main()
                    {
                    long      int       tableau[N];
                    long      int       i1=I0,i2=I0;
                    long      int       NombreAleatoireEntierCourant=RANDOM2;

                    srand48(GRAINE);

                    INITIALISATION(RANDOM1,I0+0);
                    INITIALISATION(RANDOM2,I0+1);
                                        /* Forcage des deux premiers nombres premiers...                                             */

                    for       (i2=I0+2 ; i2<=I2 ; i2++)
                              {
                              RANDOM(i2);
                                        /* Generation aleatoire des "nombres premiers" suivants.                                     */
                              }

                    if        (editer == VRAI)
                              {
                              for       (i2=I0 ; i2<=I2 ; i2++)
                                        {
                                        printf("nombre[%ld]=%ld\n",i2+1,tableau[i2]);
                                        /* Edition conditionnelle des "nombres premiers" generes.                                    */
                                        }

                              printf("\n");
                              }
                    else
                              {
                              }

                    if        (simuler == VRAI)
                              {
                              for       (i2=I0 ; i2<=I2 ; i2++)
                                        {
                                        for       (i1=I0 ; i1<=(I2-i2) ; i1++)
                                                  {
                                                  printf("%4ld ",tableau[i1]);

                                                  if        ((i1+1) < N-i2)
                                                            {
                                                            tableau[i1] = ABSO(tableau[i1+1]-tableau[i1]);
                                        /* Difference iterative des couples de "nombres premiers".                                   */
                                                            }
                                                  else
                                                            {
                                                            }
                                                  }

                                        printf("\n");
                                        }
                              }
                    else
                              {
                              }
                    }