Source code in the c programming language

/*********************************************
Subject: Comparing five methods for
         computing Euler's constant 0.5772...
tested : tcc-0.9.27
--------------------------------------------*/
#include <math.h>
#include <stdio.h>

#define eps 1e-6

int main(void) {
double a, b, h, n2, r, u, v;
int k, k2, m, n;

printf("From the definition, err. 3e-10\n");

n = 400;

h = 1;
for (k = 2; k <= n; k++) {
   h += 1.0 / k;
}
//faster convergence: Negoi, 1997
a = log(n +.5 + 1.0 / (24*n));

printf("Hn    %.16f\n", h);
printf("gamma %.16f\nk = %d\n\n", h - a, n);


printf("Sweeney, 1963, err. idem\n");

n = 21;

double s[] = {0, n};
r = n;
k = 1;
do {
   k += 1;
   r *= (double) n / k;
   s[k & 1] += r / k;
} while (r > eps);

printf("gamma %.16f\nk = %d\n\n", s[1] - s[0] - log(n), k);


printf("Bailey, 1988\n");

n = 5;

a = 1;
h = 1;
n2 = pow(2,n);
r = 1;
k = 1;
do {
   k += 1;
   r *= n2 / k;
   h += 1.0 / k;
   b = a; a += r * h;
} while (fabs(b - a) > eps);
a *= n2 / exp(n2);

printf("gamma %.16f\nk = %d\n\n", a - n * log(2), k);


printf("Brent-McMillan, 1980\n");

n = 13;

a = -log(n);
b = 1;
u = a;
v = b;
n2 = n * n;
k2 = 0;
k = 0;
do {
   k2 += 2*k + 1;
   k += 1;
   a *= n2 / k;
   b *= n2 / k2;
   a = (a + b) / k;
   u += a;
   v += b;
} while (fabs(a) > eps);

printf("gamma %.16f\nk = %d\n\n", u / v, k);


printf("How Euler did it in 1735\n");
//Bernoulli numbers with even indices
double B2[] = {1.0,1.0/6,-1.0/30,1.0/42,-1.0/30,\
 5.0/66,-691.0/2730,7.0/6,-3617.0/510,43867.0/798};
m = 7;
if (m > 9) return(0);

n = 10;

//n-th harmonic number
h = 1;
for (k = 2; k <= n; k++) {
   h += 1.0 / k;
}
printf("Hn    %.16f\n", h);

h -= log(n);
printf("  -ln %.16f\n", h);

//expansion C = -digamma(1)
a = -1.0 / (2*n);
n2 = n * n;
r = 1;
for (k = 1; k <= m; k++) {
   r *= n2;
   a += B2[k] / (2*k * r);
}

printf("err  %.16f\ngamma %.16f\nk = %d", a, h + a, n + m);

printf("\n\nC  =  0.57721566490153286...\n");
}


/**************************************************
Subject: Computation of Euler's constant 0.5772...
         with the Brent-McMillan algorithm B1,
         Math. Comp. 34 (1980), 305-312
tested : tcc-0.9.27 with gmp 6.2.0
-------------------------------------------------*/
#include <gmp.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

//multi-precision float pointers
mpf_ptr u, v, k2;

//precision parameters
unsigned long e10, e2;
long e;
double f;

//log(x/y) with the Taylor series for atanh(x-y/x+y)
void ln (mpf_ptr s, unsigned long x, unsigned long y) {
mpf_ptr d = u, q = v;
unsigned long k;
   //Möbius transformation
   k = x; x -= y; y += k;

   if (x != 1) {
      printf ("ln: illegal argument x - y != 1");
      exit;
   }

   //s = 1 / (x + y)
   mpf_set_ui (s, y);
   mpf_ui_div (s, 1, s);
   //k2 = s * s
   mpf_mul (k2, s, s);
   mpf_set (d, s);

   k = 1;
   do {
      k += 2;
      //d *= k2
      mpf_mul (d, d, k2);
      //q = d / k
      mpf_div_ui (q, d, k);
      //s += q
      mpf_add (s, s, q);

      f = mpf_get_d_2exp (&e, q);
   } while (abs(e) < e2);

   //s *= 2
   mpf_mul_2exp (s, s, 1);
}

int main (void) {
mpf_ptr a = malloc(sizeof(__mpf_struct));
mpf_ptr b = malloc(sizeof(__mpf_struct));
u = malloc(sizeof(__mpf_struct));
v = malloc(sizeof(__mpf_struct));
k2 = malloc(sizeof(__mpf_struct));
//unsigned long integers
unsigned long k, n, n2, r, s, t;

clock_t tim = clock();

// n = 2^i * 3^j * 5^k

// log(n) = r * log(16/15) + s * log(25/24) + t * log(81/80)

// solve linear system for r, s, t
//  4 -3 -4| i
// -1 -1  4| j
// -1  2 -1| k

//examples
t = 1;
switch (t) {
case 1 :
   n = 60;
   r = 41;
   s = 30;
   t = 18;
//100 digits
break;
case 2 :
   n = 4800;
   r = 85;
   s = 62;
   t = 37;
//8000 digits, 0.6 s
break;
case 3 :
   n = 9375;
   r = 91;
   s = 68;
   t = 40;
//15625 digits, 2.5 s
break;
default :
   n = 18750;
   r = 98;
   s = 73;
   t = 43;
//31250 digits, 12 s. @2.00GHz
}

//decimal precision
e10 = n / .6;
//binary precision
e2 = (1 + e10) / .30103;

//initialize mpf's
mpf_set_default_prec (e2);
mpf_inits (a, b, u, v, k2, (mpf_ptr)0);

//Compute log terms

ln (b, 16, 15);

//a = r * b
mpf_mul_ui (a, b, r);

ln (b, 25, 24);

//a += s * b
mpf_mul_ui (u, b, s);
mpf_add (a, a, u);

ln (b, 81, 80);

//a += t * b
mpf_mul_ui (u, b, t);
mpf_add (a, a, u);

//gmp_printf ("log(%lu) %.*Ff\n", n, e10, a);

//B&M, algorithm B1

//a = -a, b = 1
mpf_neg (a, a);
mpf_set_ui (b, 1);
mpf_set (u, a);
mpf_set (v, b);

k = 0;
n2 = n * n;
//k2 = k * k
mpf_set_ui (k2, 0);
do {
   //k2 += 2k + 1
   mpf_add_ui (k2, k2, (k << 1) + 1);
   k += 1;

   //b = b * n2 / k2
   mpf_div (b, b, k2);
   mpf_mul_ui (b, b, n2);
   //a = (a * n2 / k + b) / k
   mpf_div_ui (a, a, k);
   mpf_mul_ui (a, a, n2);
   mpf_add (a, a, b);
   mpf_div_ui (a, a, k);

   //u += a, v += b
   mpf_add (u, u, a);
   mpf_add (v, v, b);

   f = mpf_get_d_2exp (&e, a);
} while (abs(e) < e2);

mpf_div (u, u, v);
gmp_printf ("gamma %.*Ff (maxerr. 1e-%lu)\n", e10, u, e10);

gmp_printf ("k = %lu\n\n", k);

tim = clock() - tim;
printf("time: %.7f s\n",((double)tim)/CLOCKS_PER_SEC);
}


/*******************************************
Subject: Euler's constant 0.5772...
tested : tcc-0.9.27 with mpfr 4.1.0
------------------------------------------*/
#include <gmp.h>
#include <mpfr.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

int main (void) {
mpfr_ptr a = malloc(sizeof(__mpfr_struct));
unsigned long e2, e10;
clock_t tim = clock();

//decimal precision
e10 = 100;

//binary precision
e2 = (1 + e10) / .30103;
mpfr_init2 (a, e2);

mpfr_const_euler (a, MPFR_RNDN);
mpfr_printf ("gamma %.*Rf\n\n", e10, a);

tim = clock() - tim;
gmp_printf ("time: %.7f s\n",((double)tim)/CLOCKS_PER_SEC);
}