Como imprimo pi (3.14159)? [fechadas]

Que comando poderia imprimir pi para mim? Quero especificar quantos dígitos serão impressos. Não encontrei nada on-line. Eu só quero poder imprimir pi.

Você pode usar este comando:

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

Onde escala é o número de dígitos após o ponto decimal.

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

Se você tex(1)instalou:

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

Para imprimir com precisão arbitrária, você pode usar bce a fórmula pi = 4*atan(1):

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

Se você deseja algo que possa calcular o valor de π, existem várias abordagens. Talvez a solução mais óbvia seja usar um pacote pronto como pi(link do pacote Debian) , que se a descrição do pacote Debian for confiável, pode calcular o valor com uma precisão arbitrária, limitada apenas pela memória.

pié na verdade um exemplo incluído na biblioteca CLN (Class Library for Numbers) . Inclui aplicativos de exemplo que fornecem ferramentas para gerar comprimentos arbitrários de números como Pi, Fibonacci, etc. Pacotes CLN estão disponíveis pré-empacotados no Debian / Ubuntu (é para isso que o link Debian acima está apontando).

$ ./pi 10
3.141592653

$ ./pi 20
3.1415926535897932384

NOTA: A fonte desses exemplos está aqui na fonte da base de código CLN .

Outras distros

No Fedora eu tive que baixar o tarball de origem e construí-lo, mas ele é construído com pouco esforço. Por qualquer motivo, o pacote clnno Fedora inclui apenas a biblioteca, mas negligencia os exemplos que estão disponíveis na versão Debian / Ubuntu (acima).

Arch fornece o mesmo programa no clnpacote (graças Amphiteót ).

Para até um milhão de dígitos, você pode usar o seguinte (aqui para 3000 dígitos):

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

Algumas das outras respostas mostram dígitos incorretos nos últimos locais da saída. Abaixo está uma variação da resposta usandobc mas com um resultado arredondado corretamente. A variável scontém o número de dígitos significativos (inclusive 3na frente do ponto decimal).

Rodada para cima

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

Arredondar para baixo (truncar)

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

Explicação do arredondamento

O arredondamento é realizado diretamente em bc. Isso não tem a limitação do comando printfque usa a representação do doubletipo de linguagem C para os números que possuem uma precisão de cerca de 17 dígitos significativos. Veja a resposta com printfarredondamento .

scale=s-1define o número de dígitos para truncar. pi/1divide o resultado por 1 para aplicar o truncamento. Simples pinão trunca o número.

O arredondamento para metade exige a adição de 5 ao primeiro dígito que será cortado (5 × 10- ^s ), de modo que, no caso de dígitos maiores que 5, o último dígito que permanecerá será incrementado.

A partir dos testes de hobbs , parece que três dígitos adicionais que serão arredondados / cortados ( scale=s+2) serão suficientes mesmo para números muito longos.

Here strings

Os exemplos acima usam aqui strings que são suportadas, por exemplo bash, em , kshe zsh. Se o seu shell não suportar aqui, use string echoe pipe:

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

perl uma linha (usando bignum ):

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

por exemplo

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

Com python2:

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

Usando Ruby:

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

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

3.141592654

Na festança:

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

Muito simples em PHP usando a função pi () integrada:

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

Como eu perdi essa pergunta ...

Aqui está um pequeno programa Python pi que publiquei algumas semanas atrás no Stack Overflow. Não é particularmente rápido, mas pode gerar muitos dígitos. :) No entanto, como mencionei nesse tópico, geralmente uso o módulo mpmath do Python para aritmética de precisão arbitrária, e o mpmath possui um fabricante de pi bastante rápido.

Por exemplo,

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

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

500000 decimais de pi em menos de 5 segundos não é muito ruim, IMHO, considerando que está sendo executado em uma máquina com um processador de núcleo único de 2 GHz, 2 GB de RAM e gravando em uma unidade IDE antiga.

Se você node.jsinstalou, isso fará o melhor para encontrar pi para você, embora o melhor não seja muito bom:

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)'

Saídas de amostra:

3.14157749
3.1416426
3.14159055
3.14171554
3.14176165
3.14157587
3.14161137
3.14167685
3.14172371

Método de Monte Carlo

Veja, por exemplo, isto para obter uma explicação desse método.

Ressalvas

• Não é arbitrariamente preciso
• Leva muito tempo para convergir para algo útil

Vantagens

Diversão :-)

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
     }'

Nota: Eu tentei primeiro sem ele, srandmas ele ficou preso 3.14e os dígitos depois continuaram oscilando, nunca convergindo. Provavelmente porque, depois de um tempo, o PRNG começa a se repetir. O uso de srandevitará isso ou pelo menos prolongará o período da sequência pseudo-aleatória. Isso tudo é conjectura, então fique à vontade para me corrigir se eu estiver errado.

Você pode usar um algoritmo de torneira para pi. O seguinte programa C de Dik Winter e Achim Flammenkamp produzirá os primeiros 15.000 dígitos de pi, um dígito de cada vez.

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;}

PHP

Poucos exemplos:

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

Se você deseja alterar a precisão, tente:

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

O tamanho de um flutuador depende da plataforma, embora um máximo de ~ 1.8e308 com uma precisão de aproximadamente 14 dígitos decimais seja um valor comum (o formato IEEE de 64 bits). [consulte Mais informação]

Se você procura precisão ainda mais precisa, consulte o Rosetta Code ou o Code Golf SE para obter algumas soluções de programação.

Relacionado: Software que pode calcular o PI com pelo menos mil dígitos no SR.SE

Aqui está um script que imprime pi com o número de dígitos especificado (incluindo '.') Pelo usuário.

pi.sh

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

saída

$ ./pi.sh 10
3.14159265

e com valor padrão:

$ ./pi.sh
3.14159

Eu já vi pessoas usando scalecomo bcopção, mas no meu caso ( bc 1.06.95) isso não gera o valor correto:

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

Observe o último dígito.

Gosto da resposta de Abey, mas não gostei de como bc estava mudando o último dígito.

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

Então eu removi a escala usada printf para definir o número de dígitos.

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

E se você não puder, pelo resto da vida, se lembrar dessa arctancoisa? Ou supondo que você nem saiba que essa função existe bc, tente memorizar esta divisão simples:

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

Funcionará apenas com 6 dígitos, mas para cálculos não científicos, isso funcionará bem.

Se você também não consegue se lembrar desses dois números, escreva primeiro o denominador e depois o numerador:

113 355

Ou porque não

11 33 55

"dobro 1, dobro 3, dobro 5". Todos os números são ímpares. Para calcular, divida o número de 6 dígitos ao meio novamente e troque o denominador e o numerador antes de dividi-los. É sobre isso.

Pode-se supor que o OP esteja interessado em um comando shell curto e fácil de memorizar para imprimir π - mas a questão não diz isso realmente. Esta resposta está ignorando essa suposição e responde a pergunta estritamente como escrita;

Trivial?

Embora já existam 18 respostas, uma abordagem ainda está faltando - e com tantas respostas, pode-se pensar que não é a única que está faltando:
A trivial: Como imprimir π? Apenas imprima π!

Essa abordagem parece ser inútil demais para pensar nisso, mas mostrarei que ela tem seus méritos:

Otimizado

Normalmente, calcularíamos o valor de π. Não vejo o que nos impede de otimizar a solução, pré-calculando o valor - é uma constante, qualquer compilador faria isso.

Queremos um número de dígitos de π, até a precisão máxima. Então, podemos pegar o prefixo da constante, como texto:

echo 3.1415926535897932384626433832795 | cut -b -7
3.14159

Uma variante com um argumento explícito para a precisão, por exemplo. para precisão 5:

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

Vantagens

A precisão máxima pode ser escolhida arbitrariamente usando uma constante adequada calculada usando uma das outras respostas. É limitado apenas pelo comprimento máximo de uma linha de comando.
Possui complexidade de tempo constante para encontrar o valor.
Torna óbvios todos os limites e restrições, com base na baixa complexidade de implementação.
Ele lida com precisão maior que o máximo normalmente, retornando a constante na precisão total disponível (sem rastro 0).
Portanto, essa solução, embora trivial, tem vantagens. Pode ser útil quando usado em uma função shell, por exemplo.

Mínimo

A funcionalidade da solução acima também pode ser implementada sem a criação de um processo para cut(supondo que echoseja um shell embutido). Ele usa o comando printf(normalmente um builtin) de uma maneira um tanto obscura:
a constante é manipulada completamente como uma string (o formato usa %s); não há aritmética de ponto flutuante envolvida; portanto, os limites floatou doublenão se aplicam aqui.
O valor de precisão do %sescape ( 5no exemplo abaixo) especifica o comprimento do prefixo da string a ser impresso - que é a precisão. Faz 3.parte do printfformato para mantê-lo fora do cálculo de precisão.

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

Alternativa com precisão como argumento separado:

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

Ou um pouco mais legível (observe o espaço entre 3.e 14159..., eles são argumentos separados):

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

Rápido

printfPode-se esperar que a variante usando seja muito rápida: como printfé um shell embutido em shells comuns como bashe zsh, ele não cria nenhum processo.
Além disso, ele não toca em nenhum tipo de código relacionado a ponto flutuante, mas apenas na manipulação de matrizes de bytes (explicitamente, não caracteres multibyte). Isso geralmente é mais rápido, geralmente muito mais rápido que o uso do ponto flutuante.

compatibilidade printf

Muitas vezes, há razões para substituir printfpor /usr/bin/printfpara garantir consistência ou compatibilidade. Nesse caso, acho que podemos usar o built-in - o que é importante, pois o uso /usr/bin/printfreduz a vantagem "rápida" ao bifurcar um processo.
Um problema comum com printfcompatibilidade é o formato de saída de número, dependendo da localidade. A separação .de números pode ser alterada para com ,base na configuração da localidade; Mas não usamos números, apenas uma constante de string contendo um literal .- não afetada pela localidade.
StéphaneChazelas destacou que printf %.5sfunciona de maneira diferentezsh, contando caracteres, não bytes, como de costume. Felizmente, nossas constantes usam apenas caracteres no intervalo ASCII inferior, que é codificado por um byte por caractere em qualquer codificação relevante, desde que utilizemos a UTF-8codificação comum para Unicode, e não uma codificação de largura fixa.