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

Estoy buscando una calculadora que pueda hacer cálculos en el terminal sin otros prefijos y sufijos adicionales.

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

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

Aritmética Bash

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

=() {
    echo "$(($@))"
}

Así que ahora, ya no necesitas $((...))más, solo lo =que parece bastante natural.

Reemplazo

Otra cosa si quieres ser aún más rápido: puedes reemplazarlo pcon +y xcon *. Esto funcionará para eso:

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

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

Ahora ya ni siquiera lo necesitas Shift, lo único está = delante de la aritmética.

Salida hexadecimal

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

=() {
    local answer="$(($@))"
    printf '%d (%#x)\n' "$answer" "$answer"
}

Ejemplo:

$ = 16 + 0x10
272 (0x110)

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

Utilizando bc

Si desea cálculos un poco más avanzados, puede canalizarlo bcasí:

=() {
    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 bcson las siguientes (y se pueden encontrar en 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 es compatible con if, for, whiley variables como un lenguaje de programación, aunque si puede ser mejor para escribir en un archivo si quería eso.

Tenga en cuenta que sustituirá py xen nombres de funciones / variables. Puede ser mejor simplemente eliminar los reemplazos.

Utilizando gcalccmd

También puede hacer que la función llame gcalccmd(desde gnome-calculator) así:

=() {
    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 del código fuente ), ==denotan 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()

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

$ echo $((10000-9000))
1000

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

$ echo "10000-9000" | bc
1000

El bcprograma también puede hacer aritmética de coma flotante

$ echo "scale = 3; 0.1-0.09" | bc
.01

Puedes usar calc. No se instala de manera predeterminada, pero puede instalarlo rápidamente con el siguiente comando:

sudo apt-get install apcalc

Después de haberlo 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, vea su página de manual

Desafortunadamente, no hay una forma "más fácil" de hacer esto. La interfaz interactiva de Python en la línea de comandos es la más adecuada para lo que necesita, porque a diferencia de apcalc\, pythonse incluye en Ubuntu. No estoy seguro de si bctodavía se incluye, sin embargo, Python es el favorito para estas cosas.

Simplemente puede ejecutar la pythoninterfaz interactiva en la línea de comando, y luego hacer las matemáticas de esa manera. Puedes usar eso como tu calculadora.

Para hacer eso, abre la terminal, escribe python, luego presiona el Enterbotón.

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

Sin embargo, si quieres decir algo en lo que solo cargas la terminal y puedes hacer esto ...

$ 10000 - 9000
1000
PS

... entonces no, no hay forma de hacer esto solo en la terminal sin otra cosa, porque Bash no maneja argumentos numéricos como ese.

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

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

calc 5 + 5
# Returns 10

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

Si desea hacer matemáticas más avanzadas, puede usar la siguiente que importa todas las mathfunciones del módulo. (ver aquí para más información)

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

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

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

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

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 PATHvariable y establezca su indicador ejecutable para obtener el mismo calccomando que el anterior (no es necesario crear una función Bash para ejecutar un script Python).

Si desea un método en puro Bash, use 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 rompe su "cambio a Python, puede hacer eso y no lo quiero de esa manera". tenga en cuenta, pero no es necesario que ingrese la solicitud interactiva y el resultado es accesible en Bash, por lo que esta respuesta parece válida (al menos para mí).

Use el paquete gcalccmdfrom gnome-calculator(> = 13.04) o gcalctool(<13.04). Creo que el paquete está instalado por defecto

% gcalccmd
> 2+3
5
> 3/2
1.5
> 3*2
6
> 2-3
−1
> 

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

#!/bin/bash
echo "$@" | bc

Guarde esto como "c", luego póngalo 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

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

Podrá hacer cualquier cálculo aritmético de esta manera; consulte http://www.gnu.org/software/bash/manual/bashref.html#Shell-Arithmetic para obtener una lista de operadores aritméticos.

Tenga en cuenta que si la expresión que desea evaluar contiene a *, deberá citar *con \o entre comillas, ya que el shell realizará 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 . ~/.bashrcy 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 [[ $1 == [0-9+-]* ]]; then
           echo $(( $@ ))
        elif [ -x /usr/lib/command-not-found ]; then
           /usr/bin/python /usr/lib/command-not-found -- $1
           return $?
        elif [ -x /usr/share/command-not-found ]; then
           /usr/bin/python /usr/share/command-not-found -- $1
           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).

mp@ubuntu:~$ cta
No command 'cta' found, did you mean:
 Command 'cda' from package 'xmcd' (universe)
 Command 'cat' from package 'coreutils' (main)
cta: command not found
mp@ubuntu:~$ 9000-1000
8000

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

sudo apt-get install qalc

para la versión CLI,

sudo apt-get install qalculate-gtk

para la GUI

Tiene un montón de características como:

• soporte para unidades : ej.20 m / s * 12 h = 864 kilom
• incorporada constantes tales como pi, e, c,avogadro
• muchos incorporadas funciones : por ejemplo sin(pi) = 0, gamma(4) = 6, 5! = 120,log(1024, 2) = 10
• conversión de unidades, por ejemplo:

> 120 in
120 * inch = 120 in
> convert cm
120 in = 304.8 centim

• cálculo simbólico , p. ej.(x + y)^2 = x^2 + 2xy + y^2
• integración, por ejemplo integrate 3*x^2 = x^3,diff sin(x), pi
• ayuda incorporada, por ejemplo help convert,help integrate
• tabulación de comandos
• todo está traducido, por ejemplo, mi sistema está en holandés, por lo que puedo escribir ambos factorial(5)y faculteit(5).
• y más...

Dices que quieres usarlo sin prefijos, bueno ... puedes usarlo con un prefijo:

$ qalc 5 ft + 3 cm
(5 * foot) + (3 * centim) = 1.554 m

así como ejecutarlo como respuesta.

dc! Es parte de coreutils, por lo que está instalado en OS X, Ubuntu y prácticamente 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 de 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

Yo uso Octave para este tipo de cosas: http://www.gnu.org/software/octave/

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

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

Ejemplo de uso:

~ $ octave
octave:1> 9000 - 8000
ans =  1000
octave:2> 

Me gusta mucho 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 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

manera simple es llamar a python.

Ejemplo:

>  python -c 'print 10000-9000'

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

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

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

El beneficio de usar Perl es (detalles de Pros y contras listados aquí )

• Mejor captura de errores (dividir por 0 no detendrá el cálculo)
• Puede proporcionar fórmulas en un archivo de configuración. No es necesario escapar usando expresiones regulares complejas

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

function = {
  echo "$@" | bc -l
}

Tenga en cuenta que la -lbandera es muy importante. Sin ella, el uso de bcda 5 / 2 = 2.

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

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

echo 10000 9000 | awk '{print $1-$2}'
1000
echo 10000 9000 | awk '{print $1+$2}'
19000
echo 10000 9000 | awk '{print $1/$2}'
1.11111
echo 10000 9000 | awk '{print $1*$2}'
90000000

use el comando "bc" y luego puede hacer el cálculo

ejemplo

[root@vaibhav ~]# 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 bcsin la nota de garantía escriba en el terminalbc -q

ejemplo

[root@vaibhav ~]# bc -q
10+2
12

Puede usar bind y bash C-ay C-epara controlar la salida. Por ejemplo, ejecute esto 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 su bash, como las teclas de acceso directo.
• \C-j este es el bash equivalente a Ctrl + J, esta es la combinación de teclas que nos gustaría agregar a nuestro comando.
• \C-a Esto nos lleva al inicio de la línea.
• echo $((Esto escribe echo $((al principio.
• \C-e nos lleva al final de la línea
• )) cierra nuestro paréntesis anterior
• \C-m Este es el equivalente a la tecla de retorno.

Puede escribir esto en su ~/.inputrcarchivo:

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

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

• antes de Cristo: "\C-j": "\C-aecho " \C-e " | bc \C-m"
• apcalc: "\C-j": "\C-acacl \C-m"
• pitón: "\C-j": "\C-apython3 -c "print( \C-e )" \C-m"
• ¿cualquier otro?

Puede cambiar Ctrl + J a lo que quiera, pero recuerde, intente no cambiarlo por algo que ya tenga un enlace;).

Recurso:

• ¿Hay alguna manera de configurar bash para siempre la salida de página?

En el pasado, he usado wcalcun pequeño programa llamado eque es prácticamente imposible buscar en Google. Ahora uso un script de Python para hacer esto, que usa algunas características ecomo los corchetes. wcalcsigue siendo bueno porque puede hacer 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 guión se haya guardado como ey puesto en algún lugar del $PATH):

$ e e**[pi*1i]
-1.0
$ e hex[10**3]
0x3e8
$ e "[0o400+3]&0xff" # need quotes because of '&'
3

Hay una forma de un solo paso para lograr exactamente lo que quieres. Todo lo que necesita hacer es configurar shellsu cuenta /bin/bc.

También puede usar printf shell incorporado para hacer cálculos aritméticos en la 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

Puede 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 por defecto.

$ 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

Crear una calculadora de terminal

Ponga lo siguiente en su archivo .bashrc

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

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

$ calc 3+45
   48

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