Arithmetic-geometric mean/Calculate Pi: Difference between revisions

{{task}}

[http://www.maa.org/sites/default/files/pdf/upload_library/22/Ford/Almkvist-Berndt585-608.pdf Almkvist Berndt 1988] begins with an investigation of why the agm is such an efficient algorithm, and proves that it converges quadratically. This is an efficient method to calculate <math>\pi</math>.

<!-- Example by Nigel Galloway, Feb 8, 2012 -->

{{libheader|GMP}}

void agm (const mpf_t in1, const mpf_t in2, mpf_t out1, mpf_t out2) {

=={{header|C sharp|C#}}==

using System.Numerics;

{{trans|C}}

{{libheader|GMP}}

#include <chrono>

=={{header|Clojure}}==

{{trans|Ruby}}

(:use [criterium.core])

(:gen-class))

{{libheader|MMA}}

<p>This is an example that uses the Common Lisp Bigfloat Package (http://www.cs.berkeley.edu/~fateman/lisp/mma4max/more/bf.lisp)</p>

;;(setf mma::bigfloat-bin-prec 1000)

=={{header|D}}==

{{trans|C#}}

import std.conv;

import std.math;

Thanks for Velthuis BigIntegers library[https://github.com/rvelthuis/DelphiBigNumbers].

{{Trans|C#}}

program Calculate_Pi;

=={{header|Erlang}}==

{{trans|python}}

-module(pi).

-export([agmPi/1, agmPiBody/5]).

{{libheader|iso_fortran_env}}

{{trans|Julia}}

! Use real128 numbers: (append '_rf')

use iso_fortran_env, only: rf => real128

=={{header|Go}}==

import (

=={{header|Groovy}}==

{{trans|Java}}

class CalculatePi {

{{libheader|MPFR}}

{{libheader|hmpfr}}

import Data.Number.MPFR hiding (sqrt, pi, div)

import Data.Number.MPFR.Instances.Near ()

[https://code.jsoftware.com/wiki/Essays/Extended%20Precision%20Functions Extended precision functions] and [https://code.jsoftware.com/wiki/Essays/Chudnovsky_Algorithm Pi].

Translated from python:

round=: DP&$: : (4 : 0)

1583455951826865080542496790424338362837978447536228171662934224565463064033895909488933268392567279887495006936541219489670405121434573776487989539520749180843985094860051126840117004097133550161882511486508109869673199973040182062140382647367514024790194...</pre>

3.1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253421170679</syntaxhighlight>

3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342117067982148086513</syntaxhighlight>

{{trans|Kotlin}}

Used features of Java 8

import java.math.MathContext;

import java.util.Objects;

`rsqrt` function

for taking square roots of rationals; such a module can be found at [[Arithmetic/Rational]].

def pi(precision):

=={{header|Julia}}==

agm1step(x, y) = (x + y) / 2, sqrt(x * y)

=={{header|Kotlin}}==

import java.math.MathContext

With 16 steps we have 89415 correct digits:

local a:=1,g:=evalf(sqrt(1/2)),s:=0,p:=4,i;

for i to n do

=={{header|Mathematica}}/{{header|Wolfram Language}}==

Module[{a = 1, g = N[1/Sqrt[2], prec], k, s = 0, p = 4},

For[k = 1, k < n, k++,

=={{header|МК-61/52}}==

{{Output?}}

^ 4 / П3 ИП3 ИП1 ИП2 + 2 /

П5 ИП1 - x^2 ИП4 * - П3 ИП1 ИП2

{{libheader|bignum}}

{{Trans|Delphy}}

import times

=={{header|OCaml}}==

program for calculating digits of pi

let x = Array.make (n+1) 2000

=={{header|PARI/GP}}==

pi(6)</syntaxhighlight>

{{out}}

The number of steps used is based on the desired accuracy rather than being hard coded, as this is intended to work for 1M digits as well as for 100.

my $digits = shift || 100; # Get number of digits from command line

The following is a translation, almost line-for-line, of the Ruby code. It is slower than the above and the last digit or two may not be correct.

{{trans|Ruby}}

use warnings;

use Math::BigFloat;

{{libheader|Phix/mpfr}}

{{trans|Python}}

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #7060A8;">requires</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"1.0.0"</span><span style="color: #0000FF;">)</span> <span style="color: #000080;font-style:italic;">-- (mpfr_set_default_prec[ision] has been renamed)</span>

=={{header|PicoLisp}}==

{{trans|Python}}

(de pi ()

=={{header|Python}}==

{{trans|Ruby}}

D = Decimal

{{libheader|Rmpfr}}

agm <- function(n, prec) {

=={{header|Racket}}==

{{trans|Ruby}}

(require math/bigfloat)

Notice that we don't get the exact number of decimals required : the last two decimals or so can be wrong. This is because we don't need <math>a_n</math>, but rather <math>a_n^2</math>. Elevating to the square makes us lose a bit of precision. It could be compensated by choosing a slightly higher value of N (in a way that could be precisely calculated), but that would probably be overkill.

multi sqrt(Int $n) {

Whatever number of digits used, the actual number of digits is five larger than specified, and then the result is rounded to the requested number of digits.

===version 1===

parse arg d .; if d=='' | d=="," then d= 500 /*D not specified? Then use default. */

numeric digits d+5 /*set the numeric decimal digits to D+5*/

For 1,005 decimal digits, &nbsp; it is over &nbsp; '''68''' &nbsp; times faster than version 3.

parse arg a b digs . /*obtain optional numbers from the C.L.*/

if digs=='' | digs=="," then digs= 100 /*No DIGS specified? Then use default.*/

===version 3===

/*REXX*/

Using agm.

See [[Talk:Arithmetic-geometric mean]]

#

#

=={{header|Rust}}==

pub fn pi(n: usize) -> f64 {

let mut a : f64 = 1.0;

</syntaxhighlight>

Can be invoked like:

fn main() {

println!("pi(7): {}", pi(7));

=={{header|Scala}}==

===Completely (tail) recursive===

import scala.annotation.tailrec

=={{header|Sidef}}==

var acc = (digits + 8);

{{trans|Ruby}}

{{tcllib|math::bigfloat}}

namespace import math::bigfloat::*

{{trans|C#}}

{{Libheader|System.Numerics}}

Module Program

{{trans|Sidef}}

{{libheader|Wren-big}}

var digits = 500

3.14159265358979323846264338327950288419716939937510582097494459230781640628620899862803482534211706798214808651328230664709384460955058223172535940812848111745028410270193852110555964462294895493038196442881097566593344612847564823378678316527120190914564856692346034861045432664821339360726024914127372458700660631558817488152092096282925409171536436789259036001133053054882046652138414695194151160943305727036575959195309218611738193261179310511854807446237996274956735188575272489122793818301194912

</pre>