¿Alguna calculadora de línea de comandos para Ubuntu?

116

Estoy buscando una Calculadora que pueda hacer cálculos en el terminal mismo sin ningún otro prefijo y sufijo adicional.

Por ejemplo: si escribí algo así como 10000-9000 en la terminal, la respuesta debería aparecer como 1000.

Una vez más, estoy diciendo, solo necesito una calculadora rápida en la terminal, sin agregar ningún carácter. Sé que si cambio a Python, puede hacerlo, pero no lo quiero de esa manera.

    
pregunta Ten-Coin 18.11.2013 - 03:37

23 respuestas

72

Bash Arithmetic

Otra solución posible es agregar una función simple para la aritmética incorporada de Bash. Pon esto en tu archivo .bashrc para probar:

=() {
    echo "$(([email protected]))"
}

Así que ahora, ni siquiera necesitas $((...)) , solo = que parece lo suficientemente natural.

Reemplazo

Otra cosa si quieres ser aún más rápido: puedes hacer que reemplace p con + y x con * . Esto funcionará para eso:

=() {
    local IFS=' '
    local calc="${*//p/+}"
    calc="${calc//x/*}"
    echo "$(($calc))"
}

= 5 x 5  # Returns 25
= 50p25  # Returns 75

Ahora ya no necesitas Shift , lo único es delante de la aritmética.

Salida hexadecimal

La salida se puede mostrar en decimal y hexadecimal, si así lo desea. ( Nota : el uso de la sustitución x entrará en conflicto con la sintaxis 0x... hex)

=() {
    local answer="$(([email protected]))"
    printf '%d (%#x)\n' "$answer" "$answer"
}

Ejemplo:

$ = 16 + 0x10
272 (0x110)

$ = 16**3 + 16**4
69632 (0x11000)

Usando bc

Si desea cálculos un poco más avanzados, puede canalizarlo a bc como se muestra a continuación:

=() {
    local IFS=' '
    local calc="${*//p/+}"
    calc="${calc//x/*}"
    bc -l <<<"scale=10;$calc"
}

= 'sqrt(2)' # Returns 1.4142135623
= '4*a(1)'  # Returns pi (3.1415926532)

Las funciones proporcionadas por bc son las siguientes (y se pueden encontrar desde man bc ):

sqrt ( expression )
       The value of the sqrt function is the square root of the expression.  
       If the expression is negative, a run time error is generated.

s (x)  The sine of x, x is in radians.

c (x)  The cosine of x, x is in radians.

a (x)  The arctangent of x, arctangent returns radians.

l (x)  The natural logarithm of x.

e (x)  The exponential function of raising e to the value x.

j (n,x)
       The Bessel function of integer order n of x.

También admite if , for , while y variables como un lenguaje de programación, aunque puede ser mejor escribir en un archivo si así lo deseas.

Tenga en cuenta que sustituirá p y x en nombres de funciones / variables. Puede ser mejor simplemente eliminar los reemplazos.

Usando gcalccmd

También puede hacer que la función invoque gcalccmd (from gnome-calculator ) como tal:

=() {
    local IFS=' '
    local calc="$*"
    # Uncomment the below for (p → +) and (x → *)
    #calc="${calc//p/+}"
    #calc="${calc//x/*}"
    printf '%s\n quit' "$calc" | gcalccmd | sed 's:^> ::g'
}

= 'sqrt(2)' # Returns 1.4142135623
= '4^4'     # Returns 256

Las funciones disponibles parecen ser (tomadas directamente de el código fuente ), == denota funciones equivalentes:

ln()
sqrt()
abs()
int()
frac()
sin()
cos()
tan()
sin⁻¹() == asin()
cos⁻¹() == acos()
tan⁻¹() == atan()
sinh()
cosh()
tanh()
sinh⁻¹() == asinh()
cosh⁻¹() == acosh()
tanh⁻¹() == atanh()
ones()
twos()
    
respondido por el kiri 19.11.2013 - 10:33
88

Puedes hacer aritmética de enteros simples de forma nativa en bash usando la sintaxis ((...)) , por ejemplo,

$ echo $((10000-9000))
1000

También está la calculadora bc , que puede aceptar expresiones aritméticas en la entrada estándar

$ echo "10000-9000" | bc
1000

El programa bc también puede hacer aritmética en coma flotante

$ echo "scale = 3; 0.1-0.09" | bc
.01
    
respondido por el steeldriver 18.11.2013 - 03:59
87

Puede usar calc . No está instalado de forma predeterminada, pero puede instalarlo rápidamente con el siguiente comando:

sudo apt-get install apcalc

Después de que haya instalado, puede hacer cualquier cálculo que desee:

$ calc 5+2
    7
$ calc 5-2
    3
$ calc 5*2          
    10
$ calc 5/2
    2.5
$ calc 5^2
    25
$ calc 'sqrt(2)' 
    1.4142135623730950488
$ calc 'sin(2)'
    0.9092974268256816954
$ calc 'cos(2)'
    -0.416146836547142387
$ calc 'log(2)'
    ~0.30102999566398119521
$ calc 'sqrt(sin(cos(log(2))))^2'
    ~0.81633199125847958126
$ # and so on...

Para obtener más información, consulte su página man

    
respondido por el Radu Rădeanu 18.11.2013 - 10:16
30

Desafortunadamente, no hay una forma "más fácil" de hacer esto. La interfaz de python interactiva en la línea de comandos es la más adecuada para lo que necesita, porque a diferencia de apcalc \, python está incluido en Ubuntu. No estoy seguro si bc está incluido aún, sin embargo, Python es el favorito de manos para este material.

Puede ejecutar la interfaz interactiva python en la línea de comandos y luego hacer las matemáticas de esa manera. Puedes usar eso como tu calculadora.

Para hacerlo, abra la terminal, escriba python , luego presione el botón Enter .

Luego, en el indicador de Python que aparece, puede ingresar su matemática. Por ejemplo, 10000 - 9000 . La siguiente salida de línea es el resultado.

Sin embargo, si te refieres a algo donde solo cargas la terminal y puedes hacer esto ...

$ 10000 - 9000
1000
$

... entonces no, no hay manera de hacer esto en solo la terminal sin nada más, porque Bash no maneja argumentos numéricos como ese.

    
respondido por el Thomas Ward 18.11.2013 - 03:40
23

Te aconsejo que crees una función simple para los cálculos básicos de Python. Algo como esto en tu .bashrc :

calc() {
    python3 -c 'import sys; print(eval(" ".join(sys.argv[1:])))' "[email protected]"
}

calc 5 + 5
# Returns 10

result="$(calc 5+5)"
# Stores the result into a variable

Si desea hacer cálculos matemáticos más avanzados, puede usar el siguiente que importa todas las funciones del módulo math . (Consulte aquí para obtener más información)

calc() {
    python3 -c 'from math import *; import sys; print(eval(" ".join(sys.argv[1:])))' "[email protected]"
}

calc 'sqrt(2)'  # Needs quotes because (...) is special in Bash
# Returns 1.4142135623730951

result="$(calc 'sqrt(2)')"
# Stores the result into a variable

(Nota: como Python es un lenguaje de programación, algunas cosas pueden parecer extrañas, por ejemplo, ** para potencias de y % para módulo)

Alternativamente, puede crear un script de Python calc ,

#!/usr/bin/python3
from math import *
import sys
print(eval(' '.join(sys.argv[1:])))

colóquelo en un directorio incluido en la variable PATH y configure su indicador ejecutable para obtener el mismo comando calc que el anterior (no es necesario crear una función Bash para ejecutar un script de Python).

Si quieres un método en puro Bash, usa la respuesta de steeldriver. Esta respuesta solo es realmente beneficiosa si necesita las funciones más avanzadas (es decir, de math ), ya que Python es relativamente lento en comparación con Bash.

No estoy seguro si esto interrumpe tu "cambio a Python puede hacer eso y no lo quiero de esa manera". tenga en cuenta, pero no necesita ingresar el mensaje interactivo y el resultado está accesible en Bash, por lo que esta respuesta parece válida (para mí, al menos).

    
respondido por el kiri 18.11.2013 - 09:45
21

Utilice el paquete gcalccmd from gnome-calculator (& gt; = 13.04) o gcalctool (& lt; 13.04). Creo que el paquete está instalado por defecto

% gcalccmd
> 2+3
5
> 3/2
1.5
> 3*2
6
> 2-3
−1
> 
    
respondido por el Flint 18.11.2013 - 04:12
10

Aquí hay un script de shell rápido para esto:

#!/bin/bash
echo "[email protected]" | bc

Guarde esto como "c", luego colóquelo en algún lugar de su ruta (como / bin), luego márquelo como ejecutable.

# nano /bin/c
# chmod +x /bin/c

A partir de ahora, puede ejecutar cálculos en el terminal de esta manera:

$ c 10000-9000
1000
    
respondido por el user530873 18.11.2013 - 06:19
8

Aquí hay una modificación de la parte apropiada de /etc/bash.bashrc (en Ubuntu 10.04) que modificará el manejador command_not_found para ejecutar el evaluador de expresiones del intérprete si el primer carácter del comando desconocido es un número o - o + .

Podrás hacer cualquier aritmética de shell de esta manera; consulte enlace para obtener una lista de operadores aritméticos.

Tenga en cuenta que si la expresión que desea evaluar contiene un * , tendrá que citar el * con \ o comillas, ya que el shell hará la expansión del nombre de archivo antes de decidir qué comando ejecutar. Lo mismo para otros operadores como >> .

Pon esto en tu ~/.bashrc , luego escribe . ~/.bashrc y pruébalo.

# if the command-not-found package is installed, use it
if [ -x /usr/lib/command-not-found -o -x /usr/share/command-not-found ]; then
    function command_not_found_handle {
        if [[  == [0-9+-]* ]]; then
           echo $(( [email protected] ))
        elif [ -x /usr/lib/command-not-found ]; then
           /usr/bin/python /usr/lib/command-not-found -- 
           return $?
        elif [ -x /usr/share/command-not-found ]; then
           /usr/bin/python /usr/share/command-not-found -- 
           return $?
        else
           return 127
        fi
    }
fi

Ejemplo de salida: (Estoy escribiendo cta , un error tipográfico, solo para probar que nuestro nuevo controlador command_not_found aún intentará buscar comandos desconocidos).

[email protected]:~$ cta
No command 'cta' found, did you mean:
 Command 'cda' from package 'xmcd' (universe)
 Command 'cat' from package 'coreutils' (main)
cta: command not found
[email protected]:~$ 9000-1000
8000
    
respondido por el Mark Plotnick 18.11.2013 - 18:05
8

Otra solución que no he visto mencionar aquí es Qalculate (qalc) .

sudo apt-get install qalc

para la versión CLI,

sudo apt-get install qalculate-gtk

para la GUI.

Tiene varias funciones, como:

  • soporte para unidades : p. %código%
  • constantes incorporadas como 20 m / s * 12 h = 864 kilom , pi , e , c
  • muchas funciones incorporadas: p. avogadro , sin(pi) = 0 , gamma(4) = 6 , 5! = 120
  • conversión de unidades, por ejemplo:
  

log(1024, 2) = 10
> 120 in
120 * inch = 120 in
> convert cm

  • cálculo simbólico , p. %código%
  • integración, p. 120 in = 304.8 centim , (x + y)^2 = x^2 + 2xy + y^2
  • ayuda incorporada, p. integrate 3*x^2 = x^3 , diff sin(x), pi
  • completar pestañas de comandos
  • todo está traducido, p. mi sistema está en holandés, entonces puedo escribir tanto help convert como help integrate .
  • y más ...

Dice que quiere usarlo sin prefijos, bueno ... puede usarlo con un prefijo:

factorial(5)

y ejecutarlo como una respuesta.

    
respondido por el JW. 26.11.2013 - 11:46
7

dc ! Es parte de coreutils, por lo que está instalado en OS X, Ubuntu y casi TODO lo demás. Es una calculadora RPN, así que si no te gustan, no es para ti.

Los comandos

Muy básicos son los siguientes (la página del manual tiene toda la sintaxis que no incluí. Exponenciación, ¿alguien?)

Solo necesitas espacios entre números. Se ignoran en todos los demás casos.

Escribir un número lo empuja a la parte superior de la pila.

+ Adds top 2 items in stack, then pushes result to stack ('2 4 +p' outputs 6)
- Subtracts top 2 items in stack, then pushes result to stack ('4 2 -p' outputs 2)
* Multiplies top 2 items in stack, then pushes result to stack ('6 5 *p' outputs 30)
/ Divides top 2 items in stack, then pushes result to stack ('54 7 /p' outputs 8)
p Print top item in stack, without destroying it
c Clear stack
r Swap top 2 items on stack
d Duplicate top item on stack
k Pops top item off stack, using it to determine precision (so 10 k would print 10 numbers after the decimal point). Default is 0, so it won't do floating point math by default.
n Pops top value off stack, then sends to stdout without a trailing newline
f Dump stack. Useful for finding what something does
    
respondido por el Yet Another User 18.11.2013 - 21:07
5

Utilizo Octave para este tipo de cosas: enlace

Es más o menos un clon de matlab (se disculpa si esto es una simplificación excesiva) que se puede usar en el terminal escribiendo octava. Instale sudo apt-get install octave

No es exactamente lo que quieres, pero pensé que lo agregaría como alternativa a Python.

Uso de ejemplo:

~ $ octave
octave:1> 9000 - 8000
ans =  1000
octave:2> 
    
respondido por el Andy T 18.11.2013 - 15:39
5

Me gusta mucho el wcalc. Es una calculadora científica de línea de comando. Fácil de encontrar en el Centro de Software de Ubuntu, o simplemente use apt-get.

sudo apt-get install wcalc

Acepta argumentos de línea de comando y también tiene el modo "shell":

# simple operation
$ wcalc 2+2
 = 4
# Quoting is necessary to prevent shell from evaluating parenthesis
$ wcalc "(2+2)*10"                                                                                    
 = 40
$ wcalc "sqrt(25)"                                                                                    
~= 5
# in shell mode you can evaluate multiple commands repeatedly
$ wcalc
Enter an expression to evaluate, q to quit, or ? for help:
-> 12*20+1
 = 241
-> sin(90)
 = 1
-> sin(pi/2)
 = 0.0274121

Y si alguien está en ingeniería, como yo, podría utilizar GNU Octave. Puede hacer todo tipo de cosas, graficar, resolver ecuaciones simultáneas. Además, es una alternativa gratuita a Matlab

    
respondido por el Sergiy Kolodyazhnyy 22.09.2014 - 11:58
4

la forma simple es llamar a Python.

Ejemplo:

>  python -c 'print 10000-9000'
    
respondido por el user2327875 20.11.2013 - 14:35
3

Lo que he encontrado es que no puedo confiar en expr, bc o en las opciones de Shell integradas. Por lo tanto, utilicé Perl, que normalmente se instalaría en * dislex de Linux

perl -le 'printf "%.0f", eval"@ARGV"' "($VAL2-$VAL1)"

El cálculo anterior restará $ VAL1 de $ VAL2 e imprimirá sin decimales (0f)

Aproveche Perl es (detalles de Ventajas y desventajas enumeradas aquí )

  • Mejor captura de errores (dividir entre 0 no detendrá el cálculo)
  • Puede proporcionar fórmulas en un archivo de configuración. No es necesario escapar utilizando expresiones regulares complejas
respondido por el diaryfolio 18.11.2013 - 11:14
3

Puede agregar la siguiente función a su archivo .bashrc:

function = {
  echo "[email protected]" | bc -l
}

Tenga en cuenta que el indicador -l es muy importante. Sin él, el uso de bc da 5 / 2 = 2 .

Como se mentó anteriormente, los cálculos se pueden hacer usando el signo = delante de la fórmula.

    
respondido por el vdm 19.11.2013 - 14:51
3

También puedes utilizar awk para hacer algunos cálculos aritméticos en la terminal,

echo 10000 9000 | awk '{print -}'
1000
echo 10000 9000 | awk '{print +}'
19000
echo 10000 9000 | awk '{print /}'
1.11111
echo 10000 9000 | awk '{print *}'
90000000
    
respondido por el Avinash Raj 05.01.2014 - 19:41
2

usa el comando "bc" y luego puedes hacer cálculos

ejemplo

[[email protected] ~]# bc

----------these lines will genrate automaicaly---------------

right 1991-1994, 1997, 1998, 2000, 2004, 2006 Free Software Foundation, Inc.
This is free software with ABSOLUTELY NO WARRANTY.
For details type 'warranty'. 

---------------enter your calculation here---------------------------------------


10+2   

12

Para usar bc sin la nota de garantía, escriba en el terminal bc -q

ejemplo

[[email protected] ~]# bc -q
10+2
12
    
respondido por el Vaibhav Jain 19.11.2013 - 08:18
2

Puede usar bind y bash C-a y C-e para controlar la salida. Por ejemplo, ejecútelo en su shell:

bind '"\C-j": "\C-aecho $(( \C-e )) \C-m"'

Ahora escriba cualquier operación aritmética como 10 + 15 y presione Ctrl + J :

$ echo $(( 10 + 15 )) 
25

Obtendrás esto. Ahora, ¿cómo se hace?

  • bind Este comando cambia el enlace de tu bash, como las teclas de método abreviado.
  • \C-j este es el equivalente de bash a Ctrl + J, esta es la combinación de teclas que nos gustaría agregar a nuestro comando.
  • \C-a esto nos lleva al comienzo de la línea.
  • echo $(( esto escribe echo $(( al inicio.
  • \C-e nos lleva al final de la línea
  • )) cierra nuestro paréntesis anterior
  • \C-m esto es el equivalente a la tecla de retorno.

Puedes escribir esto en tu archivo ~/.inputrc :

"\C-j": "\C-aecho $(( \C-e )) \C-m"

¡Por supuesto, las otras respuestas también son válidas! Solo pellizqué un poco:

  • bc: "\C-j": "\C-aecho " \C-e " | bc \C-m"
  • apcalc: "\C-j": "\C-acacl \C-m"
  • python: "\C-j": "\C-apython3 -c "print( \C-e )" \C-m"
  • ¿otros?

Puedes cambiar Ctrl + J a lo que quieras, pero recuerda, intenta no cambiarlo por algo que ya tenga un enlace;).

Recurso:

respondido por el Braiam 20.11.2013 - 01:55
2

En el pasado, he usado wcalc y un pequeño programa llamado e que es prácticamente imposible google para. Ahora uso un script de python para hacer esto, que usa algunas características de e como los corchetes. wcalc sigue siendo bueno porque puede hacer una precisión arbitraria y conversión de unidades, pero casi nunca uso esas características.

#!/usr/bin/env python3

"""
This is a very simple command line calculator.  It reads in all
arguments as a single string and runs eval() on them.  The math module
is imported so you have access to all of that.  If run with no
arguments, it allows you to input a single line expression.  In the
case of command line args, square brackets are replaced with round
parentheses, because many shells interpret round parentheses if they
are not quoted.
"""

import sys, numbers
import cmath, math

args = sys.argv[1:]

if len(args) < 1:
    expr = input()
else:
    expr = " ".join(args[:])
    expr = expr.replace("[", "(").replace("]", ")")

def log2(x):
    """Return the base-2 logarithm of x."""
    return cmath.log(x, 2)

# the smallest number such that 1+eps != 1
# (this is approximate)
epsilon = sys.float_info.epsilon

env = math.__dict__
env.update(cmath.__dict__)
env = {k:v for k,v in env.items() if not k.startswith("__")}
env["eps"] = epsilon
env["log2"] = log2
env["inf"] = float("inf")
env["nan"] = float("nan")

res = eval(expr, env)
# throw away small imaginary parts, they're probably just due to imprecision
if (isinstance(res, numbers.Number)
    and res != 0
    and abs(res.imag)/abs(res) < 10*epsilon):
    res = res.real

print(str(res).replace("(", "[").replace(")", "]"))

Aquí se explica cómo usarlo (suponiendo que el script se haya guardado como e y puesto en algún lugar en $PATH ):

$ e e**[pi*1i]
-1.0
$ e hex[10**3]
0x3e8
$ e "[0o400+3]&0xff" # need quotes because of '&'
3
    
respondido por el jpkotta 18.11.2013 - 17:20
0

Hay una forma de lograr exactamente lo que quieres. Todo lo que necesita hacer es establecer shell para su cuenta en /bin/bc .

    
respondido por el bizzyunderscore 21.11.2013 - 02:29
0

También puede usar printf shell built-in para hacer cálculos aritméticos en el terminal.

printf 'expr $num1 + $num2'   # num1,num2 are  variables which stores numbers as values.

Ejemplo:

$ printf "$(expr 10000 + 9000)\n"
19000
$ printf "$(expr 10000 - 9000)\n"
1000
    
respondido por el Avinash Raj 16.04.2014 - 15:26
0

Puedes usar el intérprete de Python para el cálculo. Aquí hay un tutorial sobre cómo hacerlo .

Python 2 y Python 3 están instalados en Ubuntu de manera predeterminada.

$ python
Python 2.7.12 (default, Nov 19 2016, 06:48:10) 
[GCC 5.4.0 20160609] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> 2+2
4
>>> 3*5
15
    
respondido por el noone 27.08.2017 - 12:08
0

Crear una calculadora de terminal

Coloque lo siguiente en su archivo .bashrc

function calc
{
 echo ""|bc -l;
}

O ejecútelo en el indicador de shell. Ahora   "calc" del shell funcionará de la siguiente manera:

$ calc 3+45
   48

Todas las funciones con un "(" o ")" deben adjuntarse   entre comillas.

    
respondido por el Vishnu N K 31.01.2014 - 18:17

Lea otras preguntas en las etiquetas