วิธีการคำนวณจำนวนเต็มและลอยในทุบตีหรือภาษา / กรอบอื่น ๆ ?

การใช้echo "20+5"ข้อความจะสร้างข้อความ " 20+5" อย่างแท้จริง

ฉันสามารถใช้คำสั่งใดในการรับผลรวมตัวเลข25ในกรณีนี้

นอกจากนี้วิธีที่ง่ายที่สุดในการทำเพียงแค่ใช้ bash สำหรับจุดลอยคืออะไร ตัวอย่างเช่นecho $((3224/3807.0))พิมพ์0:(

ฉันกำลังมองหาคำตอบโดยใช้เชลล์คำสั่งพื้นฐาน ('บรรทัดคำสั่ง') เองหรือผ่านการใช้ภาษาที่มีให้จากบรรทัดคำสั่ง

มีตัวเลือกมากมาย !!!

สรุป

$ printf %.10f\\n "$((10**9 * 20/7))e-9"   # many shells. Not mksh.
$ echo "$((20.0/7))"                       # (ksh93/zsh/yash, not bash)
$ awk "BEGIN {print (20+5)/2}"
$ zcalc
$ bc <<< 20+5/2
$ bc <<< "scale=4; (20+5)/2"
$ dc <<< "4 k 20 5 + 2 / p"
$ expr 20 + 5
$ calc 2 + 4
$ node -pe 20+5/2  # Uses the power of JavaScript, e.g. : node -pe 20+5/Math.PI
$ echo 20 5 2 / + p | dc 
$ echo 4 k 20 5 2 / + p | dc 
$ perl -E "say 20+5/2"
$ python -c "print(20+5/2)"
$ python -c "print(20+5/2.0)"
$ clisp -x "(+ 2 2)"
$ lua -e "print(20+5/2)"
$ php -r 'echo 20+5/2;'
$ ruby -e 'p 20+5/2'
$ ruby -e 'p 20+5/2.0'
$ guile -c '(display (+ 20 (/ 5 2)))'
$ guile -c '(display (+ 20 (/ 5 2.0)))'
$ slsh -e 'printf("%f",20+5/2)'
$ slsh -e 'printf("%f",20+5/2.0)'
$ tclsh <<< 'puts [expr 20+5/2]'
$ tclsh <<< 'puts [expr 20+5/2.0]'
$ sqlite3 <<< 'select 20+5/2;'
$ sqlite3 <<< 'select 20+5/2.0;'
$ echo 'select 1 + 1;' | sqlite3 
$ psql -tAc 'select 1+1'
$ R -q -e 'print(sd(rnorm(1000)))'
$ r -e 'cat(pi^2, "\n")'
$ r -e 'print(sum(1:100))'
$ smjs
$ jspl

รายละเอียด

เปลือกหอย

คุณสามารถใช้ POSIX การขยายตัวทางคณิตศาสตร์สำหรับจำนวนเต็มคณิตศาสตร์echo "$((...))":

$ echo "$((20+5))"
25
$ echo "$((20+5/2))"
22

ค่อนข้างพกพา ( ash dash yash bash ksh93 lksh zsh):
การใช้ความสามารถ printf ในการพิมพ์ลอยเราสามารถขยายเชลล์ส่วนใหญ่เพื่อทำคณิตศาสตร์เลขทศนิยมในช่วงที่ จำกัด (ไม่เกิน 10 หลัก):

$ printf %.10f\\n "$((1000000000 *   20/7  ))e-9"
2.8571428570

ksh93, yashและzshทำลอยสนับสนุนที่นี่:

$ echo "$((1.2 / 3))"
0.4

เฉพาะksh93(โดยตรง) และzshโหลดไลบรารี mathfunc ที่นี่:

$ echo "$((4*atan(1)))"
3.14159265358979324

( zshต้องโหลดzmodload zsh/mathfuncเพื่อรับฟังก์ชั่นเหมือนatan)

โต้ตอบกับ zsh:

$ autoload zcalc
$ zcalc
1> PI/2
1.5708
2> cos($1)
6.12323e-17
3> :sci 12
6.12323399574e-17

ด้วย (t) csh (จำนวนเต็มเท่านั้น):

% @ a=25 / 3; echo $a
8

ในrcตระกูลเชลล์akangaคืออันที่มีส่วนขยายทางคณิตศาสตร์:

; echo $:25/3
8

POSIX toolchest

bc(ดูด้านล่างสำหรับโหมดโต้ตอบ), คู่มือที่นี่

Mnemonic: best calculator (แม้ว่าจะbเป็นจริงสำหรับพื้นฐาน )

$ echo 20+5/2 | bc
22
$ echo 'scale=4;20+5/2' | bc
22.5000

(รองรับหมายเลขความแม่นยำโดยพลการ)

bc โหมดการโต้ตอบ:

$ bc
bc 1.06.95
Copyright 1991-1994, 1997, 1998, 2000, 2004, 2006 Free Software Foundation, Inc.
This is free software with ABSOLUTELY NO WARRANTY.
For details type `warranty'. 
5+5
10

2.2+3.3
5.5

โซลูชันของRushexpr (ไม่มีโหมดโต้ตอบ):

$ expr 20 + 5
25
$ expr 20 + 5 / 2
22

ทางออกของโจชัว : awk(ไม่มีโหมดโต้ตอบ):

$ calc() { awk "BEGIN{print $*}"; }
$ calc 1/3
0.333333

เครื่องมือพกพาอื่น ๆ มากหรือน้อย

วิธีแก้ปัญหาของArcegedc (โหมดโต้ตอบ:)dc :

ซึ่งสนุกกว่านี้เพราะทำงานโดยใช้สัญลักษณ์ขัดเงาย้อนกลับ

$ echo 20 5 2 / + p | dc 
22
$ echo 4 k 20 5 2 / + p | dc 
22.5000

แต่ไม่สามารถใช้งานได้จริงเว้นแต่ว่าคุณจะทำงานกับสัญกรณ์ขัดกลับด้านจำนวนมาก

^{โปรดทราบว่าdcมีการถือกำเนิดbcและbcมีการใช้งานในอดีตเป็น wrapper รอบ ๆdcแต่dcไม่ได้มาตรฐานโดย POSIX}

DQdims 's calc(จำเป็นsudo apt-get install apcalc):

$ calc 2 + 4
6

ล่ามภาษาที่ใช้งานทั่วไป:

โซลูชันของmanatworknode (โหมดโต้ตอบ: nodeไม่จำเป็นต้องใช้ฟังก์ชั่นเอาท์พุท):

$ node -pe 20+5/2  # Uses the power of JavaScript, e.g. : node -pe 20+5/Math.PI
22.5

Perl (โหมดโต้ตอบ:) perl -de 1:

$ perl -E "say 20+5/2"
22.5

Python (โหมดโต้ตอบ: pythonไม่จำเป็นต้องใช้ฟังก์ชั่นเอาต์พุต):

$ python -c "print(20+5/2)"
22 # 22.5 with python3
$ python -c "print(20+5/2.0)"
22.5

ยังรองรับตัวเลขที่มีความแม่นยำตามอำเภอใจ:

$ python -c 'print(2**1234)'
295811224608098629060044695716103590786339687135372992239556207050657350796238924261053837248378050186443647759070955993120820899330381760937027212482840944941362110665443775183495726811929203861182015218323892077355983393191208928867652655993602487903113708549402668624521100611794270340232766099317098048887493809023127398253860618772619035009883272941129544640111837184

หากคุณclispติดตั้งแล้วคุณยังสามารถใช้สัญลักษณ์ขัดเงา:

$ clisp -x "(+ 2 2)"

โซลูชันของมาร์โกlua (โหมดโต้ตอบ:) lua:

$ lua -e "print(20+5/2)"
22.5

PHP (โหมดโต้ตอบ:) php -a:

$ php -r 'echo 20+5/2;'
22.5

Ruby (โหมดโต้ตอบ: irbไม่จำเป็นต้องใช้ฟังก์ชั่นเอาต์พุต):

$ ruby -e 'p 20+5/2'
22
$ ruby -e 'p 20+5/2.0'
22.5

Guile (โหมดโต้ตอบ:)guile :

$ guile -c '(display (+ 20 (/ 5 2)))'
45/2
$ guile -c '(display (+ 20 (/ 5 2.0)))'
22.5

S-Lang (โหมดโต้ตอบ: slshฟังก์ชั่นการส่งออกไม่จำเป็นต้องเป็นเพียงแค่;เทอร์มิ):

$ slsh -e 'printf("%f",20+5/2)'
22.000000
$ slsh -e 'printf("%f",20+5/2.0)'
22.500000

Tcl (โหมดโต้ตอบ: tclshไม่จำเป็นต้องใช้ฟังก์ชั่นเอาต์พุต แต่exprเป็น):

$ tclsh <<< 'puts [expr 20+5/2]'
22
$ tclsh <<< 'puts [expr 20+5/2.0]'
22.5

Javascript shells:

$ smjs
js> 25/3
8.333333333333334
js>

$ jspl
JSC: 25/3

RP: 8.33333333333333
RJS: [object Number]
JSC:
Good bye...

$ node
> 25/3
8.333333333333334
>

SQL ต่างๆ:

SQLite (โหมดโต้ตอบ:) sqlite3:

$ sqlite3 <<< 'select 20+5/2;'
22
$ sqlite3 <<< 'select 20+5/2.0;'
22.5

MySQL :

mysql -BNe 'select 1+1'

PostgreSQL :

psql -tAc 'select 1+1

_The ตัวเลือกใน mysql และ postgres หยุดภาพ 'ascii art'!

ภาษาเชิงคณิตศาสตร์เฉพาะทาง:

Rในโหมด plain - อนุญาตให้สร้างตัวเลขสุ่ม 1,000 ปกติแล้วรับส่วนเบี่ยงเบนมาตรฐานแล้วพิมพ์

$ R -q -e 'print(sd(rnorm(1000)))'
> print(sd(rnorm(1000)))
[1] 1.031997

Rใช้สคริปต์littler - อนุญาตให้พิมพ์ pi กำลังสอง

$ r -e 'cat(pi^2, "\n")'
9.869604
$  r -e 'print(sum(1:100))'
[1] 5050

PARI / GPระบบพีชคณิตคอมพิวเตอร์ที่ครอบคลุมสำหรับทฤษฎีจำนวนเชิงพีชคณิตเชิงเส้นและอื่น ๆ อีกมากมาย

$ echo "prime(1000)"|gp -q
7919                        // the 1000th prime
$ echo "factor(1000)" | gp -q
[2 3]
[5 3]                       // 2^3*5^3
$ echo "sum(x=1,5,x)" | gp -q
15                          // 1+2+3+4+5

GNU Octave (ภาษาที่ตีความในระดับสูงมีไว้เพื่อการคำนวณเชิงตัวเลขเป็นหลัก)

รองรับจำนวนเชิงซ้อน:

$ octave
>> 1.2 / 7
ans =  0.17143
>> sqrt(-1)
ans =  0 + 1i

Juliaภาษาที่มีประสิทธิภาพสูงและล่ามสำหรับการคำนวณทางวิทยาศาสตร์และตัวเลข

ตัวเลือกที่ไม่โต้ตอบ:

$ julia -E '2.5+3.7'
6.2

การคำนวณมีหลายวิธี สำหรับนิพจน์อย่างง่ายคุณสามารถใช้bashตัวมันเอง:

echo $((20+5))

หรือexpr:

expr 20 + 5

และสำหรับกรณีที่ซับซ้อนมีเครื่องมือที่ยอดเยี่ยมbc:

echo "20+5" | bc

Btw, bc สามารถคำนวณนิพจน์ที่ซับซ้อนได้อย่างมากกับรูทลอการิทึม cos บาปและอื่น ๆ

โซลูชันที่กล่าวถึงนั้นใช้ได้ผลดีสำหรับการคำนวณอย่างง่าย ๆ แต่มีข้อผิดพลาดมาก ตัวอย่าง:

# without spaces expr 20+5 produces literally 20+5
expr 20+5
→ 20+5

# bc's result doesn't give the fractional part by default
bc <<< 9.0/2.0
→ 4

# expr does only integer
expr 9 / 2
→ 4

# same for POSIX arithmetic expansion
echo $((9/2))
→ 4

# bash arithmetic expansion chokes on floats
echo $((9.0/2.0))
→ bash: 9/2.0: syntax error: invalid arithmetic operator (error token is ".0")

# Most `expr` implementations also have problems with floats
expr 9.0 / 2.0
→ expr: non-integer argument

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

นั่นเป็นเหตุผลที่ฉันใช้ภาษาสคริปต์อย่าง Lua เสมอ แต่คุณสามารถเลือกภาษาสคริปต์ที่คุณคุ้นเคย ฉันแค่ใช้ Lua เป็นตัวอย่าง ข้อดีคือ

• ไวยากรณ์ที่คุ้นเคย
• ฟังก์ชั่นที่คุ้นเคย
• คำเตือนที่คุ้นเคย
• อินพุตที่ยืดหยุ่น
• ช่องว่างมักจะไม่สำคัญ
• เอาท์พุทจุดลอย

ตัวอย่าง:

lua -e "print(9/2)"
→ 4.5

lua -e "print(9 / 2)"
→ 4.5

lua -e "print(9.0/2)"
→ 4.5

lua -e "print (9 /2.)"
→ 4.5

lua -e "print(math.sqrt(9))"
→ 3

ยังไม่มีใครพูดถึง awk เลยเหรอ?

การใช้ฟังก์ชั่นเชลล์ POSIX และพลังคณิตศาสตร์ awk เพียงแค่กำหนดฟังก์ชันนี้ (หนึ่งบรรทัด):

calc(){ awk "BEGIN { print $*}"; }

จากนั้นก็ดำเนินการสิ่งต่าง ๆ เช่นcalc 1+1หรือcalc 5/2

หมายเหตุ: ในการทำให้ฟังก์ชั่นใช้งานได้ตลอดเวลาให้เพิ่มเข้าไปใน ~ / .bashrc (หรือไฟล์เริ่มต้นของเชลล์ที่เกี่ยวข้อง)

แน่นอนว่าสคริปต์เล็ก ๆ ชื่อ "calc" มีเนื้อหาดังต่อไปนี้:

#!/bin/sh -
awk "BEGIN { print $* }"

ยังสามารถทำงานได้

bcคุณสามารถใช้ เช่น,

$ echo "25 + 5" | bc
30

หรือbc <<< 25+5จะใช้งานได้เช่นกัน

หรือโต้ตอบถ้าคุณต้องการทำมากกว่าการคำนวณง่าย ๆ :

$ bc
bc 1.06.95
Copyright 1991-1994, 1997, 1998, 2000, 2004, 2006 Free Software Foundation, Inc.
This is free software with ABSOLUTELY NO WARRANTY.
For details type `warranty'. 
25 + 5
30

การนำ GNU ไปใช้bcพิมพ์ข้อมูลส่วนหัว / ลิขสิทธิ์เมื่อเริ่มต้นเมื่อ stdin และ stdout ไปที่เทอร์มินัล คุณสามารถระงับมันได้ด้วย-qตัวเลือก(เฉพาะ GNU) สำหรับข้อมูลเพิ่มเติมโปรดดูหน้าbc man

คุณสามารถใช้calc:

หากคุณเพิ่งป้อนcalcโดยไม่มีข้อโต้แย้งอื่น ๆ มันจะเข้าสู่โหมดโต้ตอบที่คุณสามารถทำคณิตศาสตร์ต่อไปได้ คุณออกจากสิ่งนี้โดยพิมพ์ exit:

C-style arbitrary precision calculator (version 2.12.3.3)
Calc is open software. For license details type:  help copyright
[Type "exit" to exit, or "help" for help.]

; 2+4
6
; 3+5
8
; 3.4+5
8.4
; 2^4
16
; exit

หรือคุณใช้กับนิพจน์เป็นอาร์กิวเมนต์และมันจะให้คำตอบแล้วออก

$calc 2 + 4
    6
$

calcคล้ายกับbcฉันแค่ชอบวิธีที่มันทำงานเป็นค่าเริ่มต้นที่ดีกว่า

ฉันชอบใช้ Python และใช้เป็นเครื่องคิดเลขแบบโต้ตอบ (แต่หลังจากนั้นฉันเป็นโปรแกรมเมอร์ Python)

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

$ units "1 + 1"
        Definition: 2
$ units "1 lb" "kg"
        * 0.45359237
         / 2.2046226

หรือสำหรับเอาต์พุตที่น้อยลงคุณจะได้รับเพียงจำนวนที่ใช้ใน$()การกำหนดให้กับบางสิ่ง:

$ units -t "1 + 1"
2
$ units -t "1 lb" "kg"
0.4539237

และยังแปลงอุณหภูมิ

$ units -t "tempC(20)" "tempF"
68

ในการรับการแปลงอุณหภูมิในนิพจน์สำหรับการคำนวณเพิ่มเติมให้ทำดังนี้

$ units -t "~tempF(tempC(20))+1"
68.1

$> ghc -e '20 + 5'
25
it :: Integer

นอกจากนี้ghciนั่นคือGlasgow-Haskell Compilerในโหมดอินเทอร์แอคทีฟ ( ghc --interactiveตรงข้ามกับที่ประเมินการแสดงออกด้วย-e) ทำให้เป็น "เครื่องคิดเลข" ที่น่าสนใจ:

$>ghci
GHCi, version 7.8.3: http://www.haskell.org/ghc/  :? for help
Loading package ghc-prim ... linking ... done.
Loading package integer-gmp ... linking ... done.
Loading package base ... linking ... done.
Prelude> pi
3.141592653589793
Prelude> ceiling pi
4
Prelude> compare 1 2
LT

ฉันไม่อยากจะเชื่อในการอ่าน "พลังของ JavaScript" (แต่ฉันต้อง upvote คำตอบสำหรับส่วนอื่น ๆ ยกเว้น perl แน่นอน

ในทางปฏิบัติสำหรับกรณีง่าย ๆ ที่เลขจำนวนเต็มเพียงพอฉันใช้ buildin $ ((... )) และแนะนำ อื่นในเกือบทุกกรณี echo "... " | bc ก็เพียงพอแล้ว

สำหรับการดำเนินการทางคณิตศาสตร์บางอย่างเช่นสถิติการดำเนินการเมทริกซ์และอื่น ๆRเป็นเครื่องมือที่ดีกว่า:

echo 25 + 5 | R --vanilla

และสำหรับชุดข้อมูลขนาดเล็กและกราฟิกโยนออกผลoocalcเป็นสาธารณูปโภคที่ดี

ฉันใช้สคริปต์งูหลามเล็ก ๆ น้อย ๆ ที่จะประเมินการแสดงออกของงูหลามและพิมพ์ผลลัพธ์จากนั้นฉันก็สามารถเรียกใช้บางอย่างเช่น

$ pc '[i ** 2 for i in range(10)]'
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

สคริปต์คือ:

#!/usr/local/bin/python3

import sys
import traceback
from codeop import CommandCompiler

compile = CommandCompiler()
filename = "<input>"
source = ' '.join(sys.argv[1:]) + '\n'

try:
    code = compile(source, filename) 
except (OverflowError, SyntaxError, ValueError):
    type, value, sys.last_traceback = sys.exc_info()
    sys.last_type = type
    sys.last_value = value
    if filename and type is SyntaxError:
        # Work hard to stuff the correct filename in the exception
        try:
            msg, (dummy_filename, lineno, offset, line) = value.args
        except ValueError:
            # Not the format we expect; leave it alone
            pass
        else:
            # Stuff in the right filename
            value = SyntaxError(msg, (filename, lineno, offset, line))
            sys.last_value = value
    lines = traceback.format_exception_only(type, value)
    print(''.join(lines))
else:
    if code:
        exec(code)
    else:
        print('incomplete')

น่าเสียดายที่ฉันจำไม่ได้ว่าฉันยืมรหัสมาจากที่ไหนส่วนใหญ่ดังนั้นฉันจึงไม่สามารถอ้างอิงได้

gnuplot

gnuplot - โปรแกรมพล็อตแบบโต้ตอบไป
ตามลิงก์ด้านบนหรือพิมพ์gnuplotแบบฟอร์มแจ้งจากนั้นhelpภายในล่าม gnuplot
Gnuplotเป็นโปรแกรมที่เกิดจากการลงจุดข้อมูล แต่สามารถใช้สำหรับการคำนวณได้เช่นกัน มันมีข้อได้เปรียบที่คุณสามารถกำหนดฟังก์ชั่นและหรือใช้ฟังก์ชั่นในตัว

echo  "pr 20+5/2"  |  gnuplot          #  Lazy-note `pr` instead of print
22                                     #  Integer calculation & result
echo  "pr 20.+5/2"  |  gnuplot         #  Lazy-note `pr` instead of print
22.0                                   #  Floating point result
echo  "pr sin(2*pi/3.)"  |  gnuplot    #  Some functions ...
0.866025403784439

รูท (หรือล่าม Cอื่น ๆ)

ระบบรากมีชุดกรอบ OO กับทุกฟังก์ชั่นที่จำเป็นในการจัดการและวิเคราะห์ข้อมูลจำนวนมากในวิธีที่มีประสิทธิภาพมาก ...

คุณสามารถใช้มันเป็นล่าม C , CINTหรือใช้หนึ่งในล่าม C อื่น ๆมากมาย IMHO มันใหญ่ซับซ้อนซับซ้อนและไม่เป็นมิตรเสมอไป แต่ก็สามารถสร้างความพึงพอใจอย่างมากเช่นกัน

หากคุณไม่ต้องการฟังเสียงเล็ก ๆ ในตัวคุณที่อ้างว่าConfucioและคุณพร้อมที่จะทำลาย (เนย) บินไปบนพวงมาลัยคุณสามารถใช้รูทได้ ในกรณี-lนี้จำเป็นต้องหลีกเลี่ยงการแสดงหน้าจอ ...

echo  "20+5/2"   | root -l
(const int)22
echo  "20+5/2."  | root -l
(const double)2.25000000000000000e+01

echo  "cout<< 20+5/2 << endl;"   | root -l
22

สำหรับเลขจำนวนเต็ม (โดยที่ 3/2 = 1)

• bash echo $(( 1+1 ))
• fish math 1+1
• zsh* echo $((1+1))

*: และ ksh93, yash

สำหรับเลขคณิตทศนิยม (โดยที่ 3/2 = 1.5)

• bash awk "BEGIN {print 10/3}" (ความแม่นยำต่ำ)
• bash echo "10/3"|bc -l (ความแม่นยำสูง)
• fish math -s4 10/3
• zsh* echo $((10./3))

*: และ ksh93, yash

แน่นอนคุณสามารถกำหนดค่าเปลือกของคุณเพื่อใช้ awk ด้วยการพิมพ์ขั้นต่ำเช่นcalc 10/3(ดูหมายเหตุเกี่ยวกับวิธีการทำมันสำหรับทุบตี¹และปลา² )

เหตุผลหลักในการแนะนำ awk สำหรับ bash ก็คือมันติดตั้งไว้แล้วในระบบปฏิบัติการ Unix ที่เหมือนยูนิกซ์เกือบทั้งหมดและเบาพอสมควร (แน่นอนว่ามีค่าใช้จ่ายในการเริ่มต้นกระบวนการ) ด้วยเอาต์พุตที่แม่นยำน้อยกว่า แต่เป็นมิตรต่อมนุษย์มากกว่าbc -lพิมพ์ทศนิยม 20 ตัว ตัวเลข (แม้ว่าคุณสามารถปรับแต่ง awk เพื่อรับทศนิยมได้มากกว่า )

หมายเหตุ

(1) วิธีใช้งานไวยากรณ์ที่ง่ายในการทุบ

เพิ่มฟังก์ชั่นทุบตีนี้ของคุณ~/.bashrc:

calc(){ awk "BEGIN { print $*}"; }

(2) วิธีการใช้ซินแท็กซ์แบบง่ายในปลา

สร้างcalcฟังก์ชั่นปลา (เช่นชื่อไฟล์ข้อความ/home/ndemou/.config/fish/functions/calc.fish):

function calc
    awk "BEGIN{ print $argv }" ;
end

concalcสำหรับการคำนวณคอนโซลผมใช้ ( sudo aptitude install concalc)

หลังจากนั้นเพียงพิมพ์concalc และกด Enter มันจะไม่ให้พรอมต์ แต่เพียงพิมพ์ในการคำนวณของคุณ (ไม่มีช่องว่าง) และกด Enter และในบรรทัดถัดไปมันจะให้ค่าตัวเลข

SQLite :

echo 'select 1 + 1;' | sqlite3 

MySQL :

mysql -e 'select 1 + 1 from dual;'

PostgreSQL :

psql -c 'select 1 + 1 as sum;'

ใช้ไลบรารีความแม่นยำทางคณิตศาสตร์หลาย GNUผ่านrun-exprโปรแกรมที่ให้มา:

• ดาวน์โหลดและแตกไฟล์ (คุณต้องใช้ lzip): tar -xvf gmp-5.1.3.tar.lz
• ในไดเรกทอรีบนสุด./configureและmake(ไม่จำเป็นต้องติดตั้ง)
• ในการสาธิต / expr make run-expr
• ฉันชอบที่จะสร้างลิงค์สัญลักษณ์ใน~/binไดเรกทอรีของฉัน:ln -s /path/to/gmp/demos/expr/run-expr ~/bin/run-expr
• เพิ่มนามแฝงสำหรับใช้งานง่าย; เช่นalias calcf='run-expr -f'การประเมินจุดลอย

เอาท์พุท:

# calcf '2/3'
"2/3" base 0: result 0.666666666666666666667e0

จากrun-expr.cไฟล์:

Usage: ./run-expr [-z] [-q] [-f] [-p prec] [-b base] expression...

   Evaluate each argument as a simple expression.  By default this is in mpz
   integers, but -q selects mpq or -f selects mpf.  For mpf the float
   precision can be set with -p.  In all cases the input base can be set
   with -b, or the default is "0" meaning decimal with "0x" allowed.

ดูคู่มือสำหรับความแตกต่างของคลาสฟังก์ชั่นและรายละเอียด