ฉันจะพิมพ์ pi (3.14159) ได้อย่างไร [ปิด]

คำสั่งใดที่สามารถพิมพ์ pi ให้ฉันได้? ฉันต้องการระบุจำนวนหลักที่พิมพ์ฉันไม่พบสิ่งใดทางออนไลน์ ฉันแค่อยากจะพิมพ์ปี่

คุณสามารถใช้คำสั่งนี้:

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

โดยที่ scale คือจำนวนของตัวเลขหลังจุดทศนิยม

การอ้างอิง: http://www.tux-planet.fr/calculer-le-chiffre-pi-en-ligne-de-commande-sous-linux/

หากคุณtex(1)ติดตั้งแล้ว:

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

สำหรับการพิมพ์ด้วยความแม่นยำโดยพลการคุณสามารถใช้bcและสูตรpi = 4*atan(1):

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

หากคุณต้องการบางสิ่งที่สามารถคำนวณค่าของπได้นั้นมีหลายวิธี บางทีทางออกที่ชัดเจนที่สุดคือการใช้แพคเกจสำเร็จรูปเช่นpi(ลิงก์แพ็กเกจ Debian)ซึ่งหากคำอธิบายแพคเกจของ Debian เชื่อถือได้สามารถคำนวณค่าให้แม่นยำโดยมีข้อ จำกัด โดยหน่วยความจำเท่านั้น

piเป็นจริงตัวอย่างเช่นที่มาพร้อมกับที่ห้องสมุด CLN (ไลบรารีคลาสสำหรับเบอร์) มันมีตัวอย่างแอพพลิเคชั่นที่ให้เครื่องมือในการสร้างความยาวของตัวเลขเช่น Pi, Fibonacci และอื่น ๆ แพ็คเกจ CLN นั้นมีอยู่ในแพ็คเกจล่วงหน้าใน Debian / Ubuntu (นั่นคือสิ่งที่ลิงก์ Debian ด้านบนชี้)

$ ./pi 10
3.141592653

$ ./pi 20
3.1415926535897932384

หมายเหตุ:แหล่งที่มาของตัวอย่างเหล่านี้คือที่นี่ในแหล่งสำหรับฐานรหัส CLN ที่

สิ่งรบกวนอื่น ๆ

ใน Fedora ฉันต้องดาวน์โหลด tarball ต้นฉบับและสร้างด้วยตัวเอง แต่มันสร้างด้วยความยุ่งยากเล็กน้อย ไม่ว่าจะด้วยเหตุผลใดก็ตามแพ็คเกจclnใน Fedora มีเพียงแค่ห้องสมุด แต่ละเลยตัวอย่างที่มีอยู่ในรุ่น Debian / Ubuntu (ด้านบน)

ประตูชัยให้โปรแกรมเดียวกันในแพคเกจ (ขอบคุณAmphiteót )cln

มากถึงหนึ่งล้านหลักคุณสามารถใช้ต่อไปนี้ (ที่นี่สำหรับ 3000 หลัก):

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

คำตอบอื่น ๆ บางส่วนแสดงตัวเลขที่ไม่ถูกต้องในตำแหน่งสุดท้ายของผลลัพธ์ ด้านล่างนี้เป็นรูปแบบของคำตอบที่ใช้bcแต่มีผลลัพธ์ที่ถูกต้อง ตัวแปรsประกอบด้วยจำนวนของตัวเลขที่มีนัยสำคัญ (รวมถึง3ด้านหน้าของจุดทศนิยม)

ปัดครึ่งขึ้น

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

ปัดเศษ (ตัด)

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

คำอธิบายของการปัดเศษ

bcปัดเศษจะดำเนินการโดยตรงใน สิ่งนี้ไม่มีข้อ จำกัด ของคำสั่งprintfที่ใช้การแทนค่าdoubleชนิดภาษา C สำหรับตัวเลขที่มีความแม่นยำประมาณ 17 หลักสำคัญ ดูคำตอบที่มีprintfการปัดเศษ

scale=s-1ตั้งค่าจำนวนหลักเพื่อตัดให้เป็น pi/1หารผลลัพธ์ด้วย 1 เพื่อใช้การตัด Simple piไม่ตัดทอนตัวเลข

การปัดเศษครึ่งขึ้นต้องเพิ่ม 5 หลักแรกซึ่งจะถูกตัดออก (5 × 10- ^s ) ดังนั้นในกรณีที่ตัวเลขที่สูงกว่าเท่ากับ 5 หลักสุดท้ายซึ่งจะยังคงเพิ่มขึ้น

จากการทดสอบโดย hobbsดูเหมือนว่าตัวเลขสามหลักเพิ่มเติมซึ่งจะถูกปัดเศษ / ตัด ( scale=s+2) จะพอเพียงสำหรับตัวเลขที่ยาวมาก

นี่คือสตริง

ตัวอย่างข้างต้นการใช้งานที่นี่สตริงซึ่งได้รับการสนับสนุนเช่นในbash, และksh zshหากเชลล์ของคุณไม่รองรับการใช้สตริงechoและไพพ์แทน:

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

Perl หนึ่งบรรทัด (ใช้bignum ):

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

เช่น

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

ด้วย python2:

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

ใช้ทับทิม:

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

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

3.141592654

ในทุบตี:

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

ง่ายมากใน PHP โดยใช้ฟังก์ชั่น pi ():

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

ฉันคิดถึงคำถามนี้ได้อย่างไร ...

นี่เป็นโปรแกรม Python pi เล็กน้อยของฉันที่ฉันโพสต์เมื่อไม่กี่สัปดาห์ที่ผ่านมาใน Stack Overflow มันไม่ได้โดยเฉพาะอย่างยิ่งได้อย่างรวดเร็ว แต่ก็สามารถทำจำนวนมากของตัวเลข :) อย่างไรก็ตามตามที่ฉันกล่าวถึงในหัวข้อนั้นโดยทั่วไปฉันใช้โมดูล mpmath ของ Python สำหรับการคำนวณทางคณิตศาสตร์ที่มีความแม่นยำตามอำเภอใจและ mpmath มีผู้สร้าง pi ที่ค่อนข้างเร็ว

เช่น,

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

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

500000 ทศนิยมของ pi ภายใน 5 วินาทีนั้นไม่โทรมเกินไป IMHO เมื่อพิจารณาว่ามันทำงานบนเครื่องที่มีหน่วยประมวลผล 2GHz แกนเดียว, RAM 2 กิ๊กและเขียนไปยังไดรฟ์ IDE รุ่นเก่า

หากคุณnode.jsติดตั้งสิ่งนี้จะทำให้ดีที่สุดในการค้นหา pi ให้คุณ

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

ตัวอย่างผลลัพธ์:

3.14157749
3.1416426
3.14159055
3.14171554
3.14176165
3.14157587
3.14161137
3.14167685
3.14172371

วิธีมอนติคาร์โล

ดูตัวอย่างนี้สำหรับคำอธิบายของวิธีนี้

คำเตือน

• ไม่ถูกต้องตามอำเภอใจ
• ใช้เวลานานในการรวมเข้ากับสิ่งที่มีประโยชน์

ข้อดี

สนุก :-)

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

หมายเหตุ: ฉันพยายามครั้งแรกโดยไม่ต้องsrandติดอยู่กับที่3.14และหลังจากนั้นตัวเลขก็ยังคงสั่นอยู่ไม่เคยมาบรรจบกัน อาจเป็นเพราะหลังจากนั้นไม่นาน PRNG ก็เริ่มทำซ้ำตัวเอง การใช้srandจะหลีกเลี่ยงอย่างนั้นหรืออย่างน้อยก็ยืดระยะเวลาของลำดับหลอกสุ่ม นี่คือการคาดเดาทั้งหมดดังนั้นโปรดแก้ไขให้ฉันถ้าฉันผิด

คุณสามารถใช้อัลกอริทึมเดือยสำหรับ pi โปรแกรม C ต่อไปนี้โดย Dik Winter และ Achim Flammenkamp จะสร้าง pi จำนวน 15,000 หลักแรกต่อครั้ง

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

ตัวอย่างไม่กี่:

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

หากคุณต้องการเปลี่ยนความแม่นยำลอง:

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

ขนาดของการลอยขึ้นอยู่กับแพลตฟอร์มแม้ว่าสูงสุด ~ 1.8e308 ที่มีความแม่นยำประมาณ 14 หลักทศนิยมเป็นค่าทั่วไป (รูปแบบ IEEE 64 บิต) [อ่านเพิ่มเติม]

หากคุณกำลังมองหาความแม่นยำที่แม่นยำยิ่งขึ้นให้ตรวจสอบRosetta CodeหรือCode Golf SEสำหรับวิธีแก้ไขปัญหาการเขียนโปรแกรมบางอย่าง

ที่เกี่ยวข้อง: ซอฟต์แวร์ที่สามารถคำนวณ PI อย่างน้อยหนึ่งพันหลักที่ SR.SE

นี่คือสคริปต์ที่พิมพ์ pi ตามจำนวนตัวเลขที่ระบุ (รวมถึง '.') โดยผู้ใช้

pi.sh

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

เอาท์พุต

$ ./pi.sh 10
3.14159265

และมีค่าเริ่มต้น:

$ ./pi.sh
3.14159

ฉันเคยเห็นคนที่ใช้scaleเป็นbcตัวเลือก แต่ในกรณีของฉัน ( bc 1.06.95) สิ่งนี้จะไม่ส่งออกค่าที่ถูกต้อง:

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

สังเกตุตัวเลขตัวสุดท้าย

ฉันชอบคำตอบของ Abey แต่ไม่ชอบวิธีที่ bc เปลี่ยนเลขหลักสุดท้าย

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

ดังนั้นฉันจึงลบสเกลที่ใช้ printf เพื่อตั้งค่าจำนวนหลัก

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

เกิดอะไรขึ้นถ้าคุณไม่สามารถสำหรับชีวิตของคุณจำไว้ว่านี้arctanสิ่งที่? หรือสมมุติว่าคุณไม่รู้ด้วยซ้ำว่ามีฟังก์ชั่นนี้อยู่bcจากนั้นลองจดจำการหารง่ายๆนี้:

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

จะใช้งานได้เพียง 6 หลัก แต่สำหรับการคำนวณที่ไม่ใช่ทางวิทยาศาสตร์จะทำได้ดี

หากคุณคิดว่าคุณจำตัวเลขสองตัวนี้ไม่ได้ให้เขียนตัวส่วนก่อนจากนั้นจึงเป็นตัวเศษ:

113 355

หรือทำไมไม่

11 33 55

"double 1, double 3, double 5" ตัวเลขทั้งหมดเป็นเลขคี่ ในการคำนวณให้แบ่งจำนวน 6 หลักครึ่งและสลับส่วนและตัวเศษก่อนหาร เกี่ยวกับมัน.

มันสามารถสันนิษฐานได้ว่า OP มีความสนใจในคำสั่งเชลล์สั้น ๆ และง่ายต่อการจดจำเพื่อพิมพ์π - แต่คำถามไม่ได้พูดอย่างนั้น คำตอบนี้ละเลยข้อสันนิษฐานนั้นและตอบคำถามอย่างเคร่งครัดตามที่เขียนไว้;

จิ๊บจ๊อย?

ในขณะที่มีคำตอบอยู่แล้ว 18 คำตอบแนวทางหนึ่งยังคงหายไป - และด้วยคำตอบมากมายมันอาจคิดว่ามันไม่ใช่วิธีเดียวที่ขาดหายไป:
ความรู้เล็กน้อย: วิธีการพิมพ์π? เพียงพิมพ์π!

วิธีการนั้นดูเหมือนจะไร้ประโยชน์เกินกว่าที่จะคิดเกี่ยวกับมัน แต่ฉันจะแสดงให้เห็นว่ามันมีความสนุกสนาน:

เพิ่มประสิทธิภาพ

ปกติแล้วเราจะคำนวณค่าของπ ฉันไม่เห็นสิ่งที่ทำให้เราไม่สามารถเพิ่มประสิทธิภาพโซลูชันโดยการคำนวณค่าล่วงหน้า - เป็นค่าคงที่คอมไพเลอร์ใด ๆ จะทำเช่นนั้น

เราต้องการตัวเลขจำนวน of บางส่วนเพื่อความแม่นยำสูงสุด ดังนั้นเราจึงสามารถใช้คำนำหน้าของค่าคงที่เป็นข้อความ:

echo 3.1415926535897932384626433832795 | cut -b -7
3.14159

ตัวแปรที่มีอาร์กิวเมนต์ชัดเจนสำหรับความแม่นยำเช่น เพื่อความแม่นยำ5:

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

ข้อดี

ความแม่นยำสูงสุดสามารถเลือกได้เองโดยใช้ค่าคงที่ที่เหมาะสมซึ่งคำนวณโดยใช้หนึ่งในคำตอบอื่น มันถูก จำกัด ด้วยความยาวสูงสุดของบรรทัดคำสั่ง
มันมีความซับซ้อนของเวลาคงที่สำหรับการค้นหาค่า
มันทำให้ข้อ จำกัด และข้อ จำกัด ทั้งหมดชัดเจนขึ้นอยู่กับความซับซ้อนต่ำของการใช้งาน
มันจัดการกับความแม่นยำที่ใหญ่กว่าค่าสูงสุดอย่างสง่างามโดยการคืนค่าคงที่ในความแม่นยำเต็มรูปแบบที่มีอยู่ (โดยไม่ต้องต่อท้าย0)
ดังนั้นวิธีแก้ปัญหานี้ในขณะที่เล็กน้อยก็มีข้อดี มันอาจมีประโยชน์เมื่อมันถูกใช้ในฟังก์ชันเชลล์เช่น

ต่ำสุด

ฟังก์ชันการทำงานของโซลูชันด้านบนสามารถใช้งานได้โดยไม่ต้องสร้างกระบวนการสำหรับcut(สมมติว่าechoเป็นเชลล์ในตัว) มันใช้คำสั่งprintf(ปกติเป็น builtin) ในทางที่ค่อนข้างคลุมเครือ:
ค่าคงที่จะถูกจัดเรียงอย่างสมบูรณ์เป็นสตริง (รูปแบบที่ใช้%s) ไม่มีจุดลอยตัวที่เกี่ยวข้องกับคณิตศาสตร์ดังนั้นข้อ จำกัด ของfloatหรือdoubleไม่ใช้ที่นี่
ค่าความแม่นยำของการ%sหลบหนี ( 5ในตัวอย่างด้านล่าง) ระบุความยาวของคำนำหน้าสตริงที่จะพิมพ์ - ซึ่งเป็นความแม่นยำ 3.เป็นส่วนหนึ่งของprintfรูปแบบที่จะให้มันออกมาจากการคำนวณที่มีความแม่นยำ

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

ทางเลือกที่มีความแม่นยำเป็นอาร์กิวเมนต์แยกต่างหาก:

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

หรือสามารถอ่านได้มากขึ้นเล็กน้อย (โปรดสังเกตช่องว่างระหว่าง3.และกับ14159...พวกเขาเป็นอาร์กิวเมนต์ที่แยกต่างหาก):

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

รวดเร็ว

การใช้ตัวแปรprintfสามารถคาดว่าจะเร็วมาก: เนื่องจากprintfเชลล์มีอยู่แล้วภายในเชลล์ทั่วไปbashและzshไม่สร้างกระบวนการใด ๆ
นอกจากนี้มันจะไม่แตะต้องรหัสที่เกี่ยวข้องกับจุดลอยตัวใด ๆ แต่จะจัดการเฉพาะอาร์เรย์ไบต์เท่านั้น (ไม่ใช่อักขระหลายไบต์อย่างชัดเจน) โดยทั่วไปแล้วจะเร็วกว่าหรือเร็วกว่าการใช้จุดลอยตัวมาก

ความเข้ากันได้ printf

บ่อยครั้งมีเหตุผลที่จะแทนที่ printfด้วย /usr/bin/printfเพื่อรับประกันความสอดคล้องหรือเข้ากันได้ ในกรณีนี้ฉันคิดว่าเราสามารถใช้ builtin ซึ่งเป็นสิ่งสำคัญเนื่องจากการใช้/usr/bin/printfช่วยลดข้อได้เปรียบ "เร็ว" โดยการทำกระบวนการ
ปัญหาทั่วไปเกี่ยวกับprintfความเข้ากันได้คือรูปแบบเอาต์พุตตัวเลขขึ้นอยู่กับโลแคล การแยก.ตัวเลขสามารถเปลี่ยนแปลงได้,ตามการตั้งค่าภาษา แต่เราไม่ใช้ตัวเลขเพียงค่าคงที่สตริงที่มีตัวอักษร.- ไม่ได้รับผลกระทบจากสถานที่เกิดเหตุ
StéphaneChazelasชี้ให้เห็นว่าการprintf %.5sทำงานแตกต่างกันzshโดยการนับอักขระไม่ใช่ไบต์ตามปกติ โชคดีที่ค่าคงที่ของเราใช้เฉพาะอักขระในช่วง ASCII ที่ต่ำกว่าซึ่งถูกเข้ารหัสโดยหนึ่งไบต์ต่ออักขระในการเข้ารหัสที่เกี่ยวข้องตราบใดที่เราใช้การUTF-8เข้ารหัสทั่วไปสำหรับ Unicode ไม่ใช่การเข้ารหัสความกว้างคงที่