it-swarm-tr.com

Bash veya diğer dillerde / çerçevelerde tamsayı ve float hesaplamaları nasıl yapılır?

echo "20+5" Kullanılması kelimenin tam anlamıyla "20+5" Metnini üretir.

Bu durumda 25 Sayısal toplamını 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))0 :( yazdırır.

Temel komut Shell ('komut satırı') kendisini kullanarak veya komut satırında kullanılabilir dilleri kullanarak cevap arıyorum.

316
Michael Durrant

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

integer aritmetik echo "$((...))" için POSIX aritmetik genişletmesini kullanabilirsiniz:

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

Oldukça taşınabilir (ash dash yash bash ksh93 lksh zsh):
Şamandıraları yazdırmak için printf özelliğini kullanarak, çoğu mermiyi sınırlı bir aralıkta da olsa (en fazla 10 basamak) kayan nokta matematiği yapmak için genişletebiliriz:

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

ksh93, yash ve zsh şamandıraları burada destekliyorlar:

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

sadece ksh93 (doğrudan) ve zsh burada kütüphane mathfunc yükleniyor:

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

(zshatan gibi işlevleri alabilmek için zmodload zsh/mathfunc yüklemeniz gerekir).


Zsh ile etkileşimli olarak:

$ 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 tamsayı):

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

rc Shell ailesinde, akanga aritmetik genişleme olanıdır:

; echo $:25/3
8

POSIX araç testi

bc (etkileşimli mod için aşağıya bakın), buradaki kılavuz

Anımsatıcı: bavustralya, Brezilya ve Kuzey Amerika ülkelerinin kullandığı saat uygulaması calculator (b aslında temel içindir).

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

(keyfi hassas sayıları destekler)


bc etkileşimli modu:

$ 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

Yuşa'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 'ın çözümü, dc (etkileşimli mod: dc):

Ters lehçe gösterimi 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

Ancak ters lehçe gösterimi ile çok fazla çalışmadığınız sürece pratik değildir.

dc öncesi _ bc ve bc 'ın dc etrafında sarmalayıcı olarak uygulandığını, ancak dc POSIX tarafından standartlaştırılmadığını unutmayın


DQdims 's calc (gerekli Sudo apt-get install apcalc):

$ calc 2 + 4
6

Genel amaçlı dil tercümanları:

manatwork 'ın çözümü, node (interaktif mod: node; çıkış fonksiyonu değil ) gerekli:

$ 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; çıkış işlevi gerekli değildir):

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

Ayrıca keyfi hassas sayıları destekler:

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

Yüklü clisp varsa, lehçe gösterimini de kullanabilirsiniz:

$ clisp -x "(+ 2 2)"

Marco 'ın çö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 (etkileşimli mod: irb; çıkış 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; çıkış işlevi gerekli değil, sadece bir ; 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; çıkış işlevi gerekli değil, ancak expr zorunludur):

$ 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

Mysql ve postgres seçenekleri 'ascii art' imajını durdurur!

Uzmanlaşmış matematik odaklı diller:

Düz modda [~ # ~] r [~ # ~] - 1000 Normal rasgele sayı üretelim ve standart sapmayı alıp yazdıralım

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

[= # ~] r [~ # ~] altlığı kullanarak script - pi kare baskı 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 daha 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 Oktav (öncelikle sayısal hesaplamalar için tasarlanmış yüksek düzeyde yorumlanmış bir dil)

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

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

Julia , yüksek performanslı dil ve bilimsel ve sayısal hesaplama için yorumlayıcı.

Etkileşimli olmayan seçenek:

$ Julia -E '2.5+3.7'
6.2
431
lgarzo

Hesaplamanın birçok yolu vardır. Basit ifadeler için bash'in kendisini kullanabilirsiniz:

echo $((20+5))

veya expr:

expr 20 + 5

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

echo "20+5" | bc

Btw, bc kökler, logaritmalar, cos, günah vb.Ile çok karmaşık ifadeleri bile hesaplayabilir.

37
rush

Bahsedilen çözümler çok basit hesaplamalar için iyidir, ancak hataya açıktır. Ö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 fark edilir, ancak atılan bir kayan bölümle tamsayı yanıtları kolayca fark edilmeyebilir ve yanlış sonuçlara yol açabilir.

Bu yüzden hep bunun için Lua gibi bir betik dili kullanıyorum. Ancak, aşina olduğunuz herhangi bir komut dosyası dilini seçebilirsiniz. Ben sadece örnek olarak Lua kullanıyorum. Avantajları

  • tanıdık bir sözdizimi
  • tanıdık işlevler
  • 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
25
Marco

Hiç kimse awk'tan bahsetmedi mi?

POSIX Kabuk işlevlerini ve awk matematik gücünü kullanarak, bu (tek satır) işlevi tanımlamanız yeterlidir:

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

Sonra calc 1+1 veya calc 5/2

Not: İşlevi her zaman kullanılabilir yapmak için, ~/.bashrc'ye (veya ilgili Shell'in başlangıç ​​dosyasına) ekleyin.

Tabii ki, aşağıdaki içeriğe sahip "calc" adlı küçük bir komut dosyası:

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

de işe yarayabilir.

25
Joshua

bc kullanabilirsiniz. Örneğin.,

$ echo "25 + 5" | bc
30

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

Veya etkileşimli olarak, sadece tek bir basit hesaplamadan daha 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 bc uygulaması, hem stdin hem de stdout'u bir terminale gittiğinde başlangıçta bu başlık/telif hakkı bilgilerini basar. (GNU'ya özgü ) -q seçeneği. Daha fazla bilgi için bc man sayfasına

18
Levon

calc kullanabilirsiniz:

calc değerini başka bir argüman olmadan girerseniz, matematik yapmaya devam edebileceğiniz etkileşimli bir moda girer. Bu işlemi exit yazarak çıkarsınız:

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 ifadeyi bir argüman olarak kullanırsanız, yanıtı sağlar ve sonra çıkar

$calc 2 + 4
    6
$

calcbc'ye benziyor, tıpkı varsayılan olarak daha iyi davranma şeklini seviyorum

17
DQdlM

Ben Python ve etkileşimli bir hesap makinesi olarak kullanmak istiyorum (ama sonra tekrar, ben Python programcı) seviyorum.

10
asmeurer

Başka hiç kimse bundan bahsetmediğinden ve kesinlikle bir hesap makinesi olmasa da (ancak bunların hepsi genel amaçlı komut dosyası dilleri de değildir), units: dan bahsetmek istiyorum:

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

Veya daha az çıktı için, $() öğesinde atamak istediğiniz sayıyı alabilirsiniz:

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

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

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

Daha fazla hesaplama için bir ifadede sıcaklık dönüşümünü elde etmek için şunu yapın:

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

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

  • bashecho $(( 1+1 ))
  • fishmath 1+1
  • zsh*echo $((1+1))

*: ve ksh93, yash

Kayan nokta aritmetiği için (3/2 = 1,5 olduğunda)

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

*: ve ksh93, yash

Elbette Shell'inizi calc 10/3 Gibi minimum yazarak awk kullanacak şekilde yapılandırabilirsiniz (bash için nasıl yapılacağı ile ilgili notlara bakın.1 ve balık2).

Bash için awk önermenin ana nedeni, neredeyse tüm Unix benzeri işletim sistemlerine önceden kurulmuş olması ve bc -l 20 ondalık basamak basar (kesinlikle yapabilirsiniz Daha fazla ondalık basamak almak için awk ayarını yapın ).


Notlar

(1) Bash'da basitleştirilmiş sözdizimi nasıl kullanılır

Bu bash işlevini ~/.bashrc Cihazınıza ekleyin:

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

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

Bir calc balık işlevi oluşturun (yani /home/ndemou/.config/fish/functions/calc.fish Adlı bir metin dosyası):

function calc
    awk "BEGIN{ print $argv }" ;
end
6
ndemou
$> ghc -e '20 + 5'
25
it :: Integer

Ayrıca ghci, interaktif modda Glasgow-Haskell Derleyicisi (ghc --interactive, aksine bir ifadeyi -e ), büyüleyici bir "hesap makinesi" yapar:

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

Ben python ifadesini değerlendirmek ve sonucu yazdırmak biraz python komut dosyası kullanın, sonra gibi bir şey çalıştırabilirsiniz

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

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

4
cobbal

Gnuplot

gnuplot - etkileşimli bir çizim programı
Yukarıdaki bağlantıyı izleyin veya cnnlot yorumlayıcısının içine gnuplot İstemi oluştur _ help yazın.
Gnuplot verileri çizmek için doğan bir programdır, ancak hesaplama için de kullanılabilir. Fonksiyonları tanımlayabilme ve yerleşik olanları kullanabilme avantajı 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 yorumlayıcısı )

ROOT sistemi , çok miktarda veriyi çok iyi işlemek ve analiz etmek için gereken tüm işlevlere sahip bir dizi OO çerçeve) sağlar verimli bir şekilde ...

Bunu C yorumlayıcısı , [~ # ~] cint [~ # ~] olarak kullanabilirsiniz. veya diğer pek çok C tercümanı 'dan birini kullanabilirsiniz. IMHO, büyük, karmaşık, güçlü ve her zaman dostça değil, aynı zamanda büyük memnuniyet de verebilir.

Gerçekten içinizdeki küçük sesi dinlemek istemiyorsanız Confucio ve hazırsınız tekerleğe bir (tereyağı) sinek kırmaya kök kullanabilirsiniz. Bu durumda -l açı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
4
Hastur

"JavaScript'in gücünü" okumaya inanamıyorum (ama elbette Perl hariç diğer bölümlerin cevabını kaldırmak zorunda kaldım.

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

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

echo 25 + 5 | R --Vanilla

ve küçük veri kümeleri ve grafiksel atma sonuçları için oocalc güzel bir yardımcı programdır.

4
user unknown

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

Bundan sonra, concalc yazıp enter tuşuna basmanız yeterlidir. Bir İstem sağlamaz, ancak sadece hesaplamanızı yazın (boşluk yok) ve enter tuşuna basın ve sonraki satırda size sayısal değer verecektir.

3
killermist

SQLite:

echo 'select 1 + 1;' | sqlite3 

MySQL:

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

PostgreSQL:

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

Sağlanan run-expr Programında GNU Çok Hassasiyetli Aritmetik Kütüphanesi kullanın:

  • İndirin ve çıkarın (lzip'e ihtiyacınız olacak): tar -xvf gmp-5.1.3.tar.lz
  • Üst dizinde ./configure Ve make (yüklemeye gerek yok)
  • Demo/ifade olarak make run-expr
  • ~/bin Dizinimde sembolik bir bağlantı oluşturmak istiyorum: ln -s /path/to/gmp/demos/expr/run-expr ~/bin/run-expr
  • Kolay kullanım için bir takma ad ekleyin; örneğin kayan nokta değerlendirmesi için alias calcf='run-expr -f'

Çıktı:

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

run-expr.c Dosyasından:

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.

İşlev sınıfı farkları ve ayrıntıları için manual bölümüne bakın.

2
user44370

Buradaki çözümlerin geri kalanının önemli dezavantajları var.

Bu yüzden bunu en basit ve en güvenilir şekilde yapabilmek için yeni bir komut oluşturdum.

Örnekler:

$ 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