Rosetta Code

Arithmetic-geometric mean/Calculate Pi: Difference between revisions

Page Discussion

Arithmetic-geometric mean/Calculate Pi (view source)

Revision as of 01:37, 25 January 2024

5,670 bytes added ,  3 months ago
→‎{{header|MATLAB}}: fix typo
(Add TI SR-56 solution)
(9 intermediate revisions by 9 users not shown)
Line 18:
 
The purpose of this task is to demonstrate how to use this approximation in order to compute a large number of decimals of <math>\pi</math>.
 
=={{header|BASIC}}==
==={{header|BASIC256}}===
<syntaxhighlight lang="basic">digits = 500
an = 1.0
bn = sqr(0.5)
tn = 0.5 ^ 2
pn = 1.0
 
while pn <= digits
prevAn = an
an = (bn + an) / 2
bn = sqr(bn * prevAn)
prevAn -= an
tn -= (pn * prevAn ^ 2)
pn *= 2
end while
print ((an + bn) ^ 2) / (tn * 4)</syntaxhighlight>
 
==={{header|FreeBASIC}}===
<syntaxhighlight lang="vb">Dim As Short digits = 500
Dim As Double an = 1
Dim As Double bn = Sqr(0.5)
Dim As Double tn = 0.5^2
Dim As Double pn = 1
Dim As Double prevAn
 
While pn <= digits
prevAn = an
an = (bn + an) / 2
bn = Sqr(bn * prevAn)
prevAn -= an
tn -= (pn * prevAn^2)
pn *= 2
Wend
Dim As Double pi = ((an + bn)^2) / (tn * 4)
Print pi
 
Sleep</syntaxhighlight>
{{out}}
<pre>3.141592653589794</pre>
 
==={{header|IS-BASIC}}===
<syntaxhighlight lang="is-basic">100 PROGRAM "PI.bas"
110 LET DIGITS=10
120 LET AN,PN=1
130 LET BN=SQR(.5)
140 LET TN=.5^2
150 DO WHILE PN<=DIGITS
160 LET PREVAN=AN
170 LET AN=(BN+AN)/2
180 LET BN=SQR(BN*PREVAN)
190 LET PREVAN=PREVAN-AN
200 LET TN=TN-(PN*PREVAN^2)
210 LET PN=PN+PN
220 LOOP
230 PRINT (AN+BN)^2/(TN*4)</syntaxhighlight>
 
==={{header|True BASIC}}===
{{works with|QBasic}}
<syntaxhighlight lang="qbasic">LET digits = 500
LET an = 1.0
LET bn = SQR(0.5)
LET tn = 0.5 ^ 2
LET pn = 1.0
 
DO WHILE pn <= digits
LET prevAn = an
LET an = (bn + an) / 2
LET bn = SQR(bn * prevAn)
LET prevAn = prevAn - an
LET tn = tn - (pn * prevAn ^ 2)
LET pn = pn + pn
LOOP
PRINT ((an + bn) ^ 2) / (tn * 4)
END</syntaxhighlight>
 
==={{header|Yabasic}}===
<syntaxhighlight lang="basic">digits = 500
an = 1.0
bn = sqrt(0.5)
tn = 0.5 ^ 2
pn = 1.0
 
while pn <= digits
prevAn = an
an = (bn + an) / 2
bn = sqrt(bn * prevAn)
prevAn = prevAn - an
tn = tn - (pn * prevAn ^ 2)
pn = pn + pn
wend
print ((an + bn) ^ 2) / (tn * 4)</syntaxhighlight>
 
=={{header|C}}==
Line 489 ⟶ 582:
3.141592653589793238...81377399510065895288
</pre>
=={{header|EasyLang}}==
{{trans|FreeBASIC}}
<syntaxhighlight lang=easylang>
an = 1
bn = sqrt 0.5
tn = 0.25
pn = 1
while pn <= 5
prevAn = an
an = (bn + an) / 2
bn = sqrt (bn * prevAn)
prevAn -= an
tn -= (pn * prevAn * prevAn)
pn *= 2
.
mypi = (an + bn) * (an + bn) / (tn * 4)
numfmt 15 0
print mypi
</syntaxhighlight>
 
=={{header|Erlang}}==
{{trans|python}}
Line 569 ⟶ 682:
Iteration: 4 Diff: 3.05653257536554156111405386493810661E-0010 Pi: 3.14159265358979323846636060270664556
Iteration: 5 Diff: 3.71721942712928151094186846648146566E-0021 Pi: 3.14159265358979323846264338327951628
</pre>
 
=={{header|FutureBasic}}==
<syntaxhighlight lang="futurebasic">
 
double a, c, g, t, p
double apprpi
short i
 
// Initial values
a = 1
g = sqr(0.5)
p = 1
t = 0.25
 
//Iterate just 3 times
for i = 1 to 3
c = a
a = ( a + g ) / 2
g = sqr( c * g )
c -= a
t -= ( p * c^2 )
p *= 2
apprpi = (( a + g )^2) / ( t * 4 )
print "Iteration "i": ", apprpi
next
 
print "Actual value:",pi
 
handleevents
 
</syntaxhighlight>
{{output}}
<pre>
Iteration 1: 3.140579250522169
Iteration 2: 3.141592646213543
Iteration 3: 3.141592653589794
Actual value: 3.141592653589793
</pre>
 
Line 948 ⟶ 1,099:
pi[7, 100]
3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628046852228654</syntaxhighlight>
 
=={{header|MATLAB}}==
{{trans|Julia}}
<syntaxhighlight lang="MATLAB">
 
clear all;close all;clc;
testMakePi();
 
 
function [a, g] = agm1step(x, y)
a = (x + y) / 2;
g = sqrt(x * y);
end
 
function [a, g, s, k] = approxPiStep(x, y, z, n)
[a, g] = agm1step(x, y);
k = n + 1;
s = z + 2^(k + 1) * (a^2 - g^2);
end
 
function pi_approx = approxPi(a, g, s)
pi_approx = 4 * a^2 / (1 - s);
end
 
function testMakePi()
digits(512); % Set the precision for variable-precision arithmetic
a = vpa(1.0);
g = 1 / sqrt(vpa(2.0));
s = vpa(0.0);
k = 0;
oldPi = vpa(0.0);
% Define a small value as a threshold for convergence
convergence_threshold = vpa(10)^(-digits);
 
fprintf(' k Error Result\n');
for i = 1:100
[a, g, s, k] = approxPiStep(a, g, s, k);
estPi = approxPi(a, g, s);
if abs(estPi - oldPi) < convergence_threshold
break;
end
oldPi = estPi;
err = abs(vpa(pi) - estPi);
fprintf('%4d%10.1e', i, double(err));
fprintf('%70.60f\n', double(estPi));
end
end
</syntaxhighlight>
{{out}}
<pre>
k Error Result
1 4.6e-02 3.187672642712108483920019352808594703674316406250000000000000
2 8.8e-05 3.141680293297653303596916884998790919780731201171875000000000
3 3.1e-10 3.141592653895446396461466065375134348869323730468750000000000
4 3.7e-21 3.141592653589793115997963468544185161590576171875000000000000
5 5.5e-43 3.141592653589793115997963468544185161590576171875000000000000
6 1.2e-86 3.141592653589793115997963468544185161590576171875000000000000
7 5.8e-174 3.141592653589793115997963468544185161590576171875000000000000
8 0.0e+00 3.141592653589793115997963468544185161590576171875000000000000
9 0.0e+00 3.141592653589793115997963468544185161590576171875000000000000
</pre>
 
=={{header|МК-61/52}}==
Line 961 ⟶ 1,173:
=={{header|Nim}}==
{{libheader|bignum}}
{{Trans|DelphyDelphi}}
<syntaxhighlight lang="nim">from math import sqrt
import times
Line 1,605 ⟶ 1,817:
1004 3.141...201989381
1005 3.141...2019893810</pre>
 
=={{header|RPL}}==
{{trans|BASIC}}
{{works with|Halcyon Calc|4.2.7}}
{| class="wikitable"
! RPL code
! Comment
|-
|
≪ → digits
≪ 0.5 SQ 1 1 0.5 √
'''WHILE''' 3 PICK digits ≤ '''REPEAT'''
OVER
ROT 3 PICK + 2 / ROT ROT
SWAP OVER * √ SWAP
3 PICK -
5 ROLL SWAP SQ 5 PICK * - 4 ROLLD
ROT DUP + ROT ROT
'''END'''
+ SQ ROT 4 * /
SWAP DROP
≫ ≫ ‘'''AGMPI'''’ STO
≪ { } 1 5 FOR d d '''AGMPI''' NEXT
≫ ‘'''TASK'''’ STO
|
'''AGMPI''' ''( digits -- pi )''
tn = 0.5 ^ 2 : pn = 1.0 : an = 1.0 : bn = sqrt(0.5)
while pn <= digits
prevAn = an
an = (bn + an) / 2
bn = sqrt(bn * prevAn)
prevAn = prevAn - an
tn = tn - (pn * prevAn ^ 2)
pn = pn + pn
wend
print ((an + bn) ^ 2) / (tn * 4)
// clean stack
|}
{{out}}
<pre>
5: 2.91421356238
4: 3.14057925053
3: 3.14159264619
2: 3.14159264619
1: 3.14159265359
</pre>
 
=={{header|Ruby}}==
Line 1,869 ⟶ 2,132:
| 02 00 || 0 || 27 94 || = || 52 01 || 1 || 77 ||
|-
| 03 01 || 1 || 28 32 || x><yt|| 53 43 || x² || 78 ||
|-
| 04 33 || STO || 29 64 || * || 54 54 || / || 79 ||
Line 1,885 ⟶ 2,148:
| 10 20 || *1/x || 35 02 || 2 || 60 01 || 1 || 85 ||
|-
| 11 33 || STO || 36 32 || x><yt|| 61 08 || 8 || 86 ||
|-
| 12 02 || 2 || 37 74 || - || 62 41 || R/S || 87 ||
Line 1,905 ⟶ 2,168:
| 20 84 || + || 45 35 || SUM || 70 || || 95 ||
|-
| 21 32 || x><yt || 46 03 || 3 || 71 || || 96 ||
|-
| 22 34 || RCL || 47 94 || = || 72 || || 97 ||
Line 1,930 ⟶ 2,193:
2 √x 1/x STO 2 // r2 = g0
. 2 5 STO 4 // r4 = 0.25
RCL 1 + x><yt RCL 2 = / 2 = // t = a0, x = a1
x><yt * RCL 2 = √x STO 2 // t = a1, r2 = g1
x><yt - EXC 1 = // x = (a1 - a0), r1 = a1
x² * RCL 3 SUM 3 = INV SUM 4 // r4 = r4-r3(a1-a0)^2, r3 = r3*2
RCL 1 x² / RCL 4 = pause
Line 1,964 ⟶ 2,227:
{{trans|Sidef}}
{{libheader|Wren-big}}
<syntaxhighlight lang="ecmascriptwren">import "./big" for BigRat
 
var digits = 500
Aspen138
337

edits

Retrieved from "https://rosettacode.org/wiki/Special:MobileDiff/335456...352279"