Alguma calculadora de linha de comando para o Ubuntu?

Estou procurando uma calculadora que possa fazer cálculos no próprio terminal sem outros prefixos e sufixos extras.

Por exemplo: Se eu digitar algo como 10000-9000 no terminal, a resposta deve sair como 1000.

Mais uma vez estou dizendo, só preciso de uma calculadora rápida no terminal, sem nenhum caractere adicionado. Eu sei que se eu mudar para Python, ele pode fazer isso, mas não o quero dessa maneira.

Aritmética do Bash

Outra solução possível é adicionar uma função simples à aritmética integrada do Bash. Coloque isso no seu .bashrcarquivo para tentar:

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

Então agora você não precisa $((...))mais, apenas o =que parece bastante natural.

Substituição

Outra coisa se você quiser ser ainda mais rápido: você pode substituí-lo ppor +e xpor *. Isso funcionará para isso:

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

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

Agora você nem precisa Shiftmais, a única coisa que está = na frente da aritmética.

Saída hexadecimal

A saída pode ser exibida em decimal e hexadecimal, se desejado. ( Nota : o uso de xsubstituição entrará em conflito com a 0x...sintaxe hexadecimal)

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

Exemplo:

$ = 16 + 0x10
272 (0x110)

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

Usando bc

Se você quiser cálculos um pouco mais avançados, você pode canalizá-lo para bcassim:

=() {
    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)

As funções fornecidas por bcsão as seguintes (e podem ser encontradas em 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.

Ele também suporta if, for, whilee variáveis como uma linguagem de programação que se pode ser melhor para escrever para um arquivo se você queria isso.

Tenha em mente que ele vai substituir pe xem função / variável nomes. Pode ser melhor apenas remover as substituições.

Usando gcalccmd

Você também pode fazer a chamada de função gcalccmd(de gnome-calculator) da seguinte maneira:

=() {
    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

As funções disponíveis parecem ser (tiradas diretamente do código fonte ), ==denotam funções 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()

Você pode fazer aritmética inteira simples de forma nativa no bash usando a ((...))sintaxe, por exemplo

$ echo $((10000-9000))
1000

Há também a bccalculadora, que pode aceitar expressões aritméticas na entrada padrão

$ echo "10000-9000" | bc
1000

O bcprograma também pode fazer aritmética de ponto flutuante

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

Você pode usar calc. Não está instalado por padrão, mas você pode instalá-lo rapidamente usando o seguinte comando:

sudo apt-get install apcalc

Após a instalação, você pode fazer qualquer cálculo que desejar:

$ 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 obter mais informações, consulte sua página de manual

Infelizmente, não há uma maneira "mais fácil" de fazer isso. A interface python interativa na linha de comando é a mais adequada para o que você precisa, porque, ao contrário de apcalc\, pythonestá incluído no Ubuntu. Não tenho certeza se bcainda está incluído, no entanto, python é o favorito direto para essas coisas.

Você pode simplesmente executar a pythoninterface interativa na linha de comando e fazer as contas dessa maneira. Você pode usar isso como sua calculadora.

Para isso, abra o terminal, digite pythone pressione o Enterbotão.

Em seguida, no prompt do python que aparece, você pode digitar sua matemática. Por exemplo 10000 - 9000,. A próxima saída de linha é o resultado.

No entanto, se você quer dizer algo em que você apenas carrega o terminal e pode fazer isso ...

US $ 10000 - 9000
1000
$

... então não há como fazer isso apenas no terminal sem mais nada, porque o Bash não lida com argumentos numéricos como esse.

Eu aconselho você a criar uma função simples para cálculos básicos em Python. Algo assim no seu .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

Se você deseja fazer cálculos mais avançados, pode usar o seguinte, que importa todas as mathfunções do módulo. (veja aqui para mais informações)

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: Como o Python é uma linguagem de programação, algumas coisas podem parecer estranhas, por exemplo, **para potências e %módulos)

Como alternativa, você pode criar um script Python calc,

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

coloque-o em um diretório incluído na PATHvariável e defina seu sinalizador executável para obter o mesmo calccomando acima (não é necessário criar uma função Bash para executar um script Python).

Se você deseja um método no Bash puro, use a resposta da chave de aço. Essa resposta só é realmente benéfica se você precisar das funções mais avançadas (ou seja, de math), pois o Python é relativamente lento comparado ao Bash.

Não tenho certeza se isso interrompe sua "mudança para python, isso pode ser feito e eu não a quero dessa maneira". observe, mas você não precisa digitar o prompt interativo e o resultado pode ser acessado no Bash, portanto esta resposta parece válida (pelo menos para mim).

Use o pacote gcalccmdfrom gnome-calculator(> = 13.04) ou gcalctool(<13.04). Eu acho que o pacote está instalado por padrão

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

Aqui está um rápido shell script para isso:

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

Salve isso como "c", coloque-o em algum lugar do seu caminho (como / bin) e marque-o como executável.

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

A partir de agora, você pode executar cálculos no terminal assim:

$ c 10000-9000
1000

Aqui está uma modificação da parte apropriada do /etc/bash.bashrc(no Ubuntu 10.04) que modificará o command_not_foundmanipulador para executar o avaliador de expressão do shell se o primeiro caractere do comando desconhecido for um número ou -ou +.

Você poderá fazer qualquer aritmética de shell dessa maneira; consulte http://www.gnu.org/software/bash/manual/bashref.html#Shell-Arithmetic para obter uma lista dos operadores aritméticos.

Observe que, se a expressão que você deseja avaliar contiver a *, será necessário citar as aspas *with \ou, pois o shell fará a expansão do nome do arquivo antes de decidir qual comando executar. O mesmo vale para outros operadores >>.

Coloque isso no seu ~/.bashrc, digite . ~/.bashrce experimente.

# 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

Exemplo de saída: (Estou digitando cta, um erro de digitação, apenas para testar se nosso novo manipulador command_not_found ainda tentará procurar comandos desconhecidos).

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

Outra solução que não vi mencionada aqui é o Qalculate (qalc) .

sudo apt-get install qalc

para a versão CLI,

sudo apt-get install qalculate-gtk

para a GUI.

Possui vários recursos, como:

• suporte para unidades : por exemplo20 m / s * 12 h = 864 kilom
• embutida constantes , tais como pi, e, c,avogadro
• muitas embutidos funções : por exemplo sin(pi) = 0, gamma(4) = 6, 5! = 120,log(1024, 2) = 10
• conversão de unidades, por exemplo:

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

• cálculo simbólico , por exemplo(x + y)^2 = x^2 + 2xy + y^2
• integração, por exemplo integrate 3*x^2 = x^3,diff sin(x), pi
• ajuda embutida, por exemplo help convert,help integrate
• conclusão da guia de comandos
• tudo é traduzido, por exemplo, meu sistema está em holandês, para que eu possa escrever ambos factorial(5)e faculteit(5).
• e mais...

Você diz que deseja usá-lo sem prefixos, bem ... você pode usá-lo com um prefixo:

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

bem como executá-lo como um substituto.

dc! Faz parte do coreutils, por isso é instalado no OS X, Ubuntu e praticamente TUDO. É uma calculadora RPN; portanto, se você não gosta, não é para você.

Comandos muito básicos são os seguintes (a página de manual tem toda a sintaxe que eu não incluí. Exponenciação, alguém?)

Você só precisa de espaços entre os números. Eles são ignorados em todos os outros casos.

Digitar um número o empurra para o topo da pilha.

+ 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

Eu uso o Octave para esse tipo de coisa: http://www.gnu.org/software/octave/

É praticamente um clone do matlab (desculpas se isso for uma simplificação excessiva) que pode ser usado no terminal digitando oitava. Instale o sudo apt-get install oitava

Não é exatamente o que você quer, mas pensei em adicioná-lo como uma alternativa ao python.

Exemplo de uso:

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

Eu gosto muito do wcalc. É uma calculadora científica de linha de comando. Fácil de encontrar no Ubuntu Software Center, ou apenas use o apt-get.

sudo apt-get install wcalc

Ele aceita argumentos de linha de comando e possui o 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

E se alguém estiver em engenharia, como eu, você poderá usar o GNU Octave. Ele pode fazer todo tipo de coisa, fazer gráficos, resolver equações simultâneas. Além disso, é uma alternativa gratuita ao Matlab

maneira simples é chamar python.

Exemplo:

>  python -c 'print 10000-9000'

O que eu descobri é que não posso confiar nas opções expr, bc ou Shell incorporadas. Por isso, usei o Perl, que normalmente seria instalado nos distros * linux

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

O cálculo acima subtrairá $ VAL1 de $ VAL2 e será impresso sem casas decimais (0f)

O benefício de usar o Perl é (detalhes de prós e contras listados aqui )

• Melhor captura de erro (dividir por 0 não interrompe o cálculo)
• Pode fornecer fórmulas em um arquivo de configuração. Não há necessidade de escapar usando regex complexo

Você pode adicionar a seguinte função ao seu arquivo .bashrc:

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

Observe que a -lbandeira é muito importante. Sem ele, o uso de bcdá 5 / 2 = 2.

Como foi mencionado acima, os cálculos podem ser feitos usando o =sinal na frente da fórmula.

Você também pode usar o awk para fazer alguns cálculos aritméticos no 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 o comando "bc" e então você pode fazer o cálculo

exemplo

[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 bcsem a nota de garantia, escreva no terminalbc -q

exemplo

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

Você pode usar bind e bash C-ae C-epara controlar a saída. Por exemplo, execute isso no seu shell:

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

Agora digite qualquer operação aritmética como 10 + 15 e pressione Ctrl+ J:

$ echo $(( 10 + 15 )) 
25

Você vai conseguir isso. Agora, como é feito?

• bind este comando altera a ligação do seu bash, como teclas de atalho.
• \C-j este é o equivalente do bash a Ctrl + J; é a combinação de teclas que gostaríamos de adicionar ao nosso comando.
• \C-a isso nos leva ao início da linha.
• echo $((isso escreve echo $((no início.
• \C-e nos leva até o fim da linha
• )) fecha nosso parêntese anterior
• \C-m isso é equivalente a retornar a chave.

Você pode escrever isso em seu ~/.inputrcarquivo:

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

Obviamente, as outras respostas também são válidas! Apenas alterei um pouco:

• bc: "\C-j": "\C-aecho " \C-e " | bc \C-m"
• apcalc: "\C-j": "\C-acacl \C-m"
• Pitão: "\C-j": "\C-apython3 -c "print( \C-e )" \C-m"
• mais algum?

Você pode alterar Ctrl + J para o que quiser, mas lembre-se, tente não alterá-lo para algo que já tenha uma ligação;).

Recurso:

• Existe uma maneira de configurar o bash para sempre imprimir a página?

No passado, eu usei wcalce um pequeno programa chamado eque é praticamente impossível pesquisar no Google. Agora eu uso um script python para fazer isso, que usa alguns recursos ecomo colchetes. wcalcainda é bom porque pode fazer precisão arbitrária e conversão de unidades, mas quase nunca uso esses recursos.

#!/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(")", "]"))

Veja como usá-lo (supondo que o script tenha sido salvo ee colocado em algum lugar no $PATH):

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

Existe uma maneira de realizar exatamente o que você deseja. Tudo o que você precisa fazer é definir shellpara a sua conta /bin/bc.

Você também pode usar o printf shell interno para fazer cálculos aritméticos no terminal.

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

Exemplo:

$ printf "$(expr 10000 + 9000)\n"
19000
$ printf "$(expr 10000 - 9000)\n"
1000

Você pode usar o interpretador python para cálculo. Aqui está um tutorial sobre como fazer isso .

Python 2 e python 3 são instalados no Ubuntu por padrão.

$ 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

Criar uma calculadora de terminal

Coloque o seguinte no seu arquivo .bashrc

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

Ou execute-o no prompt do shell. Agora "calc" do shell funcionará da seguinte maneira:

$ calc 3+45
   48

Todas as funções com "(" ou ")" devem estar entre aspas.