aparler/RosettaCodeData
1
0
Fork 0
Code Issues 12 Pull requests 3 Projects Releases Packages Wiki Activity Actions

Data commit

Browse source
This commit is contained in:
Ingy döt Net 2023-07-01 11:58:00 -04:00
parent 7387c8f97b
commit cb5bb5e222
199093 changed files with 3378972 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

3
Task/Eulers-constant-0.5772.../00-META.yaml Normal file
View file

@ -0,0 +1,3 @@
---
from: http://rosettacode.org/wiki/Euler's_constant_0.5772...
note: mathematics

29
Task/Eulers-constant-0.5772.../00-TASK.txt Normal file
View file

@ -0,0 +1,29 @@
;Task.
Compute [[wp:Euler%27s_constant|the Euler constant 0.5772...]]
Discovered by [[wp:Leonhard_Euler|Leonhard Euler]] around 1730, it is the most ubiquitous mathematical constant after pi and e, but appears more arcane than these.
Denoted gamma (''&#947;''), it measures the amount by which the partial sums of the [[wp:Harmonic_series_(mathematics)|harmonic series]] (the simplest diverging series) differ from the logarithmic function (its approximating integral): {{math|lim&#8202;<sub>n&#8202;&rarr;&#8202;&infin;</sub> <big>(</big>1 + 1/2 + 1/3 + &#8230; + 1/n &minus; log(n)<big>)</big>}}.
The definition of ''&#947;'' converges too slowly to be numerically useful, but in 1735 Euler himself applied his recently discovered summation formula to compute &#8216;the notable number&#8217; accurate to 15 places. For a single-precision implementation this is still the most economic algorithm.
In 1961, the young Donald Knuth used Euler's method to evaluate ''&#947;'' to 1271 places. Knuth found that the computation of the Bernoulli numbers required in the Euler-Maclaurin formula was the most time-consuming part of the procedure.
The next year Dura Sweeney computed 3566 places, using a formula based on the expansion of the exponential integral which didn't need Bernoulli numbers. It's a bit-hungry method though: ''2d'' digits of working precision obtain ''d'' correct places only.
This was remedied in 1988 by David Bailey; meanwhile Richard Brent and Ed McMillan had published an even more efficient algorithm based on Bessel function identities and found 30100 places in 20 hours time.
Nowadays the old records have far been exceeded: over {{math|6&#183;10<sup>11</sup>}} decimal places are already known. These massive computations suggest that ''&#947;'' is neither rational nor algebraic, but this is yet to be proven.
;References.
[http://numbers.computation.free.fr/Constants/Gamma/gamma.html]
Gourdon and Sebah, The Euler constant ''&#947;''. (for all formulas)
[https://scholarlycommons.pacific.edu/cgi/viewcontent.cgi?filename=1&article=1046&context=euler-works&type=additional]
Euler's original journal article translated from the latin (p. 9)
__TOC__

1
Task/Eulers-constant-0.5772.../Burlesque/eulers-constant-0.5772....blq Normal file
View file

@ -0,0 +1 @@
33ro{JroJJJL[\/JL[\/nr\/{-1}\/.*FLJL[ro?^?*\/JL[{2}\/.*FL\/?^?*\/{1.+}m[J{lg}m[\/?/?*++\/1 3.0./\/?^.*}m[++-2 3 2lg.*./.*2lg2./.+

67
Task/Eulers-constant-0.5772.../C++/eulers-constant-0.5772....cpp Normal file
View file

@ -0,0 +1,67 @@
#include <array>
#include <cmath>
#include <iomanip>
#include <iostream>
double ByVaccaSeries(int numTerms)
{
// this method is simple but converges slowly
// calculate gamma by:
// 1 * (1/2 - 1/3) +
// 2 * (1/4 - 1/5 + 1/6 - 1/7) +
// 3 * (1/8 - 1/9 + 1/10 - 1/11 + 1/12 - 1/13 + 1/14 - 1/15) +
// 4 * ( . . . ) +
// . . .
double gamma = 0;
size_t next = 4;
for(double numerator = 1; numerator < numTerms; ++numerator)
{
double delta = 0;
for(size_t denominator = next/2; denominator < next; denominator+=2)
{
// calculate terms two at a time
delta += 1.0/denominator - 1.0/(denominator + 1);
}
gamma += numerator * delta;
next *= 2;
}
return gamma;
}
// based on the C entry
double ByEulersMethod()
{
//Bernoulli numbers with even indices
const std::array<double, 8> B2 {1.0, 1.0/6, -1.0/30, 1.0/42, -1.0/30,
5.0/66, -691.0/2730, 7.0/6};
const int n = 10;
//n-th harmonic number
const double h = [] // immediately invoked lambda
{
double sum = 1;
for (int k = 2; k <= n; k++) { sum += 1.0 / k; }
return sum - log(n);
}();
//expansion C = -digamma(1)
double a = -1.0 / (2*n);
double r = 1;
for (int k = 1; k < ssize(B2); k++)
{
r *= n * n;
a += B2[k] / (2*k * r);
}
return h + a;
}
int main()
{
std::cout << std::setprecision(16) << "Vacca series: " << ByVaccaSeries(32);
std::cout << std::setprecision(16) << "\nEulers method: " << ByEulersMethod();
}

121
Task/Eulers-constant-0.5772.../C/eulers-constant-0.5772...-1.c Normal file
View file

@ -0,0 +1,121 @@
/*********************************************
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");
}

178
Task/Eulers-constant-0.5772.../C/eulers-constant-0.5772...-2.c Normal file
View file

@ -0,0 +1,178 @@
/**************************************************
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);
}

28
Task/Eulers-constant-0.5772.../C/eulers-constant-0.5772...-3.c Normal file
View file

@ -0,0 +1,28 @@
/*******************************************
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);
}

6
Task/Eulers-constant-0.5772.../Clojure/eulers-constant-0.5772....clj Normal file
View file

@ -0,0 +1,6 @@
(let [n 1e10]
(loop [i 1
out (- (Math/log n))]
(if (<= i n)
(recur (inc i) (+ out (/ 1.0 i)))
out)))

39
Task/Eulers-constant-0.5772.../Delphi/eulers-constant-0.5772....delphi Normal file
View file

@ -0,0 +1,39 @@
function ComputeEuler(N: int64): double;
{Compute Eurler number with N-number of iterations}
var I: integer;
var A: double;
begin
Result:=0;
for I:=1 to N-1 do
Result:=Result + 1 / I;
A:=Ln(N + 0.5 + 1/(24.0*N));
Result:=Result-A;
end;
procedure ShowEulersNumber(Memo: TMemo);
{Show Euler numbers at various levels of precision}
var Euler,G,A,Error: double;
var N: integer;
const Correct =0.57721566490153286060651209008240243104215933593992;
procedure ShowEulerError(N: int64);
{Show Euler number and Error}
begin
Euler:=ComputeEuler(N);
Error:=Correct-Euler;
Memo.Lines.Add('N = '+FloatToStrF(N,ffNumber,18,0));
Memo.Lines.Add('Euler='+FloatToStrF(Euler,ffFixed,18,18));
Memo.Lines.Add('Error='+FloatToStrF(Error,ffFixed,18,18));
Memo.Lines.Add('');
end;
begin
{Compute Euler number with iterations ranging 10 to 10^9}
for N:=1 to 9 do
begin
ShowEulerError(Trunc(Power(10,N)));
end;
end;

120
Task/Eulers-constant-0.5772.../FreeBASIC/eulers-constant-0.5772...-1.basic Normal file
View file

@ -0,0 +1,120 @@
'**********************************************
'Subject: Comparing five methods for
' computing Euler's constant 0.5772...
'tested : FreeBasic 1.08.1
'----------------------------------------------
const eps = 1e-6
dim as double a, b, h, n2, r, u, v
dim as integer k, k2, m, n
? "From the definition, err. 3e-10"
n = 400
h = 1
for k = 2 to n
h += 1 / k
next k
'faster convergence: Negoi, 1997
a = log(n +.5 + 1 / (24*n))
? "Hn "; h
? "gamma"; h - a; !"\nk ="; n
?
? "Sweeney, 1963, err. idem"
n = 21
dim as double s(1) = {0, n}
r = n
k = 1
do
k += 1
r *= n / k
s(k and 1) += r / k
loop until r < eps
? "gamma"; s(1) - s(0) - log(n); !"\nk ="; k
?
? "Bailey, 1988"
n = 5
a = 1
h = 1
n2 = 2^n
r = 1
k = 1
do
k += 1
r *= n2 / k
h += 1 / k
b = a: a += r * h
loop until abs(b - a) < eps
a *= n2 / exp(n2)
? "gamma"; a - n * log(2); !"\nk ="; k
?
? "Brent-McMillan, 1980"
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
loop until abs(a) < eps
? "gamma"; u / v; !"\nk ="; k
?
? "How Euler did it in 1735"
'Bernoulli numbers with even indices
dim as double B2(9) = {1,1/6,-1/30,1/42,_
-1/30,5/66,-691/2730,7/6,-3617/510,43867/798}
m = 7
if m > 9 then end
n = 10
'n-th harmonic number
h = 1
for k = 2 to n
h += 1 / k
next k
? "Hn "; h
h -= log(n)
? " -ln"; h
'expansion C = -digamma(1)
a = -1 / (2*n)
n2 = n * n
r = 1
for k = 1 to m
r *= n2
a += B2(k) / (2*k * r)
next k
? "err "; a; !"\ngamma"; h + a; !"\nk ="; n + m
?
? "C = 0.57721566490153286..."
end

172
Task/Eulers-constant-0.5772.../FreeBASIC/eulers-constant-0.5772...-2.basic Normal file
View file

@ -0,0 +1,172 @@
'***************************************************
'Subject: Computation of Euler's constant 0.5772...
' with the Brent-McMillan algorithm B1,
' Math. Comp. 34 (1980), 305-312
'tested : FreeBasic 1.08.1 with gmp 6.2.0
'---------------------------------------------------
#include "gmp.bi"
'multi-precision float pointers
Dim as mpf_ptr a, b
Dim shared as mpf_ptr k2, u, v
'unsigned long integers
Dim as ulong k, n, n2, r, s, t
'precision parameters
Dim shared as ulong e10, e2
Dim shared e as clong
Dim shared f as double
Dim as double tim = TIMER
CLS
a = allocate(len(__mpf_struct))
b = allocate(len(__mpf_struct))
u = allocate(len(__mpf_struct))
v = allocate(len(__mpf_struct))
k2 = allocate(len(__mpf_struct))
'log(x/y) with the Taylor series for atanh(x-y/x+y)
Sub ln (byval s as mpf_ptr, byval x as ulong, byval y as ulong)
Dim as mpf_ptr d = u, q = v
Dim k as ulong
'Möbius transformation
k = x: x -= y: y += k
If x <> 1 Then
Print "ln: illegal argument x - y <> 1"
End
End If
'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)
Loop until abs(e) > e2
's *= 2
mpf_mul_2exp (s, s, 1)
End Sub
'Main
'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
select case t
case 1
n = 60
r = 41
s = 30
t = 18
'100 digits
case 2
n = 4800
r = 85
s = 62
t = 37
'8000 digits, 0.6 s
case 3
n = 9375
r = 91
s = 68
t = 40
'15625 digits, 2.5 s
case else
n = 18750
r = 98
s = 73
t = 43
'31250 digits, 12 s. @2.00GHz
end select
'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, Cptr(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 shl 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)
Loop until 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)
gmp_printf (!"time: %.7f s\n", TIMER - tim)
end

23
Task/Eulers-constant-0.5772.../FreeBASIC/eulers-constant-0.5772...-3.basic Normal file
View file

@ -0,0 +1,23 @@
' ******************************************
'Subject: Euler's constant 0.5772...
'tested : FreeBasic 1.08.1 with mpfr 4.1.0
'-------------------------------------------
#include "gmp.bi"
#include "mpfr.bi"
dim as mpfr_ptr a = allocate(len(__mpfr_struct))
dim as ulong e2, e10
dim as double tim = TIMER
'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)
gmp_printf (!"time: %.7f s\n", TIMER - tim)
end

2
Task/Eulers-constant-0.5772.../J/eulers-constant-0.5772...-1.j Normal file
View file

@ -0,0 +1,2 @@
(% - !@<:) 2^_27
0.577216

8
Task/Eulers-constant-0.5772.../J/eulers-constant-0.5772...-2.j Normal file
View file

@ -0,0 +1,8 @@
Euler=: {{
A=.B=. ^.1r13 1x1
r=. j=. 0
whilst. (r=.%/B)~:!.0(r) do.
B=. B+A=. (j,1)%~+/\.A*169%(1,j)*(j=.j+1)
end.
r
}}0

2
Task/Eulers-constant-0.5772.../J/eulers-constant-0.5772...-3.j Normal file
View file

@ -0,0 +1,2 @@
Euler
0.5772156649015329

24
Task/Eulers-constant-0.5772.../Java/eulers-constant-0.5772....java Normal file
View file

@ -0,0 +1,24 @@
/**
* Using a simple formula derived from Hurwitz zeta function,
* as described on https://en.wikipedia.org/wiki/Euler%27s_constant,
* gives a result accurate to 12 decimal places.
*/
public class EulerConstant {
public static void main(String[] args) {
System.out.println(gamma(1_000_000));
}
private static double gamma(int N) {
double gamma = 0.0;
for ( int n = 1; n <= N; n++ ) {
gamma += 1.0 / n;
}
gamma -= Math.log(N) + 1.0 / ( 2 * N );
return gamma;
}
}

11
Task/Eulers-constant-0.5772.../Jq/eulers-constant-0.5772....jq Normal file
View file

@ -0,0 +1,11 @@
# Bailey, 1988
def bailey($n; $eps):
pow(2; $n) as $n2
| {a :1, b: 0, h: 1, r: 1, k: 1}
| until( (.b - .a)|fabs <= $eps;
.k += 1
| .r *= ($n2 / .k)
| .h += (1.0 / .k)
| .b = .a
| .a += (.r * .h) )
| (.a * $n2 / ($n2|exp) ) - ($n * (2|log)) ;

1
Task/Eulers-constant-0.5772.../Julia/eulers-constant-0.5772....julia Normal file
View file

@ -0,0 +1 @@
display(MathConstants.γ) # γ = 0.5772156649015...

15
Task/Eulers-constant-0.5772.../Lambdatalk/eulers-constant-0.5772...-1.lambdatalk Normal file
View file

@ -0,0 +1,15 @@
{def negoi
{lambda {:n}
{let { {:n :n}
{:h {+ {S.map {lambda {:k} {/ 1 :k}} {S.serie 1 :n}}} }
{:a {log {+ :n 0.5 {/ 1 {* 24 :n}}}}} // Negoi, 1997
} {div}-> Hn :h
{div}gamma {- :h :a}
{div}k :n
}}}
-> negoi
{negoi 400}
-> Hn 6.5699296911765055
gamma 0.5772156645765731 with k = 400
(0.57721566457657 target)

21
Task/Eulers-constant-0.5772.../Lambdatalk/eulers-constant-0.5772...-2.lambdatalk Normal file
View file

@ -0,0 +1,21 @@
{def sweeney
{def sweeney.set!
{lambda {:s :r :k :i}
{A.set! :i {+ {A.get :i :s} {/ :r :k}} :s}
}}
{def sweeney.loop
{lambda {:n :s :r :k}
{if {<= :r 1.e-10}
then gamma = {- {A.get 1 :s} {A.get 0 :s} {log :n}} with k=:k
else {sweeney.loop :n
{sweeney.set! :s {* :r {/ :n :k}} :k {% :k 2}}
{* :r {/ :n :k}}
{+ :k 1} }
}}}
{lambda {:n}
{sweeney.loop :n {A.new 0 :n} :n 2} }}
-> sweeney
{sweeney 21}
-> gamma = 0.577215664563631 with k=76
(0.57721566456363 target)

10
Task/Eulers-constant-0.5772.../Lua/eulers-constant-0.5772....lua Normal file
View file

@ -0,0 +1,10 @@
function computeGamma (iterations, decimalPlaces)
local Hn = 1
for i = 2, iterations do
Hn = Hn + (1/i)
end
local gamma = tostring(Hn - math.log(iterations))
return tonumber(gamma:sub(1, decimalPlaces + 2))
end
print(computeGamma(10^8, 8))

1
Task/Eulers-constant-0.5772.../Mathematica/eulers-constant-0.5772....math Normal file
View file

@ -0,0 +1 @@
N[EulerGamma, 1000]

9
Task/Eulers-constant-0.5772.../Nim/eulers-constant-0.5772....nim Normal file
View file

@ -0,0 +1,9 @@
import std/math
const n = 1e6
var result = 1.0
for i in 2..int(n):
result += 1/i
echo result - ln(n)

4
Task/Eulers-constant-0.5772.../PARI-GP/eulers-constant-0.5772....parigp Normal file
View file

@ -0,0 +1,4 @@
\l "euler_const.log"
\p 100
print("gamma ", Euler);
\q

7
Task/Eulers-constant-0.5772.../Perl/eulers-constant-0.5772....pl Normal file
View file

@ -0,0 +1,7 @@
#!/usr/bin/perl
use strict; # https://en.wikipedia.org/wiki/Euler%27s_constant
use warnings;
use List::Util qw( sum );
print sum( map 1 / $_, 1 .. 1e6) - log 1e6, "\n";

6
Task/Eulers-constant-0.5772.../Phix/eulers-constant-0.5772...-1.phix Normal file
View file

@ -0,0 +1,6 @@
(phixonline)-->
<span style="color: #000080;font-style:italic;">-- demo\rosetta\Eulers_constant.exw</span>
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
<span style="color: #008080;">constant</span> <span style="color: #000000;">C</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">sum</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">sq_div</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">tagset</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1e6</span><span style="color: #0000FF;">)))-</span><span style="color: #7060A8;">log</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1e6</span><span style="color: #0000FF;">)</span>
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"gamma %.12f (max 12d.p. of accuracy)\n"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">C</span><span style="color: #0000FF;">)</span>
<!--

89
Task/Eulers-constant-0.5772.../Phix/eulers-constant-0.5772...-2.phix Normal file
View file

@ -0,0 +1,89 @@
-->
<span style="color: #008080;">without</span> <span style="color: #008080;">js</span> <span style="color: #000080;font-style:italic;">-- no mpfr_get_d_2exp() in mpfr.js as yet</span>
<span style="color: #7060A8;">requires</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"1.0.2"</span><span style="color: #0000FF;">)</span> <span style="color: #000080;font-style:italic;">-- mpfr_get_d_2exp(), mpfr_addmul_si()</span>
<span style="color: #008080;">include</span> <span style="color: #004080;">mpfr</span><span style="color: #0000FF;">.</span><span style="color: #000000;">e</span>
<span style="color: #004080;">mpfr</span> <span style="color: #000000;">u</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">v</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">k2</span><span style="color: #0000FF;">;</span>
<span style="color: #004080;">integer</span> <span style="color: #000000;">e</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">e10</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">e2</span>
<span style="color: #004080;">atom</span> <span style="color: #000000;">f</span>
<span style="color: #000080;font-style:italic;">//log(x/y) with the Taylor series for atanh(x-y/x+y)</span>
<span style="color: #008080;">procedure</span> <span style="color: #000000;">ln</span><span style="color: #0000FF;">(</span><span style="color: #004080;">mpfr</span> <span style="color: #000000;">s</span><span style="color: #0000FF;">,</span> <span style="color: #004080;">integer</span> <span style="color: #000000;">x</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">y</span><span style="color: #0000FF;">)</span>
<span style="color: #004080;">mpfr</span> <span style="color: #000000;">d</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">u</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">q</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">v</span><span style="color: #0000FF;">;</span>
<span style="color: #7060A8;">assert</span><span style="color: #0000FF;">((</span><span style="color: #000000;">x</span><span style="color: #0000FF;">-</span><span style="color: #000000;">y</span><span style="color: #0000FF;">)==</span><span style="color: #000000;">1</span><span style="color: #0000FF;">)</span>
<span style="color: #7060A8;">mpfr_set_si</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">x</span><span style="color: #0000FF;">+</span><span style="color: #000000;">y</span><span style="color: #0000FF;">)</span>
<span style="color: #7060A8;">mpfr_si_div</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">1</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">s</span><span style="color: #0000FF;">)</span> <span style="color: #000080;font-style:italic;">// s = 1 / (x + y)</span>
<span style="color: #7060A8;">mpfr_mul</span><span style="color: #0000FF;">(</span><span style="color: #000000;">k2</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">s</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">s</span><span style="color: #0000FF;">)</span> <span style="color: #000080;font-style:italic;">// k2 = s * s</span>
<span style="color: #7060A8;">mpfr_set</span><span style="color: #0000FF;">(</span><span style="color: #000000;">d</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">s</span><span style="color: #0000FF;">)</span>
<span style="color: #004080;">integer</span> <span style="color: #000000;">k</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">1</span>
<span style="color: #008080;">while</span> <span style="color: #004600;">true</span> <span style="color: #008080;">do</span>
<span style="color: #000000;">k</span> <span style="color: #0000FF;">+=</span> <span style="color: #000000;">2</span><span style="color: #0000FF;">;</span>
<span style="color: #7060A8;">mpfr_mul</span><span style="color: #0000FF;">(</span><span style="color: #000000;">d</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">d</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">k2</span><span style="color: #0000FF;">)</span> <span style="color: #000080;font-style:italic;">// d *= k2</span>
<span style="color: #7060A8;">mpfr_div_si</span><span style="color: #0000FF;">(</span><span style="color: #000000;">q</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">d</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">k</span><span style="color: #0000FF;">)</span> <span style="color: #000080;font-style:italic;">// q = d / k</span>
<span style="color: #7060A8;">mpfr_add</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">s</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">q</span><span style="color: #0000FF;">)</span> <span style="color: #000080;font-style:italic;">// s += q</span>
<span style="color: #0000FF;">{</span><span style="color: #000000;">f</span><span style="color: #0000FF;">,</span><span style="color: #000000;">e</span><span style="color: #0000FF;">}</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">mpfr_get_d_2exp</span><span style="color: #0000FF;">(</span><span style="color: #000000;">q</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">if</span> <span style="color: #7060A8;">abs</span><span style="color: #0000FF;">(</span><span style="color: #000000;">e</span><span style="color: #0000FF;">)>=</span><span style="color: #000000;">e2</span> <span style="color: #008080;">then</span> <span style="color: #008080;">exit</span> <span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">while</span>
<span style="color: #7060A8;">mpfr_mul_si</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">s</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">2</span><span style="color: #0000FF;">)</span> <span style="color: #000080;font-style:italic;">//s *= 2</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">procedure</span>
<span style="color: #004080;">mpfr</span> <span style="color: #000000;">a</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">b</span>
<span style="color: #004080;">integer</span> <span style="color: #000000;">k</span><span style="color: #0000FF;">,</span>
<span style="color: #000000;">n</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">60</span><span style="color: #0000FF;">,</span> <span style="color: #000080;font-style:italic;">-- (required precision in decimal dp *6/10)</span>
<span style="color: #000000;">n2</span><span style="color: #0000FF;">,</span>
<span style="color: #000000;">r</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">41</span><span style="color: #0000FF;">,</span>
<span style="color: #000000;">s</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">30</span><span style="color: #0000FF;">,</span>
<span style="color: #000000;">t</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">18</span><span style="color: #0000FF;">;</span>
<span style="color: #000080;font-style:italic;">// 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
//decimal precision</span>
<span style="color: #000000;">e10</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">floor</span><span style="color: #0000FF;">(</span><span style="color: #000000;">n</span><span style="color: #0000FF;">/</span><span style="color: #000000;">0.6</span><span style="color: #0000FF;">)</span>
<span style="color: #000080;font-style:italic;">//binary precision</span>
<span style="color: #000000;">e2</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">floor</span><span style="color: #0000FF;">((</span><span style="color: #000000;">1</span> <span style="color: #0000FF;">+</span> <span style="color: #000000;">e10</span><span style="color: #0000FF;">)</span> <span style="color: #0000FF;">/</span> <span style="color: #000000;">0.30103</span><span style="color: #0000FF;">)</span>
<span style="color: #7060A8;">mpfr_set_default_precision</span><span style="color: #0000FF;">(</span><span style="color: #000000;">e2</span><span style="color: #0000FF;">)</span>
<span style="color: #0000FF;">{</span><span style="color: #000000;">a</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">b</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">u</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">v</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">k2</span><span style="color: #0000FF;">}</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">mpfr_inits</span><span style="color: #0000FF;">(</span><span style="color: #000000;">5</span><span style="color: #0000FF;">)</span>
<span style="color: #000080;font-style:italic;">//Compute log terms</span>
<span style="color: #000000;">ln</span><span style="color: #0000FF;">(</span><span style="color: #000000;">b</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">16</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">15</span><span style="color: #0000FF;">)</span> <span style="color: #7060A8;">mpfr_mul_si</span><span style="color: #0000FF;">(</span><span style="color: #000000;">a</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">b</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">r</span><span style="color: #0000FF;">)</span> <span style="color: #000080;font-style:italic;">// a = r * b</span>
<span style="color: #000000;">ln</span><span style="color: #0000FF;">(</span><span style="color: #000000;">b</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">25</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">24</span><span style="color: #0000FF;">)</span> <span style="color: #000000;">mpfr_addmul_si</span><span style="color: #0000FF;">(</span><span style="color: #000000;">a</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">b</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">s</span><span style="color: #0000FF;">)</span> <span style="color: #000080;font-style:italic;">// a += s * b</span>
<span style="color: #000000;">ln</span><span style="color: #0000FF;">(</span><span style="color: #000000;">b</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">81</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">80</span><span style="color: #0000FF;">)</span> <span style="color: #000000;">mpfr_addmul_si</span><span style="color: #0000FF;">(</span><span style="color: #000000;">a</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">b</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">t</span><span style="color: #0000FF;">)</span> <span style="color: #000080;font-style:italic;">// a += t * b</span>
<span style="color: #000000;">mpfr_neg</span><span style="color: #0000FF;">(</span><span style="color: #000000;">a</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">a</span><span style="color: #0000FF;">)</span> <span style="color: #000080;font-style:italic;">// a = -a</span>
<span style="color: #7060A8;">mpfr_set_si</span><span style="color: #0000FF;">(</span><span style="color: #000000;">b</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">1</span><span style="color: #0000FF;">)</span> <span style="color: #000080;font-style:italic;">// b = 1</span>
<span style="color: #7060A8;">mpfr_set</span> <span style="color: #0000FF;">(</span><span style="color: #000000;">u</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">a</span><span style="color: #0000FF;">)</span>
<span style="color: #7060A8;">mpfr_set</span> <span style="color: #0000FF;">(</span><span style="color: #000000;">v</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">b</span><span style="color: #0000FF;">)</span>
<span style="color: #000000;">k</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">0</span><span style="color: #0000FF;">;</span>
<span style="color: #000000;">n2</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">n</span> <span style="color: #0000FF;">*</span> <span style="color: #000000;">n</span><span style="color: #0000FF;">;</span>
<span style="color: #7060A8;">mpfr_set_si</span><span style="color: #0000FF;">(</span><span style="color: #000000;">k2</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">0</span><span style="color: #0000FF;">)</span> <span style="color: #000080;font-style:italic;">// k2 = k * k (as below)</span>
<span style="color: #008080;">while</span> <span style="color: #004600;">true</span> <span style="color: #008080;">do</span>
<span style="color: #000000;">mpfr_add_si</span><span style="color: #0000FF;">(</span><span style="color: #000000;">k2</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">k2</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">k</span><span style="color: #0000FF;">*</span><span style="color: #000000;">2</span><span style="color: #0000FF;">+</span><span style="color: #000000;">1</span><span style="color: #0000FF;">)</span> <span style="color: #000080;font-style:italic;">// k2 += 2k + 1</span>
<span style="color: #000000;">k</span> <span style="color: #0000FF;">+=</span> <span style="color: #000000;">1</span><span style="color: #0000FF;">;</span>
<span style="color: #7060A8;">mpfr_div</span><span style="color: #0000FF;">(</span><span style="color: #000000;">b</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">b</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">k2</span><span style="color: #0000FF;">)</span>
<span style="color: #7060A8;">mpfr_mul_si</span><span style="color: #0000FF;">(</span><span style="color: #000000;">b</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">b</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">n2</span><span style="color: #0000FF;">)</span> <span style="color: #000080;font-style:italic;">// b = b * n2 / k2</span>
<span style="color: #7060A8;">mpfr_div_si</span><span style="color: #0000FF;">(</span><span style="color: #000000;">a</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">a</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">k</span><span style="color: #0000FF;">)</span>
<span style="color: #7060A8;">mpfr_mul_si</span><span style="color: #0000FF;">(</span><span style="color: #000000;">a</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">a</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">n2</span><span style="color: #0000FF;">)</span>
<span style="color: #7060A8;">mpfr_add</span> <span style="color: #0000FF;">(</span><span style="color: #000000;">a</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">a</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">b</span><span style="color: #0000FF;">)</span>
<span style="color: #7060A8;">mpfr_div_si</span><span style="color: #0000FF;">(</span><span style="color: #000000;">a</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">a</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">k</span><span style="color: #0000FF;">)</span> <span style="color: #000080;font-style:italic;">// a = (a * n2 / k + b) / k</span>
<span style="color: #7060A8;">mpfr_add</span><span style="color: #0000FF;">(</span><span style="color: #000000;">u</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">u</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">a</span><span style="color: #0000FF;">)</span> <span style="color: #000080;font-style:italic;">// u += a</span>
<span style="color: #7060A8;">mpfr_add</span><span style="color: #0000FF;">(</span><span style="color: #000000;">v</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">v</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">b</span><span style="color: #0000FF;">)</span> <span style="color: #000080;font-style:italic;">// v += b</span>
<span style="color: #0000FF;">{</span><span style="color: #000000;">f</span><span style="color: #0000FF;">,</span><span style="color: #000000;">e</span><span style="color: #0000FF;">}</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">mpfr_get_d_2exp</span> <span style="color: #0000FF;">(</span><span style="color: #000000;">a</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">if</span> <span style="color: #7060A8;">abs</span><span style="color: #0000FF;">(</span><span style="color: #000000;">e</span><span style="color: #0000FF;">)>=</span><span style="color: #000000;">e2</span> <span style="color: #008080;">then</span> <span style="color: #008080;">exit</span> <span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">while</span>
<span style="color: #7060A8;">mpfr_div</span><span style="color: #0000FF;">(</span><span style="color: #000000;">u</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">u</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">v</span><span style="color: #0000FF;">)</span>
<span style="color: #004080;">string</span> <span style="color: #000000;">su</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">mpfr_get_fixed</span><span style="color: #0000FF;">(</span><span style="color: #000000;">u</span><span style="color: #0000FF;">,</span><span style="color: #000000;">e10</span><span style="color: #0000FF;">)</span>
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"gamma %s (maxerr. 1e-%d)\n"</span><span style="color: #0000FF;">,</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">su</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">e10</span><span style="color: #0000FF;">})</span>
<!--

8
Task/Eulers-constant-0.5772.../Phix/eulers-constant-0.5772...-3.phix Normal file
View file

@ -0,0 +1,8 @@
-->
<span style="color: #008080;">without</span> <span style="color: #008080;">js</span> <span style="color: #000080;font-style:italic;">-- no mpfr_const_euler() in mpfr.js as yet</span>
<span style="color: #7060A8;">requires</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"1.0.1"</span><span style="color: #0000FF;">)</span> <span style="color: #000080;font-style:italic;">-- mpfr_const_euler()</span>
<span style="color: #008080;">include</span> <span style="color: #004080;">mpfr</span><span style="color: #0000FF;">.</span><span style="color: #000000;">e</span>
<span style="color: #004080;">mpfr</span> <span style="color: #000000;">gamma</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">mpfr_init</span><span style="color: #0000FF;">(</span><span style="color: #000000;">0</span><span style="color: #0000FF;">,-</span><span style="color: #000000;">100</span><span style="color: #0000FF;">)</span>
<span style="color: #000000;">mpfr_const_euler</span><span style="color: #0000FF;">(</span><span style="color: #000000;">gamma</span><span style="color: #0000FF;">)</span>
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"gamma %s (mpfr_const_euler)\n"</span><span style="color: #0000FF;">,{</span><span style="color: #7060A8;">mpfr_get_fixed</span><span style="color: #0000FF;">(</span><span style="color: #000000;">gamma</span><span style="color: #0000FF;">,</span><span style="color: #000000;">100</span><span style="color: #0000FF;">)})</span>
<!--

9
Task/Eulers-constant-0.5772.../Picat/eulers-constant-0.5772...-1.picat Normal file
View file

@ -0,0 +1,9 @@
main =>
Gamma = 0.57721566490153286060651209008240,
println(Gamma),
foreach(N in 1..8)
G = e(10**N),
println([n=N,g=G,diff=G-Gamma])
end.
e(N) = [1.0/I : I in 1..N].sum-log(N).

5
Task/Eulers-constant-0.5772.../Picat/eulers-constant-0.5772...-2.picat Normal file
View file

@ -0,0 +1,5 @@
e2(N) = E-log(N) =>
E = 1,
foreach(I in 2..N)
E := E + 1/I
end.

21
Task/Eulers-constant-0.5772.../Picat/eulers-constant-0.5772...-3.picat Normal file
View file

@ -0,0 +1,21 @@
main =>
Gamma = 0.577215664901532860606512090082402,
println(gamma=Gamma),
member(N, 1..23),
G = gamma(N),
println([n=N,g=G,diff=G-Gamma]),
fail,
nl.
gamma(N) = Gamma =>
Gamma = 1/2 - 1/3,
foreach(I in 2..N)
Power = 2**I,
Sign = -1,
Term = 0,
foreach(Denominator in Power..(2*Power-1))
Sign := Sign * -1,
Term := Term + Sign / Denominator
end,
Gamma := Gamma + I*Term
end.

145
Task/Eulers-constant-0.5772.../Processing/eulers-constant-0.5772....processing Normal file
View file

@ -0,0 +1,145 @@
/*********************************************
Subject: Comparing five methods for
computing Euler's constant 0.5772...
// https://rosettacode.org/wiki/Euler%27s_constant_0.5772...
--------------------------------------------*/
double a, b, h, n2, r, u, v;
float floatA, floatB, floatN2;
int k, k2, m, n;
double eps = 1e-6;
void setup() {
size(100, 100);
noLoop();
}
void draw() {
println("From the definition, err. 3e-10\n");
n = 400;
h = 1;
for (int k = 2; k <= n; k++) {
h += 1.0 / k;
}
//faster convergence: Negoi, 1997
a = log(n +.5 + 1.0 / (24*n));
println("Hn ", h);
println("gamma ", h - a);
println("k = ", n);
println("");
println("Sweeney, 1963, err. idem");
n = 21;
double s[] = {0, n};
r = n;
k = 1;
while (r > eps) {
k ++;
r *= (double) n / k;
s[k & 1] = s[k & 1] + r / k;
}
// println("gamma %.16f\nk = %d\n\n", s[1] - s[0] - log(n), k);
println("Hn ", h);
println("gamma ", s[1] - s[0] - log(n));
println("k = ", k);
println("");
println("Bailey, 1988");
n = 5;
floatA = 1;
h = 1;
floatN2 = pow(2, n);
r = 1;
k = 1;
while (abs(floatB - floatA) > eps) {
k += 1;
r *= floatN2 / k;
h += 1.0 / k;
floatB = floatA;
floatA += r * h;
}
floatA *= floatN2 / exp(floatN2);
println("gamma ", floatA - n * log(2));
println("k = ", k);
println("");
println("Brent-McMillan, 1980");
n = 13;
floatA = -log(n);
floatB = 1;
u = a;
v = b;
n2 = n * n;
k2 = 0;
k = 0;
while (abs(floatA) > eps) {
k2 += 2*k + 1;
k += 1;
floatA *= n2 / k;
floatB *= n2 / k2;
floatA = (floatA + floatB) / k;
u += floatA;
v += floatB;
}
println("gamma ", u / v);
println("k ", k);
println("How Euler did it in 1735\n");
//Bernoulli numbers with even indices
double[] B2 = new double[11];
B2[1] = 1.0;
B2[2] = 1.0/6;
B2[3] = -1.0/30;
B2[4] = 1.0/42;
B2[5] = -1.0/30;
B2[6] = 5.0/66;
B2[7] = -691.0/2730;
B2[8] = 7.0/6;
B2[9] = -3617.0/510;
B2[10]= 43867.0/798;
m = 7;
n = 10;
//n-th harmonic number
h = 1;
for (k = 2; k <= n; k++) {
h += 1.0 / k;
}
println("Hn ", h);
h -= log(n);
println(" -ln ", 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);
}
println("");
println("err ", a);
println("gamma ", h + a );
println("k = ", n + m);
println("");
println("C = 0.57721566490153286...\n");
}

17
Task/Eulers-constant-0.5772.../Python/eulers-constant-0.5772....py Normal file
View file

@ -0,0 +1,17 @@
# /**************************************************
# Subject: Computation of Euler's constant 0.5772...
# with Euler's Zeta Series.
# tested : Python 3.11
# -------------------------------------------------*/
from scipy import special as s
def eulers_constant(n):
k = 2
euler = 0
while k <= n:
euler += (s.zeta(k) - 1)/k
k += 1
return 1 - euler
print(eulers_constant(47))

19
Task/Eulers-constant-0.5772.../Racket/eulers-constant-0.5772....rkt Normal file
View file

@ -0,0 +1,19 @@
#lang racket/base
(require math/number-theory
math/base)
gamma.0
;; if you want to work it out the hard way...
(define (H n)
(for/sum ((i n)) (/ (add1 i))))
(define (g #:n (n 10) #:k (k 7))
(+ (- (H n)
(log n)
(/ (* n 2)))
(for/sum ((2k (in-range 2 (* 2 (add1 k)) 2)))
(/ (bernoulli-number 2k) (* (expt n 2k) 2k)))))
(g)

15
Task/Eulers-constant-0.5772.../Raku/eulers-constant-0.5772....raku Normal file
View file

@ -0,0 +1,15 @@
# 20211124 Raku programming solution
sub gamma (\N where N > 1) { # Vacca series https://w.wiki/4ybp
# convert terms to FatRat for arbitrary precision
return (1/2 - 1/3) + [+] (2..N).race.map: -> \n {
my ($power, $sign, $term) = 2**n, -1;
for ($power..^2*$power) { $term += ($sign = -$sign) / $_ }
n*$term
}
}
say gamma 23 ;

2
Task/Eulers-constant-0.5772.../Ruby/eulers-constant-0.5772....rb Normal file
View file

@ -0,0 +1,2 @@
n = 1e6
p (1..n).sum{ 1.0/_1 } - Math.log(n)

23
Task/Eulers-constant-0.5772.../Rust/eulers-constant-0.5772....rust Normal file
View file

@ -0,0 +1,23 @@
// 20220322 Rust programming solution
fn gamma(N: u32) -> f64 { // Vacca series https://w.wiki/4ybp
return 1f64 / 2f64 - 1f64 / 3f64
+ ((2..=N).map(|n| {
let power: u32 = 2u32.pow(n);
let mut sign: f64 = -1f64;
let mut term: f64 = 0f64;
for denominator in power..=(2 * power - 1) {
sign *= -1f64;
term += sign / f64::from(denominator);
}
return f64::from(n) * term;
}))
.sum::<f64>();
}
fn main() {
println!("{}", gamma(23));
}

18
Task/Eulers-constant-0.5772.../Scheme/eulers-constant-0.5772....ss Normal file
View file

@ -0,0 +1,18 @@
; Procedure to compute factorial.
(define fact
(lambda (n)
(if (<= n 0)
1
(* n (fact (1- n))))))
; Compute Euler's gamma constant as the difference of log(n) from a sum.
; See section 2.3 of <http://numbers.computation.free.fr/Constants/Gamma/gamma.html>.
(define gamma
(lambda (n)
(let ((sum 0))
(do ((k 1 (1+ k)))
((> k (* 3.5911 n)) (- sum (log n)))
(set! sum (+ sum (/ (* (expt -1 (1- k)) (expt n k)) (* k (fact k)))))))))
; Show Euler's gamma constant computed at log(100).
(printf "Euler's gamma constant: ~a~%" (gamma 100))

3
Task/Eulers-constant-0.5772.../Sidef/eulers-constant-0.5772...-1.sidef Normal file
View file

@ -0,0 +1,3 @@
# 100 decimals of precision
local Num!PREC = 4*100
say Num.EulerGamma

51
Task/Eulers-constant-0.5772.../Sidef/eulers-constant-0.5772...-2.sidef Normal file
View file

@ -0,0 +1,51 @@
const n = (ARGV ? Num(ARGV[0]) : 50) # number of iterations
define ℯ = Num.e
define π = Num.pi
define γ = Num.EulerGamma
func display(r, t) {
say "#{r}\terror: #{ '%.0g' % abs(r - t) }"
}
# Original definition of the Euler-Mascheroni constant, due to Euler (1731)
display(sum(1..n, {|n| 1/n }) - log(n), γ)
# Formula due to Euler (best convergence)
display(harmfrac(n) - log(n) - 1/(2*n) - sum(1..n, {|k|
-bernoulli(2*k) / (2*k) / n**(2*k)
}), γ)
# Formula derived from the above formula of Euler,
# using approximations of Bernoulli numbers.
display(harmfrac(n) - log(n) - 1/(2*n) - sum(1..n, {|k|
(-1)**k * 4 * sqrt(π*k) * (π * ℯ)**(-2*k) * k**(2*k) / (2*k) / n**(2*k)
}), γ)
# Euler-Mascheroni constant, involving zeta(n)
display(1 - sum(2..(n+1), {|n|
(zeta(n) - 1) / n
}), γ)
# Limit_{n->Infinity} zeta((n+1)/n) - n} = gamma
display(zeta((n+1)/n) - n, γ)
# Series due to Euler (1731).
display(sum(2..(n+1), {|n|
(-1)**n * zeta(n) / n
}), γ)
# Formula due to Euler in terms of log(2) and the odd zeta values
display(3/4 - log(2)/2 + sum(1..n, {|n|
(1 - 1/(2*n + 1)) * (zeta(2*n + 1) - 1)
}), γ)
# Formula due to Euler in terms of log(2) and the odd zeta values (VII)
display(log(2) - sum(1..n, {|n|
zeta(2*n + 1) / (2*n + 1) / 2**(2*n)
}), γ)
# Formula due to Vacca (1910)
display(sum(1..n, {|n|
(-1)**n * floor(log2(n)) / n
}), γ)

98
Task/Eulers-constant-0.5772.../V-(Vlang)/eulers-constant-0.5772....v Normal file
View file

@ -0,0 +1,98 @@
import math
const eps = 1e-6
fn main() {
//.5772
println("From the definition, err. 3e-10")
mut n := 400
mut h := 1.0
for k in 2..n+1 {
h += 1.0/f64(k)
}
//faster convergence: Negoi, 1997
mut a := math.log(f64(n) + 0.5 + 1.0/f64(24*n))
println("Hn ${h:0.16f}")
println("gamma ${h-a:0.16f}\nk = $n\n")
println("Sweeney, 1963, err. idem")
n = 21
mut s := [0.0, f64(n)]
mut r := f64(n)
mut k := 1
for {
k++
r *= f64(n) / f64(k)
s[k & 1] += r/f64(k)
if r <= eps {
break
}
}
println("gamma ${s[1] - s[0] - math.log(n):0.16f}\nk = $k\n")
println("Bailey, 1988")
n = 5
a = 1.0
h = 1.0
mut n2 := math.pow(f64(2),f64(n))
r = 1
k = 1
for {
k++
r *= n2 / f64(k)
h += 1/f64(k)
b := a
a += r * h
if math.abs(b-a) <= eps {
break
}
}
a *= n2 / math.exp(n2)
println("gamma ${a - n * math.log(2):.16f}\nk = $k\n")
println("Brent-McMillan, 1980")
n = 13
a = -math.log(n)
mut b := 1.0
mut u := a
mut v := b
n2 = n * n
mut k2 := 0
k = 0
for {
k2 += 2*k + 1
k++
a *= n2 / f64(k)
b *= n2 / f64(k2)
a = (a + b)/f64(k)
u += a
v += b
if math.abs(a) <= eps {
break
}
}
println("gamma ${u/v:0.16f}\nk = $k\n")
println("How Euler did it in 1735")
// Bernoulli numbers with even indices
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
n = 10
// n'th harmonic number
h = 1.0
for kz in 2..n+1 {
h += 1.0/f64(kz)
}
println("Hn ${h:0.16f}")
h -= math.log(n)
println(" -ln ${h:0.16f}")
// expansion C = -digamma(1)
a = -1.0 / (2.0*f64(n))
n2 = f64(n * n)
r = 1
for kq in 1..m+1 {
r *= n2
a += b2[kq] / (2.0*f64(kq)*r)
}
println("err ${a:0.16f}\ngamma ${h+a:0.16f}\nk = ${n+m}")
println("\nC = 0.57721566490153286...")
}

87
Task/Eulers-constant-0.5772.../Wren/eulers-constant-0.5772...-1.wren Normal file
View file

@ -0,0 +1,87 @@
import "./fmt" for Fmt
var eps = 1e-6
System.print("From the definition, err. 3e-10")
var n = 400
var h = 1
for (k in 2..n) h = h + 1/k
//faster convergence: Negoi, 1997
var a = (n + 0.5 + 1/(24*n)).log
Fmt.print("Hn $0.14f", h)
Fmt.print("gamma $0.14f\nk = $d\n", h - a, n)
System.print("Sweeney, 1963, err. idem")
n = 21
var s = [0, n]
var r = n
var k = 1
while (true) {
k = k + 1
r = r * n / k
s[k & 1] = s[k & 1] + r/k
if (r <= eps) break
}
Fmt.print("gamma $0.14f\nk = $d\n", s[1] - s[0] - n.log, k)
System.print("Bailey, 1988")
n = 5
a = 1
h = 1
var n2 = 2.pow(n)
r = 1
k = 1
while (true) {
k = k + 1
r = r * n2 / k
h = h + 1/k
var b = a
a = a + r * h
if ((b-a).abs <= eps) break
}
a = a * n2 / n2.exp
Fmt.print("gamma $0.14f\nk = $d\n", a - n * 2.log, k)
System.print("Brent-McMillan, 1980")
n = 13
a = -n.log
var b = 1
var u = a
var v = b
n2 = n * n
var k2 = 0
k = 0
while (true) {
k2 = k2 + 2*k + 1
k = k + 1
a = a * n2 / k
b = b * n2 / k2
a = (a + b)/k
u = u + a
v = v + b
if (a.abs <= eps) break
}
Fmt.print("gamma $0.14f\nk = $d\n", u / v, k)
System.print("How Euler did it in 1735")
// Bernoulli numbers with even indices
var b2 = [1, 1/6, -1/30, 1/42, -1/30, 5/66, -691/2730, 7/6, -3617/510, 43867/798]
var m = 7
n = 10
// n'th harmonic number
h = 1
for (k in 2..n) h = h + 1/k
Fmt.print("Hn $0.14f", h)
h = h - n.log
Fmt.print(" -ln $0.14f", h)
// expansion C = -digamma(1)
a = -1 / (2*n)
n2 = n * n
r = 1
for (k in 1..m) {
r = r * n2
a = a + b2[k] / (2*k*r)
}
Fmt.print("err $0.14f\ngamma $0.14f\nk = $d", a, h + a, n + m)
System.print("\nC = 0.57721566490153286...")

44
Task/Eulers-constant-0.5772.../Wren/eulers-constant-0.5772...-2.wren Normal file
View file

@ -0,0 +1,44 @@
import "./gmp" for Mpf
var euler = Fn.new { |n, r, s, t|
// decimal precision
var e10 = (n/0.6).floor
// binary precision
var e2 = ((1 + n/0.6)/0.30103).round
Mpf.defaultPrec = e2
var b = Mpf.new().log(Mpf.from(16).div(15))
var a = b.mul(r)
b = Mpf.new().log(Mpf.from(25).div(24))
a.add(b.mul(s))
b = Mpf.new().log(Mpf.from(81).div(80))
var u = b * t
a.add(u).neg
b.set(1)
u.set(a)
var v = Mpf.from(b)
var k = 0
var n2 = n * n
var k2 = Mpf.zero
while (true) {
k2.add((k << 1) + 1)
k = k + 1
b.mul(n2).div(k2)
a.mul(n2).div(k).add(b).div(k)
u.add(a)
v.add(b)
var e = Mpf.frexp(a)[1]
if (e.abs >= e2) break
}
u.div(v)
System.print("gamma %(u.toString(10, 100)) (maxerr. 1e-%(e10))")
System.print("k = %(k)")
}
var start = System.clock
euler.call(60, 41, 30, 18)
euler.call(4800, 85, 62, 37)
euler.call(9375, 91, 68, 40)
euler.call(18750, 98, 73, 43)
System.print("\nTook %(System.clock - start) seconds.")

5
Task/Eulers-constant-0.5772.../Wren/eulers-constant-0.5772...-3.wren Normal file
View file

@ -0,0 +1,5 @@
import "./gmp" for Mpf
var prec = (101/0.30103).round
var gamma = Mpf.euler(prec)
System.print(gamma.toString(10, 100))

81
Task/Eulers-constant-0.5772.../XPL0/eulers-constant-0.5772....xpl0 Normal file
View file

@ -0,0 +1,81 @@
\*********************************************
\Subject: Comparing five methods for
\ computing Euler's constant 0.5772...
\---------------------------------------------
include xpllib; \for Print
define Epsilon = 1e-6;
real A, B, H, N2, R, U, V, S(2), B2;
int K, K2, M, N;
[Print("From the definition, error 3e-10\n");
N:= 400; H:= 1.;
for K:= 2 to N do
H:= H + 1.0/float(K);
\Faster convergence: Negoi, 1997
A:= Ln(float(N) + 0.5 + 1.0/(24.*float(N)));
Print("Hn %1.16f\n", H);
Print("gamma %1.16f\nK = %d\n\n", H-A, N);
Print("Sweeney, 1963, error 3e-10\n");
N:= 21; S(0):= 0.; S(1):= float(N);
R:= float(N); K:= 1;
repeat
K:= K+1;
R:= R * float(N) / float(K);
S(K&1):= S(K&1) + R/float(K);
until R <= Epsilon;
Print("gamma %1.16f\nK = %d\n\n", S(1)-S(0)-Ln(float(N)), K);
Print("Bailey, 1988\n");
N:= 5; A:= 1.; H:= 1.;
N2:= Pow(2., float(N));
R:= 1.; K:= 1;
repeat
K:= K+1;
R:= R * N2 / float(K);
H:= H + 1.0/float(K);
B:= A; A:= A + R*H;
until abs(B-A) <= Epsilon;
A:= A * N2 / Exp(N2);
Print("gamma %1.16f\nK = %d\n\n", A-float(N)*Ln(2.), K);
Print("Brent-McMillan, 1980\n");
N:= 13; A:= -Ln(float(N));
B:= 1.; U:= A; V:= B;
N2:= float(N*N); K2:= 0; K:= 0;
repeat
K2:= K2 + 2*K + 1;
K:= K+1;
A:= A * N2 / float(K);
B:= B * N2 / float(K2);
A:= (A + B) / float(K);
U:= U + A;
V:= V + B;
until abs(A) <= Epsilon;
Print("gamma %1.16f\nK = %d\n\n", U/V, K);
Print("How Euler did it in 1735\n");
\Bernoulli numbers with even indices
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; N:= 10;
\Nth harmonic number
H:= 1.;
for K:= 2 to N do
H:= H + 1.0/float(K);
Print("Hn %1.16f\n", H);
H:= H - Ln(float(N));
Print(" -ln %1.16f\n", H);
\Expansion C:= -digamma(1)
A:= -1.0 / (2.*float(N));
N2:= float(N*N);
R:= 1.;
for K:= 1 to M do [
R:= R * N2;
A:= A + B2(K)/(2.*float(K)*R);
];
Print("err %1.16f\ngamma %1.16f\nK = %d", A, H+A, N+M);
Print("\n\nC = 0.57721566490153286...\n");
]