/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        C O M P R E H E N S I O N   D U   P L U S   P E T I T   P R O G R A M M E   D E   C A L C U L   D E   P I  :               */
/*        ( ' P O U R   L A   S C I E N C E ' ,   M A I   1 9 9 4 )                                                                  */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*        Author of '$xtc/pi_mini.02$c' :                                                                                            */
/*                                                                                                                                   */
/*                    Unknown and Jean-Francois COLONNA (LACTAMME, AAAAMMJJhhmmss).                                                  */
/*                                                                                                                                   */
/*************************************************************************************************************************************/

#define   N         14
#define   PI        2000
                                        /* Le nombre de chiffres de 'PI' donne le nombre de chiffres avec lequel est calcule 'pi'    */
                                        /* (y compris la partie entiere). Si donc ce nombre est augmente, il convient d'augmenter    */
                                        /* correlativement la valeur de 'N' (le nombre d'iterations).                                */

main()
     {
     int       k;
     int       pi=PI;
     for       (k=1 ; k<=(N-1) ; k++)
               {
               pi = ((pi/((2*(N-k))+1)) * (N-k))+PI;
                                        /* Formule de recurrence mysterieuse pouvant etre ecrite :                                   */
                                        /*                                                                                           */
                                        /*                           U                                                               */
                                        /*                            k-1                                                            */
                                        /*                  U  = ------------(N-k) + PI                                              */
                                        /*                   k    2(N-k) + 1                                                         */
                                        /*                                                                                           */
                                        /* avec :                                                                                    */
                                        /*                                                                                           */
                                        /*                  U  = PI                                                                  */
                                        /*                   0                                                                       */
                                        /*                                                                                           */
                                        /*                  k E [1,N-1]                                                              */
                                        /*                                                                                           */
                                        /* pour une valeur 'N' maximale.                                                             */
                                        /*                                                                                           */
                                        /* Cela ressemble a une sorte de fraction continue "a l'envers" (c'est-a-dire ou c'est       */
                                        /* le numerateur, et non point le denominateur, qui est une fraction) ; ainsi, pour N=4      */
                                        /* on a :                                                                                    */
                                        /*                                                                                           */
                                        /*                   1                                                                       */
                                        /*                  ---3 + 1                                                                 */
                                        /*                   7                                                                       */
                                        /*                  ---------2 + 1                                                           */
                                        /*                      5                                                                    */
                                        /*                  ---------------1 + 1                                                     */
                                        /*                         3                                                                 */
                                        /*                                                                                           */
                                        /* en faisant PI=1...                                                                        */
               }
     printf("\n pi = %d",pi);
     }