Tam sayı ve değişken hesaplamaları bash veya diğer dillerde / çerçevelerde nasıl yapılır?

echo "20+5"Kelimenin tam anlamıyla kullanılması " 20+5" metnini üretir .

25Bu durumda , sayısal toplamı almak için hangi komutu kullanabilirim ?

Ayrıca, sadece kayan nokta için bash kullanarak bunu yapmanın en kolay yolu nedir? Örneğin, echo $((3224/3807.0))yazdırır 0:(.

Temel komut kabuğunu ('komut satırı') ya da komut satırından erişilebilen dilleri kullanarak cevapları arıyorum.

Birçok seçenek var !!!

özet

$ 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

ayrıntılar

kabuklar

Tamsayılı aritmetik için POSIX aritmetik genişlemesini kullanabilirsiniz echo "$((...))":

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

Oldukça taşınabilir ( ash dash yash bash ksh93 lksh zsh):
Yüzenleri yazdırmak için printf özelliğini kullanarak, çoğu mermiyi sınırlı bir aralıkta olmasına rağmen kayan nokta matematiği yapmak için uzatabiliriz (en fazla 10 basamak):

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

ksh93, yashVe zshburada destek yüzen yapın:

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

sadece ksh93(doğrudan) ve zshburaya kütüphane mathfunc yüklüyor:

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

( gibi işlevleri almak zshiçin yüklemeniz gerekir ).zmodload zsh/mathfuncatan

Zsh ile etkileşimli:

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

(T) csh ile (yalnızca tam sayı):

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

In rckabuk ailesi, akangaaritmetik genişleme biridir:

; echo $:25/3
8

POSIX araç testi

bc(etkileşimli mod için aşağıya bakın), burada manuel

Mnemonic: best chesap makinesi ( bgerçekte basit olmasına rağmen ).

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

(isteğe bağlı hassas sayıları destekler)

bc etkileşimli mod:

$ 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

Rush'ın çözümü, expr(etkileşimli mod yok):

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

Joshua'nın çözümü : awk(etkileşimli mod yok):

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

Diğer az ya da çok taşınabilir araçlar

Arcege çözümü, dc(etkileşimli mod :)dc :

Ters cila notasyonu ile çalıştığı için daha da eğlenceli.

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

Fakat çok fazla ters cila gösterimi ile çalışmadığınız sürece pratik değil.

^{dcÖnceden ortaya çıktığını bcve bctarihsel olarak bir sarmalayıcı olarak uygulandığını dcancak dcPOSIX tarafından standartlaştırılmadığını unutmayın.}

DQdims 'in calc(gerekli sudo apt-get install apcalc):

$ calc 2 + 4
6

Genel amaçlı dil tercümanları:

manatwork'ün çözümü, node(etkileşimli mod node:; çıktı işlevine gerek yoktur):

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

Perl (etkileşimli mod :)perl -de 1 :

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

Python (etkileşimli mod python:; çıktı işlevine gerek yoktur):

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

Ayrıca isteğe bağlı hassas sayıları destekler:

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

Eğer clispyüklediyseniz, cila gösterimini de kullanabilirsiniz:

$ clisp -x "(+ 2 2)"

Marco 'nun çözümü, lua(etkileşimli mod:) lua:

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

PHP (etkileşimli mod :)php -a :

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

Ruby (interaktif mod irb:; çıktı işlevi gerekli değildir):

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

Guile (etkileşimli mod :)guile :

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

S-Lang (etkileşimli mod slsh:; çıktı işlevi gerekli değil, sadece ;sonlandırıcı):

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

Tcl (etkileşimli mod tclsh:; çıktı işlevi gerekli değildir, ancak expris):

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

Javascript kabukları:

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

Çeşitli SQL'ler:

SQLite (etkileşimli mod :)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

_Myql ve postgres seçenekleri “ascii art” imajını durdurur!

İhtisas matematik odaklı diller:

Düz modda R - 1000 Normal rasgele sayı üretmenizi ve standart sapmayı elde etmenizi ve yazdırmanızı sağlar

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

Littler betiğini kullanarak R - pi kare yazdırmayı sağlar

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

PARI / GP , sayı teorisi, doğrusal cebir ve diğer birçok şey için kapsamlı bir bilgisayar cebir sistemi

$ 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 (öncelikle sayısal hesaplamalar için tasarlanan, üst düzeyde yorumlu bir dil)

Ayrıca karmaşık sayıları destekler:

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

Julia , bilimsel ve sayısal hesaplama için yüksek performanslı bir dil ve tercüman.

Etkileşimli olmayan seçenek:

$ julia -E '2.5+3.7'
6.2

Hesaplamanın birçok yolu var. Basit ifadeler için bashkendini kullanabilirsiniz :

echo $((20+5))

veya expr:

expr 20 + 5

Ve karmaşık durumlar için harika bir araç var bc:

echo "20+5" | bc

Btw, bc kökleri, logaritmaları, cos, günah ve benzeri ile çok karmaşık ifadeleri bile hesaplayabilir.

Bahsedilen çözümler çok basit hesaplamalar için iyi, ancak çok hata eğilimli. Örnekler:

# 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

Sonuncular gibi bir sözdizimi hatası kolayca farkedilir, ancak atılan bir kayan kısımla tamsayı yanıtları kolayca farkedilmeyebilir ve yanlış sonuçlara yol açabilir.

Bu yüzden bunun için her zaman Lua gibi bir betik dili kullanıyorum. Ancak aşina olduğunuz herhangi bir betik dilini seçebilirsiniz. Sadece Lua'yı örnek olarak kullanıyorum. Avantajlar

• tanıdık bir sözdizimi
• tanıdık fonksiyonlar
• tanıdık uyarılar
• esnek giriş
• boşluklar genellikle önemli değil
• kayan nokta çıkışı

Örnekler:

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

Henüz kimse awk'tan bahsetmedi mi?

POSIX kabuk işlevlerini ve awk matematik gücünü kullanarak, yalnızca bu (bir satır) işlevini tanımlayın:

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

O zaman sadece calc 1+1veyacalc 5/2

Not: İşlevin her zaman kullanılabilir olmasını sağlamak için ~ / .bashrc dosyasına (veya ilgili kabuğunuzun başlangıç ​​dosyasına) ekleyin.

Tabii ki, aşağıdaki içeriklere sahip "calc" adında küçük bir senaryo:

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

ayrıca çalışabilir.

Kullanabilirsiniz bc. Örneğin,

$ echo "25 + 5" | bc
30

Alternatif olarak bc <<< 25+5da çalışacaktır.

Veya etkileşimli olarak, basit bir hesaplamanın ötesinden fazlasını yapmak istiyorsanız:

$ 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 uygulaması, bchem stdin hem de stdout bir terminale gidince başlangıçta bu başlık / telif hakkı bilgisini yazdırır. Bunu (GNU'ya özgü) -qseçeneğiyle bastırabilirsiniz . Daha fazla bilgi için bc man sayfasına bakınız.

Kullanabilirsiniz calc:

Sadece girerseniz calcbaşka argümanlarla bu sadece matematik yapmaya devam etkileşimli bir moda girer. Exit yazarak bundan çıkın:

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

Ya da onu bir argüman olarak ifade ile kullanırsanız, cevabı verir ve daha sonra çıkar.

$calc 2 + 4
    6
$

calcbenzer bc, ben sadece varsayılan olarak daha iyi davranması gibi

Python'u başlatmayı ve etkileşimli bir hesap makinesi olarak kullanmayı seviyorum (ancak daha sonra yine bir Python programcısıyım).

Hiç kimse bundan bahsetmediğinden ve kesinlikle bir hesap makinesi olmasa da (fakat bu genel amaçlı komut dosyası dillerinin hiçbiri degil), şunu belirtmek isterim units:

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

Veya daha az çıktı $()için, bir şeye atamak için kullanılacak numarayı alabilirsiniz :

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

Ve hatta sıcaklık dönüşümleri yapar

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

Sıcaklık dönüşümünü daha fazla hesaplama için bir ifadede almak için şunu yapın:

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

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

Ayrıca ghci, etkileşimli modda Glasgow-Haskell Derleyicisi ( ghc --interactivebir ifadeyi değerlendirmek yerine -e) etkileyici bir "hesap makinesi" oluşturur:

$>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'in gücünü" okuduğuma inanamıyorum (ama elbette perl hariç, diğer bölümlerin cevabını arttırmalıydım.

Pratik olarak, tamsayı aritmetiğinin yeterli olduğu basit durumlar için, buildin $ ((...)) komutunu kullanıyorum ve bunu tavsiye ediyorum. Başka, neredeyse her durumda yankı "..." | bc yeterlidir.

İstatistikler, matris işlemleri ve daha fazlası gibi bazı aritmetik işlemler Riçin daha iyi araçtır:

echo 25 + 5 | R --vanilla

ve küçük veri kümeleri ve grafiksel sonuçlardan kurtulmak oocalciçin güzel bir yardımcı programdır.

Bir python ifadesini değerlendirecek ve sonucu yazdıracak küçük bir python betiği kullanıyorum, sonra şöyle bir şey çalıştırabilirim

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

komut dosyası:

#!/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')

Ne yazık ki, kodun çoğunu nereden ödünç aldığımı hatırlamıyorum, bu yüzden alıntı yapamıyorum.

gnuplot

gnuplot - etkileşimli bir çizim programı
Yukarıdaki bağlantıyı takip edin yada istemdengnuplot sonra gnuplot yorumlayıcısınınhelpiçineyazın. Gnuplot , verileri çizmek için doğan bir programdır, ancak hesaplama için de kullanılabilir. İşlevleri tanımlamanız ve yerleşik olanları kullanmanız avantajını sunar.

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

Kök (veya başka bir C tercümanı )

KÖK sistemi çok verimli bir şekilde büyük miktarda veri işlemek ve analiz etmek için gerekli tüm işlevselliği ile OO çerçeveler kümesi sağlar ...

Sen olarak kullanabilirsiniz C tercüman , CInt veya birini kullanabilirsiniz birçok diğer birçok C tercüman . IMHO, kocaman, karmaşık, güçlü ve her zaman arkadaşça değil, aynı zamanda büyük memnuniyet verebilir.

İçinizdeki Confucio'yu gösteren ve içindeki tereyağı kırmaya hazır olan küçük sesi dinlemek istemiyorsanız, kökü kullanabilirsiniz . Bu durumda -laçılış ekranını göstermemek için zorunludur ...

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

Tamsayı aritmetiği için (3/2 = 1)

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

*: ve ksh93, yash

Kayan nokta aritmetiği için (3/2 = 1.5)

• bash awk "BEGIN {print 10/3}" (düşük hassasiyet)
• bash echo "10/3"|bc -l (yüksek hassasiyet)
• fish math -s4 10/3
• zsh* echo $((10./3))

*: ve ksh93, yash

Elbette, kabuğunuzu minimum yazma gibi awk kullanacak şekilde yapılandırabilirsiniz calc 10/3(bash ¹ ve balık ² için nasıl yapıldığına dair notlara bakın ).

Bash için awk önermenin ana nedeni, neredeyse tüm Unix benzeri işletim sistemlerinde önceden kurulmuş olması ve makul bir şekilde hafif olması (elbette bir işleme başlama maliyeti), bc -l20 ondalık basandan daha az kesin ancak daha insan dostu bir çıktıya sahip olmasıdır. basamaklar (kesinlikle daha fazla ondalık basamak almak için awk ayarını yapabilirsiniz ).

notlar

(1) Bash dilinde basitleştirilmiş sözdizimi nasıl kullanılır?

Bu bash işlevini kendinize ekleyin ~/.bashrc:

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

(2) Balıklarda basitleştirilmiş sözdizimi nasıl kullanılır?

Bir calcbalık işlevi oluşturun (yani, adlandırılmış bir metin dosyası /home/ndemou/.config/fish/functions/calc.fish):

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

Konsol hesaplamaları için kullanıyorum concalc. ( sudo aptitude install concalc)

Ondan sonra, sadece yazın concalc ve enter tuşuna basın. Bir bilgi istemi sağlamaz, ancak hesaplamanızı girin (boşluksuz) ve enter tuşuna basın ve bir sonraki satırda size sayısal bir değer verir.

SQLite :

echo 'select 1 + 1;' | sqlite3 

MySQL :

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

PostgreSQL :

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

Verilen program aracılığıyla GNU Çoklu Hassas Aritmetik Kütüphanesini kullanın run-expr:

• İndirin ve çıkartın (lzip'e ihtiyacınız olacak): tar -xvf gmp-5.1.3.tar.lz
• En üstteki dizinde ./configureve make(yüklemeye gerek yok)
• Demolarda / ifadede, make run-expr
• Dizinimde sembolik bir link oluşturmayı seviyorum ~/bin:ln -s /path/to/gmp/demos/expr/run-expr ~/bin/run-expr
• Kolay kullanım için bir takma ad ekleyin; örneğin alias calcf='run-expr -f'kayan nokta değerlendirmesi için

Çıktı:

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

Gönderen run-expr.cdosyası:

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.

Fonksiyon sınıfları farklılıkları ve detayları için kılavuza bakınız.