පූර්ණ හෝ පාවෙන ගණනය කිරීම්, බාෂ් හෝ වෙනත් භාෂා / රාමු වලින් කරන්නේ කෙසේද?

echo "20+5"වචනාර්ථයෙන් භාවිතා කිරීමෙන් පෙළ " 20+5" නිපදවයි .

25මේ අවස්ථාවේ දී සංඛ්‍යාත්මක මුදල ලබා ගැනීමට මට භාවිතා කළ හැකි විධානය කුමක්ද?

එසේම, පාවෙන ස්ථානය සඳහා බාෂ් භාවිතා කරමින් එය කිරීමට පහසුම ක්‍රමය කුමක්ද? උදාහරණයක් ලෙස, 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
$ gs -q  <<< "5 2 div 20 add  ="

විස්තර

ෂෙල් වෙඩි

පූර්ණ සංඛ්‍යා අංකනය සඳහා ඔබට POSIX අංක ගණිත ප්‍රසාරණය භාවිතා කළ හැකිය echo "$((...))":

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

ඉතා අතේ ගෙන යා හැකි ( ash dash yash bash ksh93 lksh zsh):
පාවෙන මුද්‍රණය කිරීමේ මුද්‍රණ හැකියාව භාවිතා කරමින් සීමිත පරාසයක් සහිතව (ඉලක්කම් 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 මෙවලම් කට්ටලය

bc(අන්තර්ක්‍රියාකාරී මාදිලිය සඳහා පහත බලන්න), අත්පොත මෙතැනින්

සිහිවටන : 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

රෂ්ගේ විසඳුම, expr(අන්තර්ක්‍රියාකාරී මාදිලියක් නොමැත):

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

යෝෂුවාගේ විසඳුම : awk(අන්තර්ක්‍රියාකාරී මාදිලියක් නැත):

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

අතේ ගෙන යා හැකි වෙනත් මෙවලම්

Arcege ගේ විසඳුම, dc(අන්තර්ක්‍රියාකාරී මාදිලිය :)dc :

ප්‍රතිලෝම පොලිෂ් අංකනය මඟින් ක්‍රියා කරන බැවින් එය වඩාත් විනෝදජනක වේ.

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

නමුත් ඔබ ප්‍රතිලෝම පොලිෂ් අංකනය සමඟ වැඩ කරන්නේ නම් මිස ප්‍රායෝගික නොවේ.

^{බව සටහන dcආරම්භ වීමට bcහා bcඑය දවටනය පමණ ලෙස ඓතිහාසිකව ක්රියාත්මක කර ඇති dcනමුත්, dcPOSIX විසින් ප්රමාණ නොවේ}

DQdims ගේ calc(අවශ්‍ය sudo apt-get install apcalc):

$ calc 2 + 4
6

පොදු අරමුණු භාෂා පරිවර්තකයන්:

manatwork හි විසඳුම, node(අන්තර්ක්‍රියාකාරී මාදිලිය : node; ප්‍රතිදාන ශ්‍රිතය අවශ්‍ය නොවේ):

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

පර්ල් (අන්තර්ක්‍රියාකාරී මාදිලිය :)perl -de 1 :

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

පයිතන් (අන්තර්ක්‍රියාකාරී මාදිලිය : 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

රූබි (අන්තර්ක්‍රියාකාරී මාදිලිය : irb; ප්‍රතිදාන ශ්‍රිතය අවශ්‍ය නොවේ):

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

වංචාව (අන්තර්ක්‍රියාකාරී මාදිලිය :)guile :

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

එස්-ලැන්ග් (අන්තර්ක්‍රියාකාරී මාදිලිය : 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

ජාවාස්ක්‍රිප්ට් ෂෙල් වෙඩි:

$ 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

_ MySQL සහ postgres හි ඇති විකල්පයන් 'ascii art' රූපය නවත්වයි!

විශේෂිත ගණිත-නැඹුරු භාෂා:

සරල මාදිලියේ R - සාමාන්‍ය අහඹු සංඛ්‍යා 1000 ක් ජනනය කර සම්මත අපගමනය ලබා ගෙන එය මුද්‍රණය කිරීමට ඉඩ දෙන්න

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

R කුඩා පිටපත භාවිතා කරමින් - 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 -E '2.5+3.7'
6.2

හොස්ට් ස්ක්‍රිප්ට් යනු හොස්ට් ස්ක්‍රිප්ට් යනු පෝස්ට් ස්ක්‍රිප්ට් පරිවර්තකයෙකි. සහාය දක්වන ගණිත විධාන ලැයිස්තුවක් සඳහා PostScript ලියකියවිලි
බලන්න .

අන්තර්ක්‍රියාකාරී උදාහරණය:

$ GS_DEVICE=display gs
GPL Ghostscript 9.07 (2013-02-14)
Copyright (C) 2012 Artifex Software, Inc.  All rights reserved.
This software comes with NO WARRANTY: see the file PUBLIC for details.
GS>5 2 div 20 add  =
22.5
GS>

ගණනය කිරීමට බොහෝ ක්‍රම තිබේ. සරල ප්‍රකාශන සඳහා ඔබට bashඑයම භාවිතා කළ හැකිය:

echo $((20+5))

හෝ expr:

expr 20 + 5

සංකීර්ණ අවස්ථාවන් සඳහා විශිෂ්ට මෙවලමක් ඇත bc:

echo "20+5" | bc

Btw, bc හට මුල්, ල ar ු ගණක, කොස්, පාපය සහ යනාදිය සමඟ ඉතා සංකීර්ණ ප්‍රකාශනයක් පවා ගණනය කළ හැකිය.

කිසිවෙකු තවමත් අමුතු ලෙස සඳහන් කර නැත?

POSIX shell කාර්යයන් සහ awk ගණිත බලය භාවිතා කරමින් මෙම (එක් පේළියක්) ශ්‍රිතය අර්ථ දක්වන්න:

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

ඉන්පසු calc 1+1හෝ වැනි දේ ක්‍රියාත්මක කරන්නcalc 5/2

සටහන: ශ්‍රිතය සැමවිටම ලබා ගැනීමට, එය ~ / .bashrc වෙත එක් කරන්න (හෝ ඔබේ අනුරූප කවචයේ ආරම්භක ගොනුව)

ඇත්ත වශයෙන්ම, පහත සඳහන් අන්තර්ගතයන් සහිත "කැල්ක්" නම් කුඩා පිටපතක්:

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

වැඩ කරන්නත් පුළුවන්.

සඳහන් කළ විසඳුම් ඉතා සරල ගණනය කිරීම් සඳහා හොඳයි, නමුත් ඉතා දෝෂ සහිතයි. උදාහරණ:

# 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 -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

ඔබට භාවිතා කළ හැකිය 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

bcආරම්භයේ දී ශීර්ෂකය / ප්‍රකාශන හිමිකම් තොරතුරු මුද්‍රණය කිරීම GNU ක්‍රියාත්මක කිරීම, එහි stdin සහ stdout යන දෙකම පර්යන්තයකට යන විට. (GNU- විශේෂිත) -qවිකල්පය සමඟ ඔබට එය යටපත් කළ හැකිය. වැඩි විස්තර සඳහා bc man පිටුව බලන්න

ඔබට භාවිතා කළ හැකිය calc:

ඔබ calcවෙනත් තර්කයකින් තොරව ඇතුළු වන්නේ නම් එය අන්තර්ක්‍රියාකාරී මාදිලියකට ඇතුළු වන අතර එහිදී ඔබට ගණිතය දිගටම කරගෙන යා හැකිය. පිටවීම ටයිප් කිරීමෙන් ඔබ මෙය පිට කරයි:

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, මම කැමතියි එය පෙරනිමියෙන් වඩා හොඳින් හැසිරෙන ආකාරයට

මම කැමතියි පයිතන් ගිනි තබා එය අන්තර්ක්‍රියාකාරී කැල්කියුලේටරයක් ​​ලෙස භාවිතා කිරීමට (නමුත් නැවතත්, මම පයිතන් ක්‍රමලේඛකයෙක්).

වෙනත් කිසිවෙකු එය සඳහන් කර නැති නිසාත්, එය තදින්ම කැල්කියුලේටරයක් ​​නොවූවත් (නමුත් මේ සියල්ලම පොදු අරමුණු සහිත ස්ක්‍රිප්ටින් භාෂා නොවේ), මම සඳහන් කිරීමට කැමතියි 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, එය අන්තර්ක්‍රියාකාරී මාදිලියේ ග්ලාස්ගෝ-හැස්කල් සම්පාදකයා වේ ( 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

පූර්ණ සංඛ්‍යා ගණිතය සඳහා (එහිදී 3/2 = 1)

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

*: සහ ksh93, යෂ්

පාවෙන ලක්ෂ්‍ය අංක ගණිතය සඳහා (එහිදී 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, යෂ්

අවම වශයෙන් ටයිප් කිරීම වැනි අමුතු භාවිතා කිරීමට ඔබට ඔබේ කවචය වින්‍යාසගත කළ හැකිය calc 10/3(බාෂ් ¹ සහ මාළු ² සඳහා එය කරන්නේ කෙසේද යන්න පිළිබඳ සටහන් බලන්න ).

බාෂ් සඳහා අවදි වීම යෝජනා කිරීමට ප්‍රධාන හේතුව වන්නේ එය යුනික්ස් වැනි සියලුම මෙහෙයුම් පද්ධති වල පූර්ව ස්ථාපනය කර bc -lඇති අතර එය දශම 20 ක් මුද්‍රණය කරන ප්‍රමාණයට වඩා අඩු නිරවද්‍ය නමුත් වඩා මානව හිතකාමී නිමැවුමක් සහිතව සැහැල්ලු (ක්‍රියාවලියක් ආරම්භ කිරීමේ පිරිවැය ඇත්ත වශයෙන්ම ඇත) ය. ඉලක්කම් ( වැඩි දශම සංඛ්‍යා ලබා ගැනීම සඳහා ඔබට නිසැකවම අවදි කළ හැකි වුවද ).

සටහන්

(1) සරල කළ වාක්‍ය ඛණ්ඩය භාවිතා කරන්නේ කෙසේද?

මෙම bash ශ්‍රිතය ඔබේ ~/.bashrc:

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

(2) මාළු වල සරල කරන ලද සින්ටැක්ස් භාවිතා කරන්නේ කෙසේද

calcමාළු ශ්‍රිතයක් සාදන්න (එනම් පෙළ ගොනුවක් නම් කර ඇත /home/ndemou/.config/fish/functions/calc.fish):

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

"ජාවාස්ක්‍රිප්ට්හි බලය" කියවීමට මට විශ්වාස කළ නොහැක (නමුත් ඇත්ත වශයෙන්ම පර්ල් හැර අනෙක් කොටස් සඳහා පිළිතුර ඉහළ නැංවීමට මට සිදු විය.

ප්‍රායෝගිකව, පූර්ණ සංඛ්‍යා අංක ගණිතය ප්‍රමාණවත් වන සරල අවස්ථා සඳහා, මම බිල්ඩින් $ ((...)) භාවිතා කර එය නිර්දේශ කරමි. නැතහොත්, සෑම අවස්ථාවකම පාහේ "..." | bc ප්‍රමාණවත්.

සංඛ්‍යාන, න්‍යාස මෙහෙයුම් සහ තවත් බොහෝ ගණිතමය මෙහෙයුම් Rසඳහා වඩා හොඳ මෙවලම:

echo 25 + 5 | R --vanilla

කුඩා දත්ත කට්ටල සහ චිත්‍රක විසිකිරීමේ ප්‍රති results ල oocalcසඳහා කදිම උපයෝගීතාවයකි.

මම කුඩා පයිතන් පිටපතක් භාවිතා කරන අතර එය පයිතන් ප්‍රකාශනයක් ඇගයීමට ලක් කර ප්‍රති result ලය මුද්‍රණය කරනු ඇත, එවිට මට වැනි දෙයක් ධාවනය කළ හැකිය

$ 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විමසුමටයිප් කරන්න. Gnuplot යනු දත්ත කුමන්ත්‍රණය කිරීම සඳහා උපත ලද වැඩසටහනකි, නමුත් ගණනය කිරීම සඳහා ද භාවිතා කළ හැකිය. එය ඔබට කාර්යයන් නිර්වචනය කිරීමට හෝ ගොඩනඟන ලද ඒවා භාවිතා කිරීමට ඇති වාසිය ලබා දෙයි.help

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

මූල (හෝ වෙනත් සී පරිවර්තකයක් )

මෙම මූල පද්ධතියට ඉතා කාර්යක්ෂම ආකාරයෙන් දත්ත විශාල ප්රමාණයක් හැසිරවීමට සහ විශ්ලේෂණය කිරීම සඳහා අවශ්ය සියලු ක්රියාකාරිත්වය සමඟ OO රාමුව මාලාවක් සපයයි ...

ඔබට එය C පරිවර්තකය , CINT ලෙස භාවිතා කළ හැකිය , නැතහොත් ඔබට තවත් බොහෝ C පරිවර්තකයන්ගෙන් එකක් භාවිතා කළ හැකිය . IMHO, එය අති විශාල, සංකීර්ණ, බලවත්, සැමවිටම මිත්‍රශීලී නොවන නමුත් විශාල තෘප්තියක් ලබා දිය හැකිය.

කොන්ෆියුසියෝ උපුටා දක්වන ඔබ තුළ ඇති කුඩා කටහ hear ඔබට ඇහුම්කන් දීමට අවශ්‍ය නැතිනම් රෝදය මත (බටර්) මැස්සෙකු කැඩීමට ඔබ සූදානම් නම් ඔබට මූල භාවිතා කළ හැකිය . මෙම අවස්ථාවේ දී -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

කොන්සෝල ගණනය කිරීම් සඳහා, මම භාවිතා කරමි concalc. ( sudo aptitude install concalc)

ඊට පසු, යතුරු ලියනය concalc කර 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.

ශ්‍රිත පන්ති වෙනස්කම් සහ විස්තර සඳහා අත්පොත බලන්න .

මෙහි ඉතිරි විසඳුම් සියල්ලටම සැලකිය යුතු අඩුපාඩු තිබේ.

එබැවින් මෙය සරලම හා විශ්වාසදායක ආකාරයකින් කළ හැකි වන පරිදි මම නව විධානයක් නිර්මාණය කර ඇත්තෙමි.

සාම්පල:

$ solve 1/5
0.2
$ solve 1.5+3.1
4.6
$ solve 1/1000000
1e-06
$ solve 7+2^3
15
$ solve "sqrt(8)"
2.82842712474619
$ solve 1/0
non solvable 🤯: 1/0

• ප්රභව කේතය
• PKGBUILD