¿Cómo hacer cálculos enteros y flotantes, en Bash u otros lenguajes/marcos?

Usando echo "20+5" literalmente produce el texto “20+5 “.

¿Qué comando puedo usar para obtener la suma numérica, 25 en este caso?

Además, ¿cuál es la forma más fácil de hacerlo simplemente usando bash para el punto flotante
? Por ejemplo, echo $((3224/3807.0)) imprime :(.

Estoy buscando respuestas utilizando el shell de comandos básico ('línea de comando
') en sí mismo o mediante el uso de idiomas que están disponibles desde la línea de comando
.

Respuesta aceptada:

¡¡Hay muchas opciones!!!

Resumen

$ printf %.10f\n "$((10**9 * 20/7))e-9"   # many shells. Not mksh.
$ echo "$((20.0/7))"                       # (ksh93/zsh/yash, some 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  ="

Detalles

Conchas

Puede usar la expansión aritmética POSIX para integer aritmética echo "$((...))" :

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

Bastante portátil (ash dash yash bash ksh93 lksh zsh ):
Usando la capacidad de printf para imprimir flotantes, podemos extender la mayoría de los shells para hacer matemáticas de coma flotante, aunque con un rango limitado (no más de 10 dígitos):

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

ksh93 , yash y zsh admite flotadores aquí:

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

solo ksh93 (directamente) y zsh cargando biblioteca mathfunc aquí:

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

(zsh necesita cargar zmodload zsh/mathfunc para obtener funciones como atan ).

Interactivamente 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 entero):

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

En el rc familia de conchas, akanga es el que tiene expansión aritmética:

; echo $:25/3
8

Cofre de herramientas POSIX

bc (ver más abajo para el modo interactivo), manual aquí

Nemónico:b est c calculador (aunque el b es de hecho para básico ).

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

(admite números de precisión arbitraria)

bc modo interactivo:

$ 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

La solución de Rush, expr (sin modo interactivo):

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

La solución de Joshua:awk (sin modo interactivo):

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

Otras herramientas más o menos portátiles

La solución de Arcege, dc (modo interactivo:dc ):

Lo cual es aún más divertido ya que funciona con notación polaca inversa.

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

Pero no tan práctico a menos que trabaje mucho con la notación de pulido inverso.

Relacionado:¿Encerrar o no encerrar el valor de una variable entre comillas en bash?

calc de DQdims (requerido sudo apt-get install apcalc) :

$ calc 2 + 4
6

Intérpretes de idiomas de propósito general:

solución de manatwork, node (modo interactivo:node; función de salida no necesaria):

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

Perl (modo interactivo:perl -de 1 ):

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

Pitón (modo interactivo:python; función de salida no necesaria):

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

También admite números de precisión arbitraria:

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

Si tienes clisp instalado, también puede usar la notación polaca:

$ clisp -x "(+ 2 2)"

La solución de Marco, lua (modo interactivo:lua ):

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

PHP (modo interactivo:php -a ):

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

Rubí (modo interactivo:irb; función de salida no necesaria):

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

Astucia (modo interactivo:guile ):

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

S-Lang (modo interactivo:slsh; la función de salida no es necesaria, solo un ; terminador):

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

Tcl (modo interactivo:tclsh; la función de salida no es necesaria, pero expr es):

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

Javascript conchas:

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

Varios SQL:

SQLite (modo interactivo: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

_¡Las opciones en mysql y postgres detienen la imagen 'ascii art'!

Lenguajes especializados orientados a las matemáticas:

R en modo simple:generemos 1000 números aleatorios normales y obtengamos la desviación estándar e imprimámosla

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

R usando el pequeño script – vamos a imprimir pi al cuadrado

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

PARI/PG , un extenso sistema de álgebra computacional para teoría de números, álgebra lineal y muchas otras cosas

$ 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

Octava GNU (un lenguaje interpretado de alto nivel, destinado principalmente a cálculos numéricos)

También admite números complejos:

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

Julia , lenguaje e intérprete de alto rendimiento para computación científica y numérica.

Opción no interactiva:

$ julia -E '2.5+3.7'
6.2

Script fantasma GhostScript es un intérprete de PostScript, muy comúnmente instalado incluso en distribuciones muy antiguas.
Consulte los documentos de PostScript para obtener una lista de los comandos matemáticos admitidos.

Ejemplo interactivo:

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