Pi: Difference between revisions

Related Task [[Arithmetic-geometric mean/Calculate Pi]]

<br><br>

 

=={{header|360 Assembly}}==

{{trans|FORTRAN}}

The program uses one ASSIST macro (XPRNT) to keep the code as short as possible.

PISPIG CSECT

USING PISPIG,R13 base register

NBUF EQU 201 number of 5 decimals

NVECT EQU 3350 nvect=ceil(nbuf*50/3)

{{out}}

<pre>

uses same algorithm as Go solution, from http://web.comlab.ox.ac.uk/people/jeremy.gibbons/publications/spigot.pdf

;pi_digits.adb:

with Ada.Text_IO;

with GNU_Multiple_Precision.Big_Integers;

end if;

Print_Pi (N);

output:

<pre> 3 1 4 1 5 9 2 6 5 3 5 8 9 7 9 3 2 3 8 4 6 2 6 4 3 3 8 3 2 7 9 5 0 2 8 8 4 1 9 7 1 6 9 3 9 9 3 7 5 1 0 5 8 2 0 9 7 4 9 4 4 5 9 2 3 0 7 8 1 6 4 0 6 2 8 6 2 0 8 9 9 8 6 2 8 0 3 4 8 2 5 3 4 2 1 1 7 0 6 7</pre>

{{wont work with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release [http://sourceforge.net/projects/algol68/files/algol68toc/algol68toc-1.8.8d/algol68toc-1.8-8d.fc9.i386.rpm/download 1.8-8d] - due to extensive use of '''format'''[ted] ''transput''.}}

This codes uses 33 decimals places as a test case. Performance is O(2) based on the number of decimal places required.

 

INT base := 10;

# OD #);

print(new line)

Output:

<pre>

3141592653589793238462643383279502

</pre>

 

=={{header|AutoHotkey}}==

{{libheader|MPL}}

Could be optimized with Ipp functions, but runs fast enough for me as-is. Does not work in AHKLx64.

#SingleInstance, Force

SetBatchLines, -1

, MP_CPY(r, nr)

}

 

=={{header|BASIC}}==

 

20 N = 100: REM N MAY BE INCREASED, BUT WILL SLOW EXECUTION

30 LN = INT(10*N/3)+16

550 RETURN

 

==={{header|Atari 8-bit}}===

20 N = 100: REM N MAY BE INCREASED, BUT WILL SLOW EXECUTION

30 LN = INT(10*N/3)+16

530 ND = 0

550 RETURN

 

 

==={{header|BASIC256}}===

{{Trans|Pascal}} below, and originally published by Stanley Rabinowitz in [http://www.mathpropress.com/stan/bibliography/spigot.pdf].

 

n =1000

print d;

end if

 

Output:

3.14159265358979323846264338327950288419716939937510582097494459230781...

</pre>

 

==={{header|Commodore BASIC}}===

This works with Commodore Basic V2

 

20 N = 100: REM N MAY BE INCREASED, BUT WILL SLOW EXECUTION

30 LN = INT(10*N/3)+16

410 N9 = 0

450 NEXT J

470 END

480 REM

490 REM OUTPUT DIGITS

510 IF D=0 THEN RETURN

530 ND = 0

550 RETURN

 

==={{header|Integer Basic}}===

Integer version was derived from the Pascal_spigot without any optimisation. It is more than 33% faster than the Applesoft version since it runs natively with integers.

 

100 N=100: REM MAX N=260 TO AVOID OVERFLOW

110 LEN=(10*N)/3

1080 IF I>0 THEN GOTO 1040

1090 RETURN

 

 

Osborne 1 program is slightly different to allow it to keep the numbers all on the main screen rather than scrolling off to the right...

 

15 CR=0

20 N = 100: REM N MAY BE INCREASED, BUT WILL SLOW EXECUTION

530 ND = 0

550 RETURN

 

==={{header|TRS-80 Model 4 BASIC}}===

 

20 N = 100: REM N MAY BE INCREASED, BUT WILL SLOW EXECUTION

30 LN = INT(10*N/3)+16

530 ND = 0

550 RETURN

 

=={{header|BBC BASIC}}==

===BASIC version===

M% = (HIMEM-END-1000) / 4

DIM B%(M%)

E% = D% MOD 100 : L% = 2

ENDCASE

 

===Assembler version===

{{works with|BBC BASIC for Windows}}

The first 250,000 digits output have been verified.

[OPT 2 :.pidig mov ebp,eax :.pi1 imul edx,ecx : mov eax,[ebx+ecx*4]

imul eax,100 : add eax,edx : cdq : div ebp : mov [ebx+ecx*4],edx

E% = D% MOD 100 : L% = 2

ENDCASE

'''Output:'''

<pre>

{{works with|GNU bc}}

{{works with|OpenBSD bc}}

 

scaleinc= 20

scale= wantscale

oldpi= pi / 1

Output:

<pre>

=={{header|Bracmat}}==

{{trans|Icon_and_Unicon}}

= f,q r t k n l,first

. !arg:((=?f),?q,?r,?t,?k,?n,?l)

)

)

Output:

<pre>3.1415926535897932384626433832795028841971693993751058209749445923078164062

 

Using Machin's formula. The "continuous printing" part is silly: the algorithm really calls for a preset number of digits, so the program repeatedly calculates Pi digits with increasing length and chop off leading digits already displayed. But it's still faster than the unbounded Spigot method by an order of magnitude, at least for the first 100k digits.

#include <stdlib.h>

#include <gmp.h>

 

return 0;

 

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

 

using System.Numerics;

 

}

}

 

Adopted Version:

using System.Collections.Generic;

using System.Linq;

}

}

=========================================================================

Decimal : 141592653589793238462643383279502884197169399375105820974944

Dwords : 243f6a88 85a308d3 13198a2e 03707344 a4093822 299f31d0

=========================================================================

 

=={{header|Clojure}}==

{{Trans|Python}}

(:gen-class))

 

(println))

(print q))

{{Output}}

<pre>

 

=={{header|Common Lisp}}==

(labels

((g (q r t1 k n l)

(* t1 l)))

(+ l 2))))))

{{out}}

<pre>CL-USER> (pi-spigot)

=={{header|Crystal}}==

{{trans|Ruby}}

 

def pi

 

pi { |digit_or_dot| print digit_or_dot; STDOUT.flush }

{{out}}

<pre>

=={{header|D}}==

This modified [[wp:Spigot_algorithm|Spigot algorithm]] does not continue infinitely, because its required memory grow as the number of digits need to print.

 

struct PiDigits {

foreach (d; PiDigits(100))

writeln(d);

<pre>314159265

358979323

534211706</pre>

===Alternative version===

 

void main() {

}

}

<pre>3.141592653589793238462643383279502884197169399375105820974944592307816

4062862089986280348253421170679821480865132823066470938446095505822317

 

introcs dot cs dot princeton dot edu slash java slash data slash pi-10million.txt

unit Pi_BBC_Main;

 

 

end.

{{out}}

<pre>

With only a few changes (noted in the comments), the same code can be used to

output the first 2070 digits of e.

[EDSAC program, Initial Orders 2.

Calculates digits of pi by spigot algorithm.

E 11 Z [define entry point]

P F [acc = 0 on entry]

{{out}}

<pre>

=={{header|Elixir}}==

{{trans|Erlang}}

def calc, do: calc(1,0,1,1,3,3,0)

end

 

 

{{out}}

 

=={{header|Erlang}}==

-module(pi_calculation).

-export([main/0]).

end

end.

{{out}}

<pre>31415926535897932384626433832795028841971693993751

 

=={{header|F_Sharp|F#}}==

{{trans|Haskell}}

if 4I*q+r-t < n*t

then

Seq.take 1 π |> Seq.iter (printf "%A.")

// 6 digits beginning at position 762 of π are '9'

{{out}}

 

=={{header|Factor}}==

{{trans|Oforth}}

IN: rosetta-code.pi

 

] forever ;

 

 

=={{header|Fortran}}==

This is a modernized version of the example Fortran programme written by S. Rabinowitz in 1991. It works in base 100000 and the key step is the initialisation of all elements of VECT to 2. The format code of I5.5 means I5 output but with all leading spaces made zero so that 66 comes out as "00066", not " 66".

 

program pi

implicit none

write (*,'(i2,"."/(1x,10i5.5))') buffer

end program pi

The output is accumulated in BUFFER then written in one go at the end, but it could be written as successive values as each is calculated without much extra nitpickery: instead of <code>BUFFER(N) = MORE + K</code> for example just <code>WRITE (*,"(I5.5)") MORE + K</code> and no need for array BUFFER.

<pre>

This is an alternate version using an unbounded spigot. Higher precision is accomplished by using the Fortran Multiple Precision

Library, FMLIB (http://myweb.lmu.edu/dmsmith/fmlib.html), provided by Dr. David M. Smith (dsmith@lmu.edu), Mathematics Professor (Emeritus) at Loyola Marymount University. We use the default precision which is about 50 significant digits.

!================================================

program pi_spigot_unbounded

 

end program

 

=={{header|FreeBASIC}}==

{{libheader|GMP}}

' compile with: fbc -s console

 

mpz_set(r, tmp2)

End If

{{out}}

<pre>3.

The code for <code>compute_pi()</code> is from [http://www.cs.ox.ac.uk/people/jeremy.gibbons/publications/spigot.pdf]. The number of digits may be given on the command line as an argument. If there's no argument, the program will run until interrupted.

 

def g( q, r, t, k, n, l ) =

if 4*q + r - t < n*t

print( d )

 

 

=={{header|FutureBasic}}==

 

xref mf(_maxLong - 1) as long

xref ms(_maxLong - 1) as long

end globals

 

local mode

local fn FmtStr( nn as long, s as Str255 ) as Str255

end fn = f

 

local mode

local fn FmtInt( nn as long, s as Str255 ) as Str255

end fn = fn FmtStr( nn, s )

 

 

local fn yprint( m as long )

col = 1

col1++

else

end if

 

 

wend

end if

 

 

local mode

local fn shift( l1 as ^long, l2 as ^long, lp as long, lmod as long )

 

 

local fn Main( nDig as long )

mf(i) = mf(i) * 10

ms(i) = ms(i) * 10

i++

wend

temp = 2 * i - 1

fn shift( @mf(i - 1), @mf(i), temp - 2, temp * kf )

i--

wend

 

 

 

 

 

Output:

4411010446 8232527162 0105265227 2111660396

Done

 

</pre>

Code below is a simplistic translation of Haskell code in [http://web.comlab.ox.ac.uk/oucl/work/jeremy.gibbons/publications/spigot.pdf Unbounded Spigot Algorithms for the Digits of Pi]. This is the algorithm specified for the [http://shootout.alioth.debian.org/u64q/performance.php?test=pidigits pidigits] benchmark of the [http://shootout.alioth.debian.org/ Computer Language Benchmarks Game].

(The standard Go distribution includes [http://golang.org/test/bench/shootout/pidigits.go source] submitted to the benchmark site, and that code runs stunning faster than the code below.)

 

import (

}

}

 

=={{header|Groovy}}==

{{trans|Java}}

Solution:

String nn

boolean first = true

: ['' , first, q*k , (2*q + r)*l , t*l, k + 1, (q*(7*k + 2) + r*l)/(t*l), l + 2]

print nn

 

Output (thru first 1000 iterations):

=={{header|Haskell}}==

The code from [http://www.cs.ox.ac.uk/people/jeremy.gibbons/publications/spigot.pdf]:

where

g (q, r, t, k, n, l) =

, k + 1

, div (q * (7 * k + 2) + r * l) (t * l)

 

===Complete command-line program===

{{Works with|GHC|7.4.1}}

 

 

import Control.Monad

main = do

hSetBuffering stdout $ BlockBuffering $ Just 80

 

{{out}}

===Quicker, Unverified Algorithm ===

Snippet verbatim from source .pdf:

g(q,r,t,i) = let (u,y)=(3*(3*i+1)*(3*i+2),div(q*(27*i-12)+5*r)(5*t))

This is more efficient because each term converges in less than one step, so no checking needs to be done partway through the iteration. Only caveat is that the convergence is ''on average'' slightly over one digit, so there is a chance that, if one checked enough digits, one may find a gap where a digit would be incorrect. Though it seems to be OK for the first 100k digits, or so.

 

=={{header|Icon}} and {{header|Unicon}}==

{{Trans|PicoLisp}} based on Jeremy Gibbons' Haskell solution.

first := "yes"

repeat { # infinite loop

procedure main ()

every (writes (pi (1,0,1,1,3,3)))

 

=={{header|J}}==

end.

Example use:

3

.

5

3

 

=={{header|Java}}==

{{trans|Icon}}

 

public class Pi {

p.calcPiDigits() ;

}

 

Output :

process.stdout.write will work in Node.js; to make this work in a browser, change it to document.body.textContent += .

 

for (;;) {

let y = (q*(27n*i-12n)+5n*r)/(5n*t);

process.stdout.write(y.toString());

if (i === 3n) { process.stdout.write('.'); }

 

=== Web Page version ===

This shows how to load the previous code into a webpage that writes digits out without freezing the browser

 

<body style="width: 100%"><tt id="pi"></tt><tt>...</tt>

<script async defer>

calcPi();

</script>

=== Simple Approximation ===

Returns an approximation of Pi.

 

var n = 20000;

var pi = 0;

}

return pi;

 

=={{header|jq}}==

 

The annotation defined here results in a triple for each digit of pi:

the strings in the six-dimensional state vector, [q, r, t, k, n, l].

The output shows that the space requirements of the Gibbons

spigot grow very slightly more than linearly.

 

 

def pi_spigot:

;

 

{{out}}

<div style="overflow:scroll; height:200px;">

[0,9,"3"]

[1,14,"1"]

[302,8623,"2"]

...

 

=={{header|Julia}}==

Julia comes with built-in support for computing π in arbitrary precision (using the GNU MPFR library). This implementation computes π at precisions that are repeatedly doubled as more digits are needed, printing one digit at a time and never terminating (until it runs out of memory) as specified:

while true

if digit > lastindex(spi)

digit += 1

end

 

Output:

=={{header|Kotlin}}==

{{trans|Java}}

 

import java.math.BigInteger

}

 

 

{{out}}

3.14159265358979323846264338327950288419716939937510582097494459230781640628620899862803482534211706798214808651328230664709384460955058223172535940812848111745...

</pre>

 

=={{header|Lasso}}==

Based off [http://crypto.stanford.edu/pbc/notes/pi/code.html Dik T. Winter's C implementation of Beeler et al. 1972, Item 120].

define generatePi => {

loop(200) => {

stdout(#pi_digits())

Output (first 100 places):

<pre>3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342117067

=={{header|Liberty BASIC}}==

Pretty slow if you run for over 100 digits...

 

q = 1

wend

 

<pre>

3.141592653589793238462643383279502884197

=={{header|Lua}}==

{{trans|Pascal}}

n = 1000

len = math.modf( 10 * n / 3 )

end

end

<pre>03141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342117067982148086 ...</pre>

 

 

 

Module Checkpi {

Module FindPi(Digits){

Modules ? ' current module exist

Stack ' Stack of values ' has to be empty, we didn't use current stack for values.

 

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

User can interrupt computation using "Alt+." or "Cmd+." on a Mac.

For[i = -1, True, i--,

 

<pre>

</pre>

<pre>

 

 

=={{header|NetRexx}}==

{{trans|Java}}

options replace format comments java crossref symbols binary

import java.math.BigInteger

return

 

method runSample(arg) private static

parse arg places .

method isFalse() private static returns boolean

return \isTrue()

{{out}}

<pre>

=={{header|Nim}}==

{{libheader|bigints}}

 

var

echo ""

i = 0

 

{{out}}

{{trans|D}}

{{libheader|bignum}}

 

proc calcPi() =

r = nr

 

 

{{out}}

=={{header|OCaml}}==

The Constructive Real library [http://www.lri.fr/~filliatr/creal.en.html Creal] contains an infinite-precision Pi, so we can just print out its digits.

 

let block = 100 in

flush stdout;

incr counter

However that is cheating if you want to see an algorithm to generate Pi. Since the Spigot algorithm is already used in the [http://benchmarksgame.alioth.debian.org/u64q/program.php?test=pidigits&lang=ocaml&id=1 pidigits] program, this implements [http://mathworld.wolfram.com/Machin-LikeFormulas.html Machin's formula].

 

(* series for: c*atan(1/k) *)

incr npr; shift := !shift */ base;

) else (acc := !acc */ d_acc);

 

=={{header|Oforth}}==

 

| q r t k n l |

1 ->q 0 ->r 1 ->t 1 ->k 3 ->n 3 -> l

k 1+ ->k

]

 

=={{header|Ol}}==

{{trans|Scheme}}

 

; 'numbers' is count of numbers or #false for eternal pleasure.

(define (pi numbers)

 

(pi #false)

{{out}}

<pre>

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

Uses the built-in Brent-Salamin arithmetic-geometric mean iteration.

my(x=Pi,n=0,t);

print1("3.");

print1(floor(x*10^n++)%10)

)

 

=={{header|Pascal}}==

With minor editing changes as published by Stanley Rabinowitz in [http://www.mathpropress.com/stan/bibliography/spigot.pdf].

Minor improvement of <user>Mischi</user> { speedup ~2 ( n=10000 , rumtime 4s-> 1,44s fpc 2.6.4 -O3 }, by calculating only necessary digits up to n.

const

n = 1000;

end;

writeln(predigit);

Output:

<pre>% ./Pi_Spigot

This takes a numer-of-digits argument, but we can make it large (albeit using memory and some startup time). Unlike the other two, this uses no modules and does not require bigints so is worth showing.

 

my $digits = shift;

my(@out, @a);

# We've closed the spigot. Print the remainder without rounding.

print join "", @out[$i-15+4 .. $digits-2], "\n";

 

==== Raku spigot ====

 

{{trans|Raku}}

sub stream {

my ($next, $safe, $prod, $cons, $z, $x) = @_;

$|++;

print $pi_stream->(), '.';

 

==== Machin's Formula ====

Here is an original Perl 5 code, using Machin's formula. Not the fastest program in the world. As with the previous code, using either Math::GMP or Math::BigInt::GMP instead of the default bigint Calc backend will make it run thousands of times faster.

 

 

# Pi/4 = 4 arctan 1/5 - arctan 1/239

$ns /= $g;

}

 

==== Modules ====

While no current CPAN module does continuous printing, there are (usually fast) ways to get digits of Pi. Examples include:

{{libheader|ntheory}}

use ntheory qw/Pi/;

say Pi(10000);

use Math::Big qw/pi/; # Very slow

say pi(10000);

 

=={{header|Phix}}==

I already had this golf entry to hand. Prints 2400 places, change the 8400 (derived from 2400*14/4) as needed, but I've not tested > that.

Someone was benchmarking the above against Lua, so I translated the Lua entry, and upped it to 2400 places, for a fairer test.

 

=={{header|PicoLisp}}==

The following script uses the spigot algorithm published by Jeremy Gibbons. Hit Ctrl-C to stop it.

 

(de piDigit ()

(loop

(prin (piDigit))

Output:

<pre>3.14159265358979323846264338327950288419716939937510582097494459 ...</pre>

 

=={{header|PL/I}}==

/* for the Digits of Pi". */

(subrg, fofl, size):

put edit(predigit) (f(1));

end; /* of begin block */

output:

<pre>

With some tweaking.

Prints 100 digits a time. Total possible output limited by available memory.

Function Get-Pi ( $Digits )

{

}

}

 

Alternate version using .Net classes

[math]::pi

Outputs:

3.14159265358979

 

=={{header|PureBasic}}==

Calculate Pi, limited to ~24 M-digits for memory and speed reasons.

#ARRINT= 2000

 

Ctrl:

PrintN(#CRLF$+"Ctrl-C was pressed")

 

=={{header|Python}}==

q, r, t, k, n, l = 1, 0, 1, 1, 3, 3

while True:

sys.stdout.write(str(d))

i += 1

<pre>

3141592653589793238462643383279502884197

 

Quackery does not have variables, it has ancillary stacks. To expedite translation from Oforth, the first two definitions implement words equivalent to the [https://forth-standard.org/standard/core/VALUE Forth words VALUE and TO].

]this[ share ]done[ ] is value ( --> x )

L 2 + to L

K 1+ to K ]

 

{{out}}

 

=={{header|R}}==

suppressMessages(library(gmp))

ONE <- as.bigz("1")

}

cat("\n")

'''Output:'''

<pre>

Utilizing Jeremy Gibbons spigot algorithm and racket generator:

 

#lang racket

(require racket/generator)

(when (zero? i) (display "." ))

(when (zero? (modulo i 80)) (newline)))

 

Output:

 

3.14159265358979323846264338327950288419716939937510...

 

=={{header|Raku}}==

(formerly Perl 6)

{{Works with|rakudo|2018.10}}

 

sub stream(&next, &safe, &prod, &cons, $z is copy, @x) {

print $pi[$i];

once print '.'

 

=={{header|REXX}}==

└─ ─┘

</pre>

parse arg digs oFID . /*obtain optional argument from the CL.*/

if digs=='' | digs=="," then digs= 1e6 /*Not specified? Then use the default.*/

say /*stick a fork in it, we're all done. */

exit: say; say n%2+1 'iterations took' format(time("Elapsed"),,2) 'seconds.'; exit 0

{{out|output|text=&nbsp; [until the &nbsp; Ctrl─Break &nbsp; key (or equivalent) was pressed]:}}

 

 

This algorithm is limited to the number of decimal digits as specified with the &nbsp; '''numeric digits ddd''' &nbsp; &nbsp; (line or statement six).

signal on halt /*───► HALT when Ctrl─Break is pressed.*/

parse arg digs oFID . /*obtain optional argument from the CL.*/

end /*forever*/

exit /*stick a fork in it, we're all done. */

 

=={{header|Ruby}}==

{{trans|Icon}}

q, r, t, k, n, l = 1, 0, 1, 1, 3, 3

loop do

 

print pi_digits.next, "."

 

=={{header|Rust}}==

{{trans|Kotlin}}

 

fn main() {

}

}

 

=={{header|Scala}}==

class PiIterator extends Iterable[BigInt] {

var r: BigInt = 0

}

 

Output:

<pre>3.141592653589793238462643383279502884197169399375105820974944592307816406286208998

 

=={{header|Scheme}}==

(import (rnrs))

 

(newline)

(set! i 0))))))

Output:

<pre>3141592653589793238462643383279502884197

 

=={{header|Seed7}}==

include "bigint.s7i";

 

end if;

end while;

 

Original source: [http://seed7.sourceforge.net/algorith/math.htm#pi_spigot_algorithm]

=={{header|Sidef}}==

===Classical Algorithm===

var (q, r, t, k, n, l) = (1, 0, 1, 1, 3, 3)

loop {

 

STDOUT.autoflush(true)

 

===Quicker, Unverified Algorithm===

{{trans|Haskell}}

From the same .pdf mentioned throughout this task, from the last page. The original algorithm was written in Haskell, this is a translation which has also been optimized to avoid redundant multiplications. Same output, but the algorithm is based on one of Gosper’s series that yields more than one digit per term on average, so no test is made partway through the iteration. This is capable of producing approximately 100,000 digits at [https://tio.run/##Hc@9boNAEATg3k@xnXfvNjaXcEkUa7v0KeLU0fkwP7Zl4DgiIYtnJ4A0xTTfSNNV2Tmfpry/e2jQEzzgzwVsOXDkgi9c8pUdn3ggEEDD5j3h1zU2ZZOssfxCG4BbXTez9zgItgqdluc3Am1VoP3eqkgH6KKLlYffecvjdrddGEAQkygstFy02JTUok9znXGAp2GVrZJSy1VLmhwgKilghHHzffz8@jnuXB/r/NZ3JRr6aHB5gxk9mlDdI2QjTdM/ tio.run] in the maximum 60 seconds allowed.

loop { c(y=(q*(a+=27) +5*r)//5*t); static _ = c('.')

r=10*(g+=j+=54)*(q*(b+=5) +r -y*t); q*=h+=k+=40; t*=g } }

 

=={{header|Simula}}==

BEGIN

 

TMOD :- TDIVMOD(A, B).MOD;

 

BIGNUM

BEGIN

 

CALCPI;

Output:

<pre>3141592653589793238462643383279502884197

Used the compact algorithm from [https://www.cs.ox.ac.uk/people/jeremy.gibbons/publications/spigot.pdf Gibbons paper].

Tailspin will at some point have arbitrary precision integers, currently we have to link into java and use BigInteger. Using java code can be slightly awkward as the argument in Tailspin comes before the method, so divide and subtract read backwards.

use 'java:java.math' stand-alone

 

 

1 -> g&{q:$one, r:$zero, t:$one, k:$one, n:$three, l:$three} -> !VOID

{{out}}

<pre>

Based on the reference in the [[#D|D]] code.

{{works with|Tcl|8.6}}

 

# http://www.cut-the-knot.org/Curriculum/Algorithms/SpigotForPi.shtml

}

}

The pi digit generation requires picking a limit to the number of digits; the bigger the limit, the more digits can be ''safely'' computed. A value of 10k yields values relatively rapidly.

fconfigure stdout -buffering none

while 1 {

puts -nonewline [piDigit]

 

=={{header|TypeScript}}==

 

function calcPi(pipe:AnyWriteableObject) {

}

 

 

'''Notes:'''

=== Async version ===

 

 

async function calcPi<T extends AnyWriteableObject>(pipe:T) {

});

 

 

Here the calculation does not continue if the consumer does not consume the character.

{{works with|VBA|6.5}}

{{works with|VBA|7.1}}

 

Sub Main()

End If

Next n

{{out}}

<pre>3.

{{trans|C#}}

Don't forget to use the "'''Project'''" tab, "'''Add Reference...'''" for '''''System.Numerics''''' (in case you get compiler errors in the Visual Studio IDE)

Imports System.Numerics

End Sub

 

{{out}}

<pre style="height:30ex;overflow:scroll;white-space:pre-wrap;">3.1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253421170679821480865132823066470938446095505822317253594081284811174502841027019385211055596446229489549303819644288109756659334461284756482337867831652712019091456485669234603486104543266482133936072602491412737245870066063155881748815209209628292540917153643678925903600113305305488204665213841469519415116094330572703657595919530921861173819326117931051185480744623799627495673518857527248912279381830119491298336733624406566430860213949463952247371907021798609437027705392171762931767523846748184676694051320005681271452635608277857713427577896091736371787214684409012249534301465495853710507922796892589235420199561121290219608640344181598136297747713099605187072113499999983729780499510597317328160963185950244594553469083026425223082533446850352619311881710100031378387528865875332083814206171776691473035982534904287554687311595628638823537875937519577818577805321712268066130019278766111959092164201989380952572010654858632788659361533818279682303019520353018529689957736225994138912497217752834791315155748572424541506959508295331168617278558890750983817546374649393192550604009277016711390098488240128583616035637076601047101819429555961989467678374494482553797747268471040475346462080466842590694912933136770289891521047521620569660240580381501935112533824300355876402474964732639141992726042699227967823547816360093417216412199245863150302861829745557067498385054945885869269956909272107975093029553211653449872027559602364806654991198818347977535663698074265425278625518184175746728909777727938000816470600161452491921732172147723501414419735685481613611573525521334757418494684385233239073941433345477624168625189835694855620992192221842725502542568876717904946016534668049886272327917860857843838279679766814541009538837863609506800642251252051173929848960841284886269456042419652850222106611863067442786220391949450471237137869609563643719172874677646575739624138908658326459958133904780275900994657640789512694683983525957098258226205224894077267194782684826014769909026401363944374553050682034962524517493996514314298091906592509372216964615157098583874105978859597729754989301617539284681382686838689427741559918559252459539594310499725246808459872736446958486538367362226260991246080512438843904512441365497627807977156914359977001296160894416948685558484063534220722258284886481584560285060168427394522674676788952521385225499546667278239864565961163548862305774564980355936345681743241125150760694794510965960940252288797108931456691368672287489405601015033086179286809208747609178249385890097149096759852613655497818931297848216829989487226588048575640142704775551323796414515237462343645428584447952658678210511413547357395231134271661021359695362314429524849371871101457654035902799344037420073105785390621983874478084784896833214457138687519435064302184531910484810053706146806749192781911979399520614196634287544406437451237181921799983910159195618146751426912397489409071864942319615679452080951465502252316038819301420937621378559566389377870830390697920773467221825625996615014215030680384477345492026054146659252014974428507325186660021324340881907104863317346496514539057962685610055081066587969981635747363840525714591028970641401109712062804390397595156771577004203378699360072305587631763594218731251471205329281918261861258673215791984148488291644706095752706957220917567116722910981690915280173506712748583222871835209353965725121083579151369882091444210067510334671103141267111369908658516398315019701651511685171437657618351556508849099898599823873455283316355076479185358932261854896321329330898570642046752590709154814165498594616371802709819943099244889575712828905923233260972997120844335732654893823911932597463667305836041428138830320382490375898524374417029132765618093773444030707469211201913020330380197621101100449293215160842444859637669838952286847831235526582131449576857262433441893039686426243410773226978028073189154411010446823252716201052652272111660396665573092547110557853763466820653109896526918620564769312570586356620185581007293606598764861179104533488503461136576867532494416680396265797877185560845529654126654085306143444318586769751456614068007002378776591344017127494704205622305389945613140711270004078547332699390814546646458807972708266830634328587856983052358089330657574067954571637752542021149557615814002501262285941302164715509792592309907965473761255176567513575178296664547791745011299614890304639947132962107340437518957359614589019389713111790429782856475032031986915140287080859904801094121472213179476477726224142548545403321571853061422881375850430633217518297986622371721591607716692547487389866549494501146540628433663937900397692656721463853067360965712091807638327166416274888800786925602902284721040317211860820419000422966171196377921337575114959501566049631862947265473642523081770367515906735023507283540567040386743513622224771589150495309844489333096340878076932599397805419341447377441842631298608099888687413260472156951623965864573021631598193195167353812974167729478672422924654366800980676928238280689964004824354037014163149658979409243237896907069779422362508221688957383798623001593776471651228935786015881617557829735233446042815126272037343146531977774160319906655418763979293344195215413418994854447345673831624993419131814809277771038638773431772075456545322077709212019051660962804909263601975988281613323166636528619326686336062735676303544776280350450777235547105859548702790814356240145171806246436267945612753181340783303362542327839449753824372058353114771199260638133467768796959703098339130771098704085913374641442822772634659470474587847787201927715280731767907707157213444730605700733492436931138350493163128404251219256517980694113528013147013047816437885185290928545201165839341965621349143415956258658655705526904965209858033850722426482939728584783163057777560688876446248246857926039535277348030480290058760758251047470916439613626760449256274204208320856611906254543372131535958450687724602901618766795240616342522577195429162991930645537799140373404328752628889639958794757291746426357455254079091451357111369410911939325191076020825202618798531887705842972591677813149699009019211697173727847684726860849003377024242916513005005168323364350389517029893922334517220138128069650117844087451960121228599371623130171144484640903890644954440061986907548516026327505298349187407866808818338510228334508504860825039302133219715518430635455007668282949304137765527939751754613953984683393638304746119966538581538420568533862186725233402830871123282789212507712629463229563989898935821167456270102183564622013496715188190973038119800497340723961036854066431939509790190699639552453005450580685501956730229219139339185680344903982059551002263535361920419947455385938102343955449597783779023742161727111

===Quicker, unverified algo===

There seems to be another algorithm in the original reference article (see the [http://www.rosettacode.org/wiki/Pi#Ada Ada] entry), which produces output a bit faster. However, the math behind the algorithm has not been completely proven. It's faster because it doesn't calculate whether each digit is accumulated properly before squirting it out. When using (slow) arbitrary precision libraries, this avoids a lot of computation time.

Module Module1

If msg.Length > 0 Then Console.WriteLine(msg)

Dim first As Boolean = True, stp As Integer = 360,

res As StringBuilder = New StringBuilder(),

rc As Integer = -1, y As Byte, et As TimeSpan,

q = 1 : r = 180 : t = 60 : g = 60 : j = 54

h = 10 : k = 10 : a = 15 : b = 3

a += 27 : y = CByte((q * a + 5 * r) / (5 * t))

res.Append(y) : b += 5 : j += 54 : g += j

If first Then res.Insert(1, "."c) : first = False

Console.Write(res.ToString())

If Console.KeyAvailable Then Exit While

End While

If Diagnostics.Debugger.IsAttached Then Console.ReadKey()

End Sub

{{out}}The First several thousand digits verified the same as the conventional spigot algorithm, haven't detected any differences yet.

<pre style="height:30ex;overflow:scroll;white-space:pre-wrap;">Press a key to exit...

{{trans|Kotlin}}

{{libheader|Wren-big}}

import "io" for Stdout

 

}

 

 

{{out}}

3.14159265358979323846264338327950288419716939937510582097494459230781640628620899862803482534211706798214808651328230664709384460955058223172535940812848111745...

</pre>

 

=={{header|zkl}}==

Uses the GMP big int library.

Same algorithm as many of the others on this page. Uses in place ops to cut down on big int generation (eg add vs +). Unless GC is given some hints, it will use up 16 gig quickly as it outruns the garbage collector.

one=BN(1), two=BN(2), three=BN(3), four=BN(4), seven=BN(7), ten=BN(10);

 

}

}

Runs until ^C hit, the first 1000 digits match the D output.

{{out}}