Jak wykonywać obliczenia liczb całkowitych i zmiennoprzecinkowych, w bash lub innych językach / frameworkach?

Użycie echo "20+5"dosłownie tworzy tekst „ 20+5”.

Jakiego polecenia mogę użyć 25w tym przypadku do uzyskania sumy liczbowej ?

Jaki jest najłatwiejszy sposób, aby to zrobić, używając bash jako zmiennoprzecinkowego? Na przykład echo $((3224/3807.0))drukuje 0:(.

Szukam odpowiedzi za pomocą samej podstawowej powłoki poleceń („wiersza polecenia”) lub za pomocą języków dostępnych z wiersza poleceń.

Istnieje wiele opcji !!!

Podsumowanie

$ 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

Detale

Muszle

Można użyć POSIX arytmetyczną ekspansję na całkowitą arytmetycznych echo "$((...))":

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

Dość przenośny ( ash dash yash bash ksh93 lksh zsh):
Używając zdolności printf do drukowania liczb zmiennoprzecinkowych, możemy rozszerzyć większość powłok, aby wykonać matematykę zmiennoprzecinkową, aczkolwiek z ograniczonym zasięgiem (nie więcej niż 10 cyfr):

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

ksh93, yashi zshczy wsparcie pływa tutaj:

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

tylko ksh93(bezpośrednio) i zshładowanie biblioteki mathfunc tutaj:

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

( zshtrzeba załadować, zmodload zsh/mathfuncaby uzyskać funkcje takie jak atan).

Interaktywnie z zsh:

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

Z (t) csh (tylko liczba całkowita):

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

W rcrodzinie powłok akangajest ten z rozszerzeniem arytmetycznym:

; echo $:25/3
8

Zestaw narzędzi POSIX

bc(patrz poniżej tryb interaktywny), instrukcja tutaj

Mnemonic: best calculator (choć btak naprawdę jest podstawowy ).

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

(obsługuje dowolne liczby precyzji)

tryb interaktywny 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

Rozwiązanie Rushaexpr (brak trybu interaktywnego):

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

Rozwiązanie Jozuego : awk(brak trybu interaktywnego):

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

Inne mniej lub bardziej przenośne narzędzia

Arcege rozwiązaniem jest, dc(tryb interaktywny: dc):

Co jest jeszcze przyjemniejsze, ponieważ działa w odwrotnej notacji polskiej.

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

Ale nie tak praktyczne, chyba że dużo pracujesz z odwrotną notacją polską.

^{Zauważ, że dcpoprzedza bci bcbyła historycznie implementowana jako opakowanie, dcale dcnie była standaryzowana przez POSIX}

DQdims 's calc(wymagane sudo apt-get install apcalc):

$ calc 2 + 4
6

Tłumacze językowi ogólnego przeznaczenia:

rozwiązanie manatwork , node(tryb interaktywny :;node funkcja wyjścia nie jest wymagana):

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

Perl (tryb interaktywny:) perl -de 1:

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

Python (tryb interaktywny python:; funkcja wyjściowa nie jest wymagana):

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

Obsługuje również dowolne liczby precyzji:

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

Jeśli masz clispzainstalowany, możesz także użyć polskiej notacji:

$ clisp -x "(+ 2 2)"

Rozwiązanie Marco , lua(tryb interaktywny:) lua:

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

PHP (tryb interaktywny:) php -a:

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

Ruby (tryb interaktywny irb:; funkcja wyjściowa nie jest wymagana):

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

Guile (tryb interaktywny :)guile :

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

S-Lang (tryb interaktywny slsh:; funkcja wyjściowa nie jest wymagana, tylko ;terminator):

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

Tcl (tryb interaktywny :;tclsh funkcja wyjściowa nie jest wymagana, ale exprjest):

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

Skorupy JavaScript :

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

Różne SQL:

SQLite (tryb interaktywny:) 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

_Opcje w mysql i postgres zatrzymują obraz „ascii art”!

Specjalistyczne języki matematyczne:

R w trybie zwykłym - pozwala wygenerować 1000 normalnych liczb losowych, uzyskać standardowe odchylenie i wydrukować go

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

R za pomocą skryptu Littler - pozwala wydrukować pi do kwadratu

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

PARI / GP , rozbudowany system algebry komputerowej do teorii liczb, algebry liniowej i wielu innych rzeczy

$ 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 (język interpretacji wysokiego poziomu, przeznaczony głównie do obliczeń numerycznych)

Obsługuje również liczby zespolone:

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

Julia , wysokowydajny język i tłumacz dla obliczeń naukowych i numerycznych.

Opcja nieinteraktywna:

$ julia -E '2.5+3.7'
6.2

Istnieje wiele sposobów obliczania. W przypadku prostych wyrażeń możesz użyć bashsamego:

echo $((20+5))

lub expr:

expr 20 + 5

A w przypadku skomplikowanych przypadków istnieje świetne narzędzie bc:

echo "20+5" | bc

Btw, bc może obliczyć nawet bardzo złożone wyrażenie z pierwiastkami, logarytmami, cos, sin i tak dalej.

Wspomniane rozwiązania nadają się do bardzo prostych obliczeń, ale są bardzo podatne na błędy. Przykłady:

# 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

Łatwo zauważalny jest błąd składniowy, podobnie jak ostatnie, ale odpowiedzi całkowite z odrzuconą częścią zmiennoprzecinkową mogą łatwo zostać niezauważone i prowadzić do błędnych wyników.

Dlatego zawsze używam do tego języka skryptowego takiego jak Lua. Możesz jednak wybrać dowolny język skryptowy, który znasz. Po prostu używam Lua jako przykładu. Zalety są

• znana składnia
• znane funkcje
• znane ostrzeżenia
• elastyczne wprowadzanie
• spacje zwykle nie mają znaczenia
• wyjście zmiennoprzecinkowe

Przykłady:

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

Nikt jeszcze nie wspomniał o awk?

Używając funkcji powłoki POSIX i mocy matematyki awk, po prostu zdefiniuj tę funkcję (jedna linia):

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

Następnie po prostu wykonaj takie rzeczy jak calc 1+1lubcalc 5/2

Uwaga: Aby funkcja była zawsze dostępna, dodaj ją do ~ / .bashrc (lub pliku startowego odpowiedniej powłoki)

Oczywiście mały skrypt o nazwie „calc” o następującej treści:

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

może również działać.

Możesz użyć bc. Na przykład,

$ echo "25 + 5" | bc
30

Alternatywnie bc <<< 25+5będzie również działać.

Lub interaktywnie, jeśli chcesz zrobić coś więcej niż tylko jedno proste obliczenie:

$ 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

Implementacja GNU bcdrukuje te nagłówki / informacje o prawach autorskich podczas uruchamiania, gdy zarówno jego stdin, jak i stdout idą do terminala. Możesz go wyłączyć za pomocą opcji (specyficznej dla GNU) -q. Aby uzyskać więcej informacji, zobacz stronę manuala bc

Możesz użyć calc:

Jeśli po prostu wejdziesz calcbez żadnych argumentów, wejdzie w tryb interaktywny, w którym możesz po prostu robić matematykę. Wyjdź z tego, wpisując polecenie 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

Lub użyjesz go z wyrażeniem jako argumentem, który dostarczy odpowiedź, a następnie zakończy działanie

$calc 2 + 4
    6
$

calcjest podobny do bc, po prostu podoba mi się sposób, w jaki lepiej się zachowuje jako domyślny

Lubię odpalać Python i używać go jako interaktywnego kalkulatora (ale z drugiej strony jestem programistą Python).

Ponieważ nikt o tym nie wspominał i chociaż nie jest to wyłącznie kalkulator (ale nie wszystkie te języki skryptowe ogólnego przeznaczenia), chciałbym wspomnieć units:

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

Lub, aby uzyskać mniej danych wyjściowych, abyś mógł uzyskać tylko numer, który będzie używany $()do przypisania do czegoś:

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

I nawet dokonuje konwersji temperatury

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

Aby uzyskać konwersję temperatury w wyrażeniu do dalszych obliczeń, wykonaj następujące czynności:

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

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

Ponadto ghci, to jest kompilator Glasgow-Haskell w trybie interaktywnym ( ghc --interactivew przeciwieństwie do oceny wyrażenia za pomocą -e), tworzy fascynujący „kalkulator”:

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

Nie mogę uwierzyć, że czytam „moc JavaScript” (ale musiałem głosować za odpowiedzią na inne części, z wyjątkiem oczywiście perla.

Praktycznie w prostych przypadkach, w których wystarczająca jest arytmetyka liczb całkowitych, używam buildin $ ((...)) i polecam go. W przeciwnym razie w prawie wszystkich przypadkach echo „...” | bc jest wystarczające.

W przypadku niektórych operacji arytmetycznych, takich jak statystyki, operacje macierzowe itp R., Lepszym narzędziem jest:

echo 25 + 5 | R --vanilla

a dla małych zestawów danych i graficznych wyników wyrzucania oocalcjest dobrym narzędziem.

Używam małego skryptu Pythona, który oceni wyrażenie w Pythonie i wydrukuje wynik, a następnie mogę uruchomić coś takiego

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

skrypt jest:

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

Niestety nie pamiętam, skąd pożyczyłem większość kodu, więc nie mogę go zacytować.

Gnuplot

gnuplot - interaktywny program do rysowania
Kliknij powyższy link lub wpiszgnuplotzapytanie, a następniehelpwinterpretera gnuplot .
Gnuplot jest programem stworzonym do drukowania danych, ale można go również wykorzystać do obliczeń. Daje to tę zaletę, że można definiować funkcje i / lub korzystać z wbudowanych.

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

Root (lub inny interpreter języka C )

System ROOT zapewnia zestaw ram OO ze wszystkimi funkcjami potrzebnymi do obsługi i analizy dużych ilości danych w bardzo wydajny sposób ...

Można go używać jako C tłumacza , CInt , lub użyć jednego z wielu, wielu innych tłumaczy C . IMHO, jest ogromny, złożony, potężny i nie zawsze przyjazny, ale może też dać dużą satysfakcję.

Jeśli naprawdę nie chcesz słuchać małego głosu w swoim wnętrzu, który cytuje Confucio, i jesteś gotowy złamać muchę (masło) na kole , możesz użyć korzenia . W takim przypadku -lnależy bezwzględnie unikać wyświetlania ekranu powitalnego ...

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

Dla arytmetyki liczb całkowitych (gdzie 3/2 = 1)

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

*: i ksh93, yash

Dla arytmetyki zmiennoprzecinkowej (gdzie 3/2 = 1,5)

• bash awk "BEGIN {print 10/3}" (niska precyzja)
• bash echo "10/3"|bc -l (wysoka precyzja)
• fish math -s4 10/3
• zsh* echo $((10./3))

*: i ksh93, yash

Możesz oczywiście skonfigurować swoją powłokę, aby używała awk przy minimalnym pisaniu jak calc 10/3(patrz uwagi na temat tego, jak to zrobić dla bash ¹ i fish ² ).

Głównym powodem sugerowania awk dla bash jest to, że jest on zainstalowany fabrycznie na prawie wszystkich systemach uniksopodobnych i jest dość lekki (oczywiście wiąże się to z kosztem uruchomienia procesu) z mniej precyzyjnym, ale bardziej przyjaznym dla człowieka wyjściem, niż bc -lktóry drukuje 20 miejsc po przecinku cyfry (chociaż z pewnością możesz dostosować awk, aby uzyskać więcej cyfr dziesiętnych ).

Notatki

(1) Jak korzystać z uproszczonej składni w bash

Dodaj tę funkcję bash do ~/.bashrc:

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

(2) Jak korzystać z uproszczonej składni u ryb

Utwórz funkcję calcryb (tj. Plik tekstowy o nazwie /home/ndemou/.config/fish/functions/calc.fish):

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

Używam do obliczeń konsolowych concalc. ( sudo aptitude install concalc)

Następnie wystarczy wpisać concalc i nacisnąć Enter. Nie wyświetli monitu, ale po prostu wpisz swoje obliczenia (bez spacji) i naciśnij klawisz Enter, a w następnym wierszu podana zostanie wartość liczbowa.

SQLite :

echo 'select 1 + 1;' | sqlite3 

MySQL :

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

PostgreSQL :

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

Użyj biblioteki arytmetycznej wielokrotnej precyzji GNU za pośrednictwem dostarczonego run-exprprogramu:

• Pobierz i rozpakuj (będziesz potrzebował lzip): tar -xvf gmp-5.1.3.tar.lz
• W górnym katalogu ./configurei make(nie trzeba instalować)
• W wersji demo / expr make run-expr
• Lubię utworzyć symboliczny link do niego w moim ~/binkatalogu:ln -s /path/to/gmp/demos/expr/run-expr ~/bin/run-expr
• Dodaj alias dla łatwego użycia; na przykład alias calcf='run-expr -f'do oceny zmiennoprzecinkowej

Wynik:

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

Z run-expr.cpliku:

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.

Patrz instrukcja różnic klas i szczegółów.