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

294

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.

Michael Durrant
fuente
1
Si va con bc, puede valer la pena leer sobre la -lopción en la página del manual.
Glenn Jackman
Supongo que el autor está pidiendo la línea de comando bash, mientras que todas las respuestas tienden a diversificarse a todo tipo de lenguajes de secuencias de comandos.
Zinking
2
hombre bash → / expresión
ДМИТРИЙ МАЛИКОВ
1
@zinking Bueno, bash está diseñado para poder invocar fácilmente a los intérpretes para una gran cantidad de otros lenguajes de secuencias de comandos.
Random832
Enseñe a bash integer division con resultados de coma flotante: stackoverflow.com/a/24431665/3776858
Cyrus el

Respuestas:

399

¡¡¡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
Stéphane Chazelas
fuente
3
y bc es interesante: whatis bc-> An arbitrary precision calculator language ¡Interesante! ¡Gracias!
Michael Durrant
@MichaelDurrant, ¿podría volver a revisar sus ediciones, debo haberlo rechazado por error?
lgarzo
44
También hay dc, que es aún más divertido, ya que funciona mediante notación de pulido inverso. echo 20 5 + p | dc Pero no es tan práctico a menos que trabajes mucho con la notación polaca inversa.
Arcege
2
Como una variación en el enfoque bc, agregué la siguiente función (que encontré en stackexchange en alguna parte) a mi archivo .bashrc. Puedo ingresar a calc 2 + 3 y obtener 5. ## Command line calculator calc () { bc -l <<< "$@" }
Joe
1
@ Chris, el pescado es un blanco en movimiento. Están trabajando en su nueva mathconstrucción (o como se llame ahora) mientras hablamos. Siéntase libre de editar. No es mi respuesta y es el wiki de la comunidad.
Stéphane Chazelas
35

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.

prisa
fuente
Agregué su expropción a la respuesta aceptada. Tuve que elegir uno para aceptar y centralizar.
Michael Durrant
3
Estás intentando ejecutar expr 20+5. Necesita escribir espacios entre números y además para hacer que funcione: expr 20 + 5. Eso es importante.
fiebre
24

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
Marco
fuente
2
bcEl resultado no es entero, solo se redondea a scale, cuyo valor predeterminado es 0. Entonces, bc <<< 'scale=4;9.0/2.0'si desea la parte fraccionaria.
manatwork
Gracias por la corrección. Pero aún así, es propenso a errores. ¿Recordaré agregar scalesi lo uso bcen un par de semanas? Probablemente no. E incluso si hay una manera de cambiarlo permanentemente, te morderá si estás en un sistema con la configuración predeterminada.
Marco
3
Personalmente recuerdo scaledesde que me conocí bchace años. Pero siempre olvidé si la función de salida en luaes puto puts. ;)
manatwork
Solo cuenta bc como uno de los lenguajes de scripting. Siempre sé si necesito resultados enteros o no; si el número entero está bien, me quedo en bash, de lo contrario, rara vez tengo razones para usar bc. Para lua, debes recordar -e, imprimir y paréntesis.
Usuario desconocido
77
Solo use siempre en bc -llugar de simple bc, luego nunca se preocupe scale.
Dalker
23

¿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.

Joshua
fuente
2
Wow, este es el mejor, incluso admite flotadores. ¡Funciona sin instalar nada!
CMCDragonkai
1
Muy bien, quería tener una comparación flotante, así es como lo hice con su ayuda:a=0; b=0.0; if echo "$a" "$b" | awk '{ exit ($1 == $2) ? 0 : 1 }'; then echo 'equals'; else echo 'not equals'; fi
Paul Tobias
18

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

Levon
fuente
1
+1 para las opciones de tubería ("|") y de modo interactivo para bs. ¿Uno ctrl-dpara salir?
Michael Durrant
1
@MichaelDurrant Sí, ^ D hará el truco como lo haráquit
Levon
c () { bc -l <<< "$@" } definirá una función c para un uso rápido y fácil. Por ejemplo, c 3/2te dará 1.50000000000000000000. El enlace de arriba que describe cómo hacerlo está muerto.
ijoseph
1
@Levon el enlace de la página man todavía funciona. Sin embargo, el enlace: paweng.com/2008/08/15/unix-command-line-calculator , que usted proporciona como el objetivo de "Esto" en la oración "Esta página también muestra cómo configurar un alias ..." muerto.
ijoseph
1
@ijoseph Gracias ... Eliminé la referencia a ese enlace de 6 años (desearía que los enlaces se destacaran más claramente en mi navegador, ni siquiera lo vi cuando miré ayer)
Levon
16

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

KennyPeanuts
fuente
1
No necesita ingresar al modo interactivo, a menos que quiera, por ejemplo: calc -e '2+4; 3+5; 3.4+5; 2^4imprime 4 líneas de salida, o simplemente calc -e 33+(3^3)... +1 Me gusta la idea de usar algo llamado 'calc' para una calculadora :)
Peter.O
1
Me acabo de dar cuenta de que la -eopción no es necesaria cuando solo hay una expresión ... ¡
genial
10

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

asmeurer
fuente
¡yo también! Python es mi navaja suiza
Levon
Siempre tengo una ventana en screensolo ejecutar Python.
Arcege
1
pythonpy ( github.com/russell91/pythonpy ) es una buena manera de hacer esto y otras cosas en la sintaxis de python sin tener que
activar
Me gusta Python, pero su hora de inicio se vuelve importante si solo desea agregar dos números en algunos lugares de su script de bash
ndemou
@ndemou dije calculadora "interactiva". Aunque también vale la pena señalar que, en algún momento, si está haciendo cosas lo suficientemente complejas en un script, la cordura dicta que use algo más que bash (como Python).
asmeurer
10

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
Aleatorio832
fuente
Hay tantas opciones que no requieren la instalación de un programa adicional que no veo por qué uno querría ir por ese camino.
ndemou
@ndemou Está instalado por defecto en algunas distribuciones ... y muchas de estas otras respuestas no lo están. ¿Y realmente necesita comentar eso en una respuesta que tiene cinco años?
Random832
1
Creo que es bueno comentar cuando rechazo el voto y es una práctica que también es alentada por SE. No veo por qué cinco años son relevantes. El mismo comentario se aplica a todas las respuestas similares, nada personal. (Por cierto, incluso el programa más oscuro se puede instalar de forma predeterminada en alguna distribución. En este caso, he probado instalaciones recientes de Debian, Ubuntu, CentOS y RedHat y las unidades no)
ndemou
6
$> 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
ДМИТРИЙ МАЛИКОВ
fuente
3
¿Es eso ghcel compilador de Glasgow Haskell?
manatwork
tomando un pase en los programas que necesito instalar pero gracias.
Michael Durrant
4

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.

usuario desconocido
fuente
4

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.

cobbal
fuente
no print(eval(' '.join(sys.argv[1:])))haría lo mismo?
g.rocket
Estás usando un martillo para golpear una mosca aquí
ndemou
4

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
Hastur
fuente
4

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 1 y fish 2 ).

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
ndemou
fuente
awkusará el doubletipo de punto flotante de su sistema , por lo que será tan preciso como la mayoría de las otras herramientas que no hacen precisión arbitraria (tenga en cuenta que gawk puede hacer precisión arbitraria). awkusa la OFMTvariable para convertir el número a su representación de cadena para la salida ( %.6gde manera predeterminada, es posible que desee cambiar eso %.17gsi desea una mayor precisión ).
Stéphane Chazelas
Tenga en cuenta que fish's mathes sólo una función que llama bc(aunque eso es cambiar )
Stéphane Chazelas
1
Bueno, era una función que llama bc. Ya no está en las versiones más nuevas donde las cosas como math "scale=4; 10/3"ya no funcionan (en math -s4 10/3cambio ahora)
Stéphane Chazelas
Gracias Stéphane Chazelas - He actualizado mi respuesta ( math -s4parece que también es compatible con versiones anteriores)
ndemou
3

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.

asesino
fuente
3

SQLite :

echo 'select 1 + 1;' | sqlite3 

MySQL :

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

PostgreSQL :

psql -c 'select 1 + 1 as sum;'
Vidul
fuente
3
Algunos detalles menores que vale la pena mencionar: 1) from duales necesario para Oracle, MySQL puede hacerlo selectsin fromcláusula. 2) PostgreSQL no requiere el alias. 3) El ;solo es requerido por SQLite. 4) MySQL y PostgreSQL funcionarán solo si pueden conectarse a un servidor de base de datos. 5) MySQL y PostgreSQL dibujarán una tabla de arte ASCII alrededor de los resultados. Para obtener solo el valor: mysql -BNe 'select 1+1'y psql -tAc 'select 1+1.
manatwork
2

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.


fuente