¿Cómo imprimo pi (3.14159)? [cerrado]

¿Qué comando podría imprimir pi para mí? Quiero especificar cuántos dígitos imprime, no pude encontrar nada en línea. Solo quiero poder imprimir pi.

Puedes usar este comando:

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

Donde escala es el número de dígitos después del punto decimal.

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

Si ha tex(1)instalado:

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

Para imprimir con precisión arbitraria, puede usar bcy la fórmula pi = 4*atan(1):

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

Si quieres algo que pueda calcular el valor de π, existen varios enfoques. Quizás la solución más obvia sería usar un paquete listo como pi(enlace del paquete Debian) , que si se puede confiar en la descripción del paquete Debian puede calcular el valor con una precisión arbitraria, limitada solo por la memoria.

pies en realidad un ejemplo que se incluye con la biblioteca CLN (Biblioteca de clases para números) . Incluye aplicaciones de ejemplo que proporcionan herramientas para generar longitudes arbitrarias de números como Pi, Fibonacci, etc. Los paquetes CLN están disponibles preenvasados ​​en Debian / Ubuntu (a eso apunta el enlace de Debian anterior).

$ ./pi 10
3.141592653

$ ./pi 20
3.1415926535897932384

NOTA: La fuente de estos ejemplos está aquí en la fuente de la base del código CLN .

Otras distribuciones

En Fedora tuve que descargar el tarball de origen y construirlo yo mismo, pero se construye con poco alboroto. Por alguna razón el paquetecln en Fedora incluye solo la biblioteca pero descuida los ejemplos que están disponibles en la versión Debian / Ubuntu (arriba).

Arch proporciona el mismo programa en el clnpaquete (gracias Amphiteót ).

Para hasta un millón de dígitos, puede usar lo siguiente (aquí para 3000 dígitos):

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

Algunas de las otras respuestas muestran dígitos incorrectos en los últimos lugares de la salida. A continuación se muestra una variación de la respuesta usandobc pero con un resultado correctamente redondeado. La variable scontiene el número de dígitos significativos (incluidos3 delante del punto decimal).

Redondear a la mitad

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

Redondear hacia abajo (truncar)

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

Explicación del redondeo.

El redondeo se realiza directamente en bc. Esto no tiene la limitación del comando printfque usa la representación del doubletipo de lenguaje C para los números que tiene una precisión de aproximadamente 17 dígitos significativos. Vea la respuesta con printfredondeo .

scale=s-1establece el número de dígitos para truncar. pi/1divide el resultado entre 1 para aplicar el truncamiento. Simplepi no trunca el número.

El redondeo a la mitad requiere agregar 5 al primer dígito que se cortará (5 × 10 ^-s ) para que, en el caso de dígitos superiores a igual a 5, se incremente el último dígito restante.

De las pruebas de hobbs parece que tres dígitos adicionales que se redondearán / cortarán (scale=s+2 ) serán suficientes incluso para números muy largos.

Aquí cuerdas

Los ejemplos anteriores usan aquí cadenas que son compatibles, por ejemplo bash, en kshy zsh. Si su shell no admite aquí el uso de cadenas echoy la tubería en su lugar:

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

perl una línea (usando bignum ):

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

p.ej

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

Con 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

En bash:

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

Muy simple en PHP usando la función incorporada pi ():

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

¿Cómo me perdí esta pregunta ...

Aquí hay un pequeño programa de Python pi que publiqué hace un par de semanas en Stack Overflow. No es particularmente rápido, pero puede hacer muchos dígitos. :) Sin embargo, como mencioné en ese hilo, generalmente uso el módulo mpmath de Python para aritmética de precisión arbitraria, y mpmath tiene un generador de pi bastante rápido.

P.ej,

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

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

En mi humilde opinión, 500000 decimales de pi en menos de 5 segundos no es nada malo, considerando que se está ejecutando en una máquina con un procesador de 2 GHz de un solo núcleo, 2 gigas de RAM y escribiendo en una unidad IDE antigua.

Si lo ha node.jsinstalado, hará todo lo posible para encontrar pi por usted, aunque lo mejor no es muy bueno:

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

Resultados de muestra:

3.14157749
3.1416426
3.14159055
3.14171554
3.14176165
3.14157587
3.14161137
3.14167685
3.14172371

Método Monte Carlo

Ver, por ejemplo, esto para una explicación de este método.

Advertencias

• No es arbitrariamente preciso
• Toma mucho tiempo converger a algo útil

Ventajas

Divertido :-)

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: Primero lo probé sin, srandpero se quedó atascado 3.14y los dígitos siguieron oscilando, sin converger. Esto probablemente se deba a que, después de un tiempo, el PRNG comienza a repetirse. El uso de srandevitará eso o al menos alargará el período de la secuencia pseudoaleatoria. Todo esto es una conjetura, así que siéntete libre de corregirme si me equivoco.

Puede usar un algoritmo de espiga para pi. El siguiente programa C de Dik Winter y Achim Flammenkamp producirá los primeros 15,000 dígitos de pi, un dígito a la 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

Pocos ejemplos:

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

Si quieres cambiar la precisión prueba:

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

El tamaño de un flotante depende de la plataforma, aunque un máximo de ~ 1.8e308 con una precisión de aproximadamente 14 dígitos decimales es un valor común (el formato IEEE de 64 bits). [Lee mas]

Si busca una precisión aún más precisa, consulte Rosetta Code o Code Golf SE para obtener algunas soluciones de programación.

Relacionado: Software que puede calcular PI a al menos mil dígitos en SR.SE

Aquí hay un script que imprime pi con el número de dígitos especificados (incluido '.') Por el usuario.

pi.sh

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

salida

$ ./pi.sh 10
3.14159265

y con valor por defecto:

$ ./pi.sh
3.14159

He visto personas que usan scalecomo bcopción, pero en mi caso ( bc 1.06.95) esto no genera el valor correcto:

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

Observe el último dígito.

Me gusta la respuesta de Abey pero no me gustó cómo bc estaba cambiando el último dígito.

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

Así que eliminé la escala utilizada printf para establecer el número de dígitos.

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

¿Qué pasa si no puedes por tu vida recordar esto arctan? O suponiendo que ni siquiera sabe que existe esta función bc, intente memorizar esta división simple:

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

Solo funcionará para 6 dígitos, pero para cálculos no científicos esto funcionará bien.

Si crees que tampoco puedes recordar estos dos números, primero escribe el denominador y luego el numerador:

113 355

O porque no

11 33 55

"doble 1, doble 3, doble 5". Todas las figuras son extrañas. Para calcular, divida nuevamente el número de 6 dígitos por la mitad e intercambie el denominador y el numerador antes de dividirlos. Eso es todo.

Se puede suponer que el OP está interesado en un comando de shell corto y fácil de memorizar para imprimir π, pero la pregunta realmente no dice eso. Esta respuesta ignora esa suposición y responde la pregunta estrictamente como está escrita;

¿Trivial?

Si bien ya hay 18 respuestas, todavía falta un enfoque, y con tantas respuestas, uno podría pensar que no es el único que falta:
El trivial: ¿Cómo imprimir π? Solo imprime π!

Ese enfoque parece ser demasiado inútil como para pensarlo, pero demostraré que tiene sus ventajas:

Optimizado

Normalmente calcularíamos el valor de π. No veo lo que nos impide optimizar la solución, calculando previamente el valor; es una constante, cualquier compilador haría eso.

Queremos cierto número de dígitos de π, hasta una precisión máxima. Entonces podemos tomar el prefijo de la constante, como texto:

echo 3.1415926535897932384626433832795 | cut -b -7
3.14159

Una variante con un argumento explícito para la precisión, por ejemplo. para precisión 5:

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

Ventajas

La precisión máxima se puede elegir arbitrariamente usando una constante adecuada calculada usando una de las otras respuestas. Está limitado solo por la longitud máxima de una línea de comando.
Tiene una complejidad de tiempo constante para encontrar el valor.
Hace obvios todos los límites y restricciones, en función de la baja complejidad de la implementación.
Maneja la precisión más grande que el máximo con gracia al devolver la constante en la precisión total disponible (sin arrastre 0).
Entonces, esta solución, aunque trivial, tiene ventajas. Puede ser útil cuando se usa en una función de shell, por ejemplo.

Mínimo

La funcionalidad de la solución anterior también se puede implementar sin crear un proceso para cut(suponiendo que echosea ​​un shell incorporado). Utiliza el comando printf(normalmente integrado) de una manera algo oscura:
la constante se maneja completamente como una cadena (el formato usa %s), no hay aritmética de punto flotante involucrada, por lo que los límites de floato doubleno se aplican aquí.
El valor de precisión del %sescape ( 5en el ejemplo a continuación) especifica la longitud del prefijo de cadena a imprimir, que es la precisión. El 3.es parte del printfformato para mantenerlo fuera del cálculo de precisión.

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

Alternativa con precisión como argumento separado:

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

O un poco más legible (tenga en cuenta el espacio entre 3.y 14159..., son argumentos separados):

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

Rápido

Se printfpuede esperar que la variante de uso sea ​​muy rápida: debido a que printfes un shell incorporado en shells comunes como bashy zsh, no crea ningún proceso.
Además, no toca ningún tipo de código relacionado con coma flotante, sino solo la manipulación de conjuntos de bytes (explícitamente no caracteres multibyte). Esto suele ser más rápido, a menudo mucho más rápido que el uso de coma flotante.

compatibilidad de printf

A menudo, hay razones para reemplazar printfpor /usr/bin/printfgarantizar la coherencia o compatibilidad. En este caso, creo que podemos usar el incorporado, lo cual es importante, ya que el uso /usr/bin/printfreduce la ventaja "rápida" al bifurcar un proceso.
Un problema común con la printfcompatibilidad es el formato de salida del número según la configuración regional. La separación .de números se puede cambiar ,según la configuración regional; Pero no usamos números, solo una constante de cadena que contiene un literal ., no afectado por la configuración regional.
StéphaneChazelas señaló queprintf %.5s funciona de manera diferente enzsh, contando caracteres, no bytes como de costumbre. Afortunadamente, nuestras constantes usan solo caracteres en el rango ASCII inferior, que está codificado por un byte por carácter en cualquier codificación relevante, siempre que usemos la UTF-8codificación común para Unicode, y no una codificación de ancho fijo.