How do I print pi (3.14159)? [closed]

Question

What command could print pi for me? I want to specify how many digits it prints, I couldn't find anything online. I just want to be able to print pi.

Answer 1

If you have tex(1) installed:

tex --version | head -1 | cut -f2 -d' '

Answer 2

You can use this command:

echo "scale=5; 4*a(1)" | bc -l
3.14159

Where scale is the number of digits after decimal point.

Reference: http://www.tux-planet.fr/calculer-le-chiffre-pi-en-ligne-de-commande-sous-linux/

Answer 3

For printing with arbitrary precision, you could use bc and the formula pi = 4*atan(1):

# bc -l
scale=<your precision>
4*a(1)

Answer 4

If you want something that can compute the value of π, then there are several approaches. Perhaps the most obvious solution would be to use a ready-made package like pi (Debian package link), which if Debian's package description is to be trusted can compute the value to an arbitrary precision, limited only by memory.

pi is actually an example that's included with the CLN library (Class Library for Numbers). It includes example applications that provide tools for generating arbitrary lengths of numbers such as Pi, Fibonacci, etc. CLN packages are available pre-packaged in Debian/Ubuntu (that's what the Debian link above is pointing to).

Examples

$ ./pi 10
3.141592653

$ ./pi 20
3.1415926535897932384

NOTE: The source of these examples is here in the source for the CLN code base.

Other distros

Fedora

On Fedora I had to download the source tarball and build it myself, but it builds with little fuss. For whatever reason the package cln on Fedora includes just the library but neglects the examples that are available in the Debian/Ubuntu version (above).

Arch

Arch provides the same program in the cln package (thanks Amphiteót).

Answer 5

For up to a million digits you can use the following (here for 3000 digits):

curl --silent http://www.angio.net/pi/digits/pi1000000.txt | cut -c1-3000

Answer 6

Some of the other answers show incorrect digits at the last places of the output. Below is a variation of the answer using bc but with a better rounded result. The variable s contains the number of significant digits (including 3 in front of the decimal point).

Round half up

$ bc -l <<< "s=5; scale=s+2; pi=4*a(1)+5*10^(-s); scale=s-1; pi/1"
3.1416

Round down (truncate)

$ bc -l <<< "s=5; scale=s+2; pi=4*a(1); scale=s-1; pi/1"
3.1415

Explanation of the rounding

The rounding is performed directly in bc. This does not have the limitation of the command printf which uses the C language double type representation for the numbers which has a precision of about 17 significant digits. See the answer with printf rounding.

scale=s-1 sets the number of digits to truncate to. pi/1 divides the result by 1 to apply the truncation. Simple pi does not truncate the number.

Rounding half up requires to add 5 to the first digit which will be cut off (5×10^-s) so that in case of digits higher of equal 5 the last digit which will remain will be incremented.

From the tests by hobbs it seems that three additional digits which will be rounded / cut off (scale=s+2) will suffice even for very long numbers.

Here strings

The examples above use here strings which are supported for example in bash, ksh and zsh. If your shell does not support here string use echo and pipe instead:

$ echo "s=5; scale=s+2; pi=4*a(1); scale=s-1; pi/1" |  bc -l
3.1415

Answer 7

perl one line (using bignum):

perl -Mbignum=bpi -wle 'print bpi(NUM)'

e.g

perl -Mbignum=bpi -wle 'print bpi(6)'
3.14159

Answer 8

With python2:

$ python -c "import math; print(str(math.pi)[:7])"
3.14159

Answer 9

Using Ruby:

require "bigdecimal"
require "bigdecimal/math"
include BigMath

BigDecimal(PI(100)).round(9).to_s("F")

3.141592654

Answer 10

In bash:

$ read -a a <<< $(grep M_PIl /usr/include/math.h) ; echo ${a[3]} | tr -d L
3.141592653589793238462643383279502884

Answer 11

Very simple in PHP using the built in pi() function:

<?php 
echo round(pi(), 2);
?>

Answer 12

How did I miss this question...

Here's a little Python pi program of mine that I posted a couple of weeks ago on Stack Overflow. It's not particularly fast, but it can do lots of digits. :) However, as I mentioned in that thread, I generally use Python's mpmath module for arbitrary precision arithmetic, and mpmath has a rather fast pi maker.

Eg,

time python -c "from mpmath import mp;mp.dps=500000;print mp.pi" >bigpi

real    0m4.709s
user    0m4.556s
sys     0m0.084s

500000 decimals of pi in under 5 seconds isn't too shabby, IMHO, considering it's running on a machine with a single core 2GHz processor, 2 gig of RAM, and writing to an elderly IDE drive.

Answer 13

If you have node.js installed, this will do its best at finding pi for you, though its best isn't very good:

node -e 'for(a=0,b=4E8,m=Math,r=m.random;b--;)a+=(1>m.sqrt((c=r())*c+(d=r())*d));console.log(a/1E8)'

Sample outputs:

3.14157749
3.1416426
3.14159055
3.14171554
3.14176165
3.14157587
3.14161137
3.14167685
3.14172371

Answer 14

Monte Carlo Method

See, for example, this for an explanation of this method.

Caveats

• Not arbitrarily accurate
• Takes a long time to converge to anything useful

Advantages

Fun :-)

perl -Mbignum -E '
    for(0 .. 1_000_000){
        srand;
        $x=rand; # Random x coordinate
        $y=rand; # Random Y coordinate
        $decision = $x**2 + $y**2 <=1 ? 1:0; # Is this point inside the unit circle?
        $circle += $decision;
        $not_circle += 1-$decision;
        $pi = 4*($circle/($circle+$not_circle)); 
        say $pi
     }'

Note: I first tried it without srand but it got stuck at 3.14 and the digits after that kept oscillating, never converging. This is probably because, after a while the PRNG starts repeating itself. The use of srand will avoid that or at least lengthen the period of the pseudo-random sequence. This is all conjecture, so feel free to correct me if I'm wrong.

Answer 15

You can use a spigot algorithm for pi. The following C program by Dik Winter and Achim Flammenkamp will produce the first 15,000 digits of pi, one digit at a time.

a[52514],b,c=52514,d,e,f=1e4,g,h;main(){for(;b=c-=14;h=printf("%04d",e+d/f))for(e=d%=f;g=--b*2;d/=g)d=d*b+f*(h?a[b]:f/5),a[b]=d%--g;}

Answer 16

PHP

Few examples:

php -r "print pi();"
php -r 'echo M_PI;'
echo "<?=pi();" | php

If you want to change the precision try:

php -d precision=100 -r 'echo pi();'

The size of a float is platform-dependent, although a maximum of ~1.8e308 with a precision of roughly 14 decimal digits is a common value (the 64 bit IEEE format). [read more]

---

If you looking for even more accurate precision, check Rosetta Code or Code Golf SE for some programming solutions.

Related: Software that can calculate PI to at least a thousand digits at SR.SE

Answer 17

Here's a script that prints pi with the number of digits specified (including '.') by the user.

pi.sh

#!/bin/bash
len=${1:-7}
echo "4*a(1)" | bc -l | cut -c 1-"$len"

output

$ ./pi.sh 10
3.14159265

and with default value:

$ ./pi.sh
3.14159

I've seen people using scale as a bc option, but in my case (bc 1.06.95) this does not output the correct value:

$ echo "scale=5;4*a(1)" | bc -l
3.14156

Notice the last digit.

Answer 18

I like Abey's answer but did not like how bc was changing the last digit.

echo "scale=5; 4*a(1)" | bc -l
3.14156

So I removed scale used printf to set the number of digits.

printf "%0.5f\n" $(echo "4*a(1)" | bc -l)
3.14159

Answer 19

What if you can't for the life of you remember this arctan thing? Or supposing you don't even know this function exists in bc, then try to memorize this simple division:

echo "scale=6; 355 / 113" | bc
3.141592

Will only work for 6 digits, but for non-scientific calculations this will do fine.

If you think you can't remember these two numbers either, write the denominator first, then the numerator:

113 355

Or why not

11 33 55

"double 1, double 3, double 5". All figures are odd. To calculate, split the 6-digit number in half again, and swap denominator and numerator before dividing them. That's about it.

Answer 20

It can be assumed that the OP is interested in a short, easy to memorize shell command to print π - but the question does not really say that. This answer is ignoring that assumption and answers the question strictly as written;

Trivial?

While there are 18 answers already, one approach is still missing - and with so many answers, it one could think it't the only one that is missing:
The trivial one: How to print π? Just print π!

That approach seems to be too useless to even think about it, but I will show that it does have it's merrits:

Optimized

We'd normally calculate the value of π. I don't see what's keeping us from optimizing the solution, by precalculating the value - it's a constant, any compiler would do that.

We want some number of digits of π, up to a maximum precision. So we can just take the prefix of the constant, as text:

echo 3.1415926535897932384626433832795 | cut -b -7
3.14159

A variant with an explicit argument for the precision, eg. for precision 5:

echo 3.1415926535897932384626433832795 | cut -b -$((2+5))
3.14159

Advantages

The maximum precision can be choosen arbitrarily by using a suitable constant calculated using one of the other answers. It is limited only by the maximal length of a command line.
It has constant time complexity for finding the value.
It makes all limits and constraints obvious, based on the low complexity of implementation.
It handles precision larger than the maximum gracefully by returning the constant in the full available precision (with no trailing 0).
So this solution, while trivial, does have advantages. It may be useful when it's used in a shell function, for example.

Minimal

The functionality of the solution above can also be inplemented without creating a process for cut (assuming echo is a shell builtin). It uses the command printf (normally a builtin) in a somewhat obscure way:
The constant is completely handeled as a string (the format uses %s), there is no floating point arithmethic involved, so the limits of float or double do not apply here.
The precision value of the %s escape (5 in the example below) specifies the length of the string prefix to print - which is the precision. The 3. is part of the printf format to keep it out of the precision calculation.

$ printf "3.%.5s\n" 1415926535897932384626433832795 
3.14159

Alternative with precision as separate argument:

$ printf "3.%.*s\n" 5 1415926535897932384626433832795 
3.14159

Or slightly more readable (Note the space between 3. and 14159..., they are separate arguments):

$ printf "%s%.5s\n" 3. 1415926535897932384626433832795
3.14159

Fast

The variant using printf can be expected to be very fast: Because printf is a shell builtin in common shells like bash and zsh, it does not create any processes.
Also, it does not touch any kind of floating point related code, but only manipulation of byte arrays (explicitly not multibyte characters). This is usually faster, often much faster than the use of floating point.

printf compatibility

Often, there are reasons to replace printf by /usr/bin/printf to guarantee consistency or compatibility. In this case, I think we can use the builtin - which is important, as using /usr/bin/printf reduces the "fast" advantage by forking a process.
A common problem with printf compatibility is the number output format depending on the locale. The separating . for numbers can be changed to , based on locale setting; But we do not use numbers, just a string constant containing a literal . - unaffected by locale.
StéphaneChazelas pointed out that printf %.5s works differently in zsh, by counting characters, not bytes as usual. Luckily, our constants use only characters in the lower ASCII-range, which is encoded by one byte per character in any relevant encoding, as long as we use the common UTF-8 encoding for Unicode, and not a fixed width encoding.