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

Usar echo "20+5"literalmente produce el texto " 20+5".

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

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

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

¡¡¡Hay muchas opciones!!!

Resumen

$ 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

Detalles

Conchas

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

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

Totalmente portátil ( ash dash yash bash ksh93 lksh zsh):
Al usar la capacidad printf para imprimir flotantes, podemos extender la mayoría de las conchas para hacer cálculos 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, yashy zshadmite flotadores aquí:

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

solo ksh93(directamente) y zshcargando la biblioteca mathfunc aquí:

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

( zshnecesita cargar zmodload zsh/mathfuncpara 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 la rcfamilia de shell, akangaes el que tiene expansión aritmética:

; echo $:25/3
8

POSIX toolchest

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

Mnemónico : bes calculador (aunque bde hecho es básico ).

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

(admite números de precisión arbitrarios)

modo interactivo de 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

La solución de Rushexpr (sin modo interactivo):

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

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 mediante notación de pulido inverso.

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

Pero no es tan práctico a menos que trabajes mucho con la notación polaca inversa.

^{Tenga en cuenta que dces anterior bce bchistóricamente se ha implementado como una envoltura, dcpero dcPOSIX no lo estandarizó}

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

$ calc 2 + 4
6

Intérpretes de lenguaje de uso general:

La solución de manatworknode (modo interactivo: nodeno se necesita la función de salida):

$ 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

Python (modo interactivo: pythonno se necesita la función de salida):

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

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

Si lo ha clispinstalado, también puede usar la notación polaca:

$ clisp -x "(+ 2 2)"

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

Ruby (modo interactivo: irbno se necesita la función de salida):

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

Guile (modo interactivo:) guile:

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

S-Lang (modo interactivo: slshno se necesita la función de salida, 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 expres):

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

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

Varios SQL's:

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 del 'arte ascii'!

Lenguajes especializados orientados a las matemáticas:

R en modo plano: permite generar 1000 números aleatorios normales y obtener la desviación estándar e imprimirla

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

R usando el script más pequeño : permite imprimir pi al cuadrado

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

PARI / GP , 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

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

También es compatible con números complejos:

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

Julia , lenguaje e intérprete de alto rendimiento para informática científica y numérica.

Opción no interactiva:

$ julia -E '2.5+3.7'
6.2

Hay muchas formas de calcular. Para expresiones simples puedes usarlo bash:

echo $((20+5))

o expr:

expr 20 + 5

Y para casos complejos hay una gran herramienta bc:

echo "20+5" | bc

Por cierto, bc puede calcular incluso expresiones muy complejas con raíces, logaritmos, cos, sin, etc.

Las soluciones mencionadas están bien para cálculos muy simples, pero muy propensos a errores. Ejemplos:

# 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

Un error de sintaxis como los últimos se nota fácilmente, pero las respuestas enteras con una parte flotante descartada pueden pasar desapercibidas y dar lugar a resultados incorrectos.

Es por eso que siempre uso un lenguaje de script como Lua para eso. Pero puede elegir cualquier lenguaje de script con el que esté familiarizado. Solo uso Lua como ejemplo. Las ventajas son

• una sintaxis familiar
• funciones familiares
• advertencias familiares
• entrada flexible
• los espacios generalmente no importan
• salida de punto flotante

Ejemplos:

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

¿Nadie ha mencionado awk todavía?

Usando las funciones de shell POSIX y awk math power, simplemente defina esta función (una línea):

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

Luego solo ejecuta cosas como calc 1+1ocalc 5/2

Nota: Para que la función esté siempre disponible, agréguela a ~ / .bashrc (o al archivo de inicio de su shell correspondiente)

Por supuesto, un pequeño script llamado "calc" con los siguientes contenidos:

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

También podría funcionar.

Podrías usar bc. P.ej,

$ echo "25 + 5" | bc
30

Alternativamente bc <<< 25+5también funcionará.

O interactivamente, si desea hacer más que un simple cálculo simple:

$ 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

La implementación de GNU bcimprime esa información de encabezado / copyright en el inicio cuando tanto su stdin como su stdout van a un terminal. Puede suprimirlo con la -qopción (específica de GNU) . Para obtener más información, consulte la página de manual de bc

Puedes usar calc:

Si solo ingresa calcsin otros argumentos, ingresa a un modo interactivo donde puede seguir haciendo matemáticas. Salga de esto escribiendo 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

O lo usa con la expresión como argumento y proporcionará la respuesta y luego saldrá

$calc 2 + 4
    6
$

calces similar a bc, simplemente me gusta la forma en que se comporta mejor por defecto

Me gusta iniciar Python y usarlo como una calculadora interactiva (pero, de nuevo, soy un programador de Python).

Como nadie más lo ha mencionado, y aunque no es estrictamente una calculadora (pero tampoco lo son todos estos lenguajes de script de propósito general), me gustaría mencionar units:

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

O, para obtener menos resultados para que pueda obtener solo el número que se usará $()para asignar a algo:

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

E incluso hace conversiones de temperatura

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

Para obtener la conversión de temperatura en una expresión para un cálculo adicional, haga esto:

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

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

Además ghci, ese es el compilador Glasgow-Haskell en modo interactivo ( ghc --interactiveen lugar de evaluar una expresión con -e), hace una "calculadora" fascinante:

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

No puedo creer leer "el poder de JavaScript" (pero tuve que votar la respuesta para las otras partes, excepto Perl, por supuesto).

Prácticamente, para los casos simples donde la aritmética de enteros es suficiente, uso el buildin $ ((...)) y lo recomiendo. De lo contrario, en casi todos los casos se hace eco de "..." | BC es suficiente.

Para algunas operaciones aritméticas como estadísticas, operaciones matriciales y más Res la mejor herramienta:

echo 25 + 5 | R --vanilla

y para pequeños conjuntos de datos y resultados gráficos desechables, oocalces una buena utilidad.

Utilizo un pequeño script de Python que evaluará una expresión de Python e imprimirá el resultado, luego puedo ejecutar algo como

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

el guión es:

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

Desafortunadamente, no recuerdo de dónde tomé prestado la mayor parte del código, así que no puedo citarlo.

Gnuplot

gnuplot: un programa de trazado interactivo
Siga el enlace anterior o escribagnuplotel mensaje y luegohelpdentro delintérprete de gnuplot .
Gnuplot es un programa nacido para trazar datos, pero también se puede utilizar para el cálculo. Ofrece la ventaja de que puede definir funciones y / o utilizar las integradas.

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 algún otro intérprete de C )

El sistema ROOT proporciona un conjunto de marcos OO con toda la funcionalidad necesaria para manejar y analizar grandes cantidades de datos de una manera muy eficiente ...

Se puede utilizar como C intérprete , CINT , o puede utilizar uno de los muchos muchos otros intérpretes C . En mi humilde opinión, es enorme, complejo, poderoso y no siempre amigable, pero también puede dar una gran satisfacción.

Si realmente no desea escuchar la pequeña voz dentro de usted que cita a Confucio y está listo para romper una mosca (mantequilla) en la rueda , puede usar la raíz . En este caso -les obligatorio evitar mostrar la pantalla de bienvenida ...

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

Para aritmética de enteros (donde 3/2 = 1)

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

*: y ksh93, yash

Para aritmética de coma flotante (donde 3/2 = 1.5)

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

*: y ksh93, yash

Por supuesto, puede configurar su shell para usar awk con un mínimo de mecanografía calc 10/3(ver notas sobre cómo hacerlo para bash ¹ y fish ² ).

La razón principal para sugerir awk para bash es que está preinstalado en casi todos los sistemas operativos tipo Unix y es razonablemente ligero (por supuesto, existe el costo de iniciar un proceso) con una salida menos precisa pero más amigable para los humanos bc -lque imprime 20 decimales dígitos (aunque ciertamente puede ajustar awk para obtener más dígitos decimales ).

Notas

(1) Cómo usar la sintaxis simplificada en bash

Agregue esta función bash a su ~/.bashrc:

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

(2) Cómo usar la sintaxis simplificada en peces

Cree una calcfunción de pez (es decir, un archivo de texto llamado /home/ndemou/.config/fish/functions/calc.fish):

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

Para los cálculos de la consola, yo uso concalc. ( sudo aptitude install concalc)

Después de eso, simplemente escriba concalc y presione enter. No proporcionará un mensaje, pero solo ingrese su cálculo (sin espacios) y presione enter, y en la siguiente línea, le dará el valor numérico.

SQLite :

echo 'select 1 + 1;' | sqlite3 

MySQL :

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

PostgreSQL :

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

Utilice la Biblioteca aritmética de precisión múltiple GNU a través del run-exprprograma suministrado :

• Descargue y extraiga (necesitará lzip): tar -xvf gmp-5.1.3.tar.lz
• En el directorio superior ./configurey make(no es necesario instalar)
• En demos / expr, make run-expr
• Me gusta crear un enlace simbólico en mi ~/bindirectorio:ln -s /path/to/gmp/demos/expr/run-expr ~/bin/run-expr
• Agregue un alias para un uso fácil; por ejemplo alias calcf='run-expr -f'para evaluación de coma flotante

Salida:

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

Del run-expr.carchivo:

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.

Consulte el manual para conocer las diferencias y detalles de las clases de funciones.