Come eseguire calcoli interi e float, in bash o altre lingue / framework?

L'uso echo "20+5"letterale produce il testo " 20+5".

Quale comando posso usare per ottenere la somma numerica, 25in questo caso?

Inoltre, qual è il modo più semplice per farlo semplicemente usando bash per virgola mobile? Ad esempio, echo $((3224/3807.0))stampa 0:(.

Sto cercando risposte utilizzando la shell dei comandi di base ('riga di comando') stessa o usando le lingue disponibili dalla riga di comando.

Ci sono molte opzioni!!!

Sommario

$ 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

Dettagli

conchiglie

È possibile utilizzare POSIX espansione aritmetica per interi aritmetica echo "$((...))":

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

Abbastanza portatile ( ash dash yash bash ksh93 lksh zsh):
Usando l'abilità printf per stampare float possiamo estendere la maggior parte delle shell per fare matematica in virgola mobile anche se con un intervallo limitato (non più di 10 cifre):

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

ksh93, yashE zshfare carri di supporto qui:

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

solo ksh93(direttamente) e zshcaricando la libreria mathfunc qui:

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

(è zshnecessario caricare zmodload zsh/mathfuncper ottenere funzioni simili atan).

Interattivo con zsh:

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

Con (t) csh (solo numero intero):

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

Nella rcfamiglia di conchiglie akangac'è quella con espansione aritmetica:

; echo $:25/3
8

Toolchest POSIX

bc(vedi sotto per la modalità interattiva), manuale qui

Mnemonico: best calculator (anche se bin effetti è di base ).

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

(supporta numeri di precisione arbitrari)

bc modalità interattiva:

$ 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

Soluzione di Rush , expr(nessuna modalità interattiva):

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

La soluzione di Joshua : awk(nessuna modalità interattiva):

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

Altri strumenti più o meno portatili

La soluzione di Arcege , dc(modalità interattiva :)dc :

Il che è ancora più divertente poiché funziona con la notazione polacca inversa.

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

Ma non è pratico a meno che non lavori molto con la notazione polacca inversa.

^{Si noti che è dcprecedente bced bcè stato storicamente implementato come un wrapper dcma dcnon è stato standardizzato da POSIX}

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

$ calc 2 + 4
6

Interpreti di lingua per scopi generici:

soluzione di manatwork , node(modalità interattiva :;node funzione di output non necessaria):

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

Perl (modalità interattiva:) perl -de 1:

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

Python (modalità interattiva python:; funzione di output non necessaria):

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

Supporta anche numeri di precisione arbitrari:

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

Se hai clispinstallato, puoi anche usare la notazione polacca:

$ clisp -x "(+ 2 2)"

Soluzione di Marco , lua(modalità interattiva:) lua:

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

PHP (modalità interattiva:) php -a:

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

Ruby (modalità interattiva irb:; funzione di output non necessaria):

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

Guile (modalità interattiva:) guile:

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

S-Lang (modalità interattiva slsh:; funzione di output non necessaria, solo un ;terminatore):

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

Tcl (modalità interattiva tclsh:; funzione di output non necessaria, ma exprè):

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

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

Vari SQL:

SQLite (modalità interattiva:) 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

_Le opzioni su mysql e postgres fermano l'immagine 'ascii art'!

Lingue specializzate orientate alla matematica:

R in modalità normale: consente di generare 1000 numeri casuali normali, ottenere la deviazione standard e stamparla

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

R usando lo script più piccolo : consente di stampare al quadrato

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

PARI / GP , un ampio sistema di algebra computerizzata per la teoria dei numeri, l'algebra lineare e molte altre cose

$ 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 (un linguaggio interpretato di alto livello, destinato principalmente ai calcoli numerici)

Supporta anche numeri complessi:

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

Julia , linguaggio ad alte prestazioni ed interprete per informatica scientifica e numerica.

Opzione non interattiva:

$ julia -E '2.5+3.7'
6.2

Esistono molti modi per calcolare. Per espressioni semplici puoi usare bashse stesso:

echo $((20+5))

oppure expr:

expr 20 + 5

E per casi complessi c'è un ottimo strumento bc:

echo "20+5" | bc

A proposito, bc può calcolare anche espressioni molto complesse con radici, logaritmi, cos, sin e così via.

Le soluzioni menzionate vanno bene per calcoli molto semplici, ma molto inclini agli errori. Esempi:

# 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

Si può facilmente notare un errore di sintassi come gli ultimi, ma le risposte intere con una parte float scartata possono facilmente passare inosservate e portare a risultati errati.

Ecco perché uso sempre un linguaggio di scripting come Lua. Ma puoi scegliere qualsiasi linguaggio di scripting che conosci. Uso solo Lua come esempio. I vantaggi sono:

• una sintassi familiare
• funzioni familiari
• avvertenze familiari
• input flessibile
• gli spazi di solito non contano
• uscita a virgola mobile

Esempi:

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

Nessuno ha ancora menzionato Awk?

Usando le funzioni shell POSIX e la potenza matematica awk, basta definire questa funzione (una riga):

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

Quindi esegui cose come calc 1+1ocalc 5/2

Nota: per rendere la funzione sempre disponibile, aggiungila a ~ / .bashrc (o al file di avvio della shell corrispondente)

Naturalmente, un piccolo script chiamato "calc" con i seguenti contenuti:

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

potrebbe anche funzionare.

Puoi usare bc. Per esempio,

$ echo "25 + 5" | bc
30

In alternativa bc <<< 25+5funzionerà anche.

O in modo interattivo, se vuoi fare più di un semplice semplice calcolo:

$ 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

L'implementazione GNU bcstampa le informazioni di intestazione / copyright all'avvio quando sia lo stdin che lo stdout vanno su un terminale. Puoi sopprimerlo con l' -qopzione (specifica per GNU) . Per maggiori informazioni consultare la pagina man di bc

Puoi usare calc:

Se entri calcsenza altri argomenti, entra in una modalità interattiva in cui puoi semplicemente continuare a fare matematica. Si esce digitando 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

Oppure lo usi con l'espressione come argomento e fornirà la risposta e poi uscirà

$calc 2 + 4
    6
$

calcè simile a bc, mi piace il modo in cui si comporta meglio come predefinito

Mi piace accendere Python e usarlo come una calcolatrice interattiva (ma, di nuovo, sono un programmatore Python).

Dal momento che nessun altro l'ha menzionato, e sebbene non sia strettamente una calcolatrice (ma non lo sono nemmeno tutti questi linguaggi di scripting generici), vorrei menzionare units:

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

Oppure, per un output inferiore in modo da poter ottenere solo il numero da utilizzare $()per assegnare a qualcosa:

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

E fa anche conversioni di temperatura

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

Per ottenere la conversione della temperatura in un'espressione per ulteriori calcoli, procedere come segue:

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

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

Inoltre ghci, questo è il compilatore di Glasgow-Haskell in modalità interattiva ( ghc --interactive, al contrario di valutare un'espressione con -e), crea un affascinante "calcolatore":

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

Non riesco a credere di leggere "il potere di JavaScript" (ma ho dovuto votare la risposta per le altre parti, tranne ovviamente perl.

In pratica, per i semplici casi in cui l'aritmetica dei numeri interi è sufficiente, utilizzo buildin $ ((...)) e lo consiglio. Altrimenti, quasi tutti i casi fanno eco "..." | bc è sufficiente.

Per alcune operazioni aritmetiche come statistiche, operazioni a matrice e altro Rè lo strumento migliore:

echo 25 + 5 | R --vanilla

e per piccoli set di dati e risultati grafici di eliminazione, oocalcè una bella utility.

Uso un piccolo script Python che valuterà un'espressione Python e stamperà il risultato, quindi posso eseguire qualcosa del genere

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

lo script è:

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

Sfortunatamente non ricordo da dove ho preso in prestito la maggior parte del codice, quindi non posso citarlo.

gnuplot

gnuplot - un programma di tracciamento interattivo
Segui il link sopra o digitagnuplotil prompt e poihelpall'interno dell'interprete gnuplot .
Gnuplot è un programma nato per tracciare dati, ma può essere utilizzato anche per il calcolo. Offre il vantaggio di poter definire funzioni o utilizzare quelle integrate.

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 (o qualche altro interprete C )

Il sistema ROOT fornisce una serie di framework OO con tutte le funzionalità necessarie per gestire e analizzare grandi quantità di dati in un modo molto efficiente ...

È possibile utilizzarlo come C interprete , CINT , oppure è possibile utilizzare uno dei molti molti altri interpreti C . IMHO, è enorme, complesso, potente e non sempre amichevole, ma può anche dare grandi soddisfazioni.

Se davvero non vuoi ascoltare la vocina dentro di te che cita Confucio e sei pronto a rompere un (burro) volo sulla ruota , puoi usare root . In questo caso -lè obbligatorio evitare di mostrare la schermata iniziale ...

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

Per aritmetica intera (dove 3/2 = 1)

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

*: e ksh93, yash

Per aritmetica in virgola mobile (dove 3/2 = 1.5)

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

*: e ksh93, yash

Puoi ovviamente configurare la tua shell per usare awk con una digitazione minima come calc 10/3(vedi note su come farlo per bash ¹ e fish ² ).

Il motivo principale per suggerire awk per bash è che è preinstallato su quasi tutti i sistemi operativi simili a Unix ed è ragionevolmente leggero (c'è ovviamente il costo di avviare un processo) con un output meno preciso ma più rispettoso dell'uomo di bc -lcui stampa 20 decimali cifre (anche se puoi certamente modificare awk per ottenere più cifre decimali ).

Appunti

(1) Come usare la sintassi semplificata in bash

Aggiungi questa funzione bash al tuo ~/.bashrc:

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

(2) Come utilizzare la sintassi semplificata nei pesci

Crea una calcfunzione fish (ovvero un file di testo chiamato /home/ndemou/.config/fish/functions/calc.fish):

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

Per i calcoli della console, io uso concalc. ( sudo aptitude install concalc)

Dopodiché, basta digitare concalc e premere invio. Non fornirà un prompt, ma basta digitare il calcolo (senza spazi) e premere invio, e nella riga successiva, ti darà il valore numerico.

SQLite :

echo 'select 1 + 1;' | sqlite3 

MySQL :

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

PostgreSQL :

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

Utilizzare l' aritmetica libreria GNU multipla di precisione attraverso la dotazione run-exprdel programma:

• Scarica ed estrai (avrai bisogno di lzip): tar -xvf gmp-5.1.3.tar.lz
• Nella directory principale ./configuree make(non è necessario installare)
• In demo / expr, make run-expr
• Mi piace creare un link simbolico ad esso nella mia ~/bindirectory:ln -s /path/to/gmp/demos/expr/run-expr ~/bin/run-expr
• Aggiungi un alias per un facile utilizzo; ad esempio alias calcf='run-expr -f'per la valutazione in virgola mobile

Produzione:

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

Dal run-expr.cfile:

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.

Consultare il manuale per differenze e dettagli delle classi di funzioni.