Qualquer calculadora de linha de comando para o Ubuntu?

118

Estou procurando uma Calculadora que possa fazer cálculos no terminal sem outros prefixos e sufixos extras.

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

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

    
por rɑːdʒɑ 18.11.2013 / 03:37
fonte

23 respostas

74

Aritmética Bash

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

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

Então, agora, você nem precisa mais de $((...)) , apenas = , o que parece natural o suficiente.

Substituição

Outra coisa, se você quiser ser ainda mais rápido: pode substituir p por + e x por * . 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 mais de Shift , a única coisa é na frente da aritmética.

Saída hexadecimal

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

=() {
    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, pode canalizá-lo para bc da seguinte forma:

=() {
    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 bc sã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 , while e variáveis como uma linguagem de programação, embora seja melhor escrever em um arquivo se você quiser.

Lembre-se de que substituirá p e x em nomes de função / variável. Pode ser melhor apenas remover as substituições.

Usando gcalccmd

Você também pode fazer a função chamar gcalccmd (de gnome-calculator ) assim:

=() {
    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 ), == indica 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()
    
por kiri 19.11.2013 / 10:33
fonte
89

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

$ echo $((10000-9000))
1000

Existe também a calculadora bc , que pode aceitar expressões aritméticas na entrada padrão

$ echo "10000-9000" | bc
1000

O programa bc também pode fazer aritmética de ponto flutuante

$ echo "scale = 3; 0.1-0.09" | bc
.01
    
por steeldriver 18.11.2013 / 03:59
fonte
88

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

Depois de ter instalado, você pode fazer qualquer cálculo:

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

    
por Radu Rădeanu 18.11.2013 / 10:16
fonte
30

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

Você pode simplesmente executar a interface interativa python na linha de comando e fazer a matemática dessa maneira. Você pode usar isso como sua calculadora.

Para fazer isso, abra o terminal, digite python e, em seguida, pressione o botão Enter .

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

Se você quer dizer, no entanto, algo em que você acabou de carregar o terminal e pode fazer isso ...

$ 10000 - 9000
1000
$

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

    
por Thomas Ward 18.11.2013 / 03:40
fonte
23

Eu aconselho você a criar uma função simples para cálculos básicos do Python. Algo parecido com isto 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ê quiser fazer uma matemática mais avançada, você pode usar a seguinte, que importa todas as funções do módulo math . (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 Python é uma linguagem de programação, algumas coisas podem parecer estranhas, por exemplo, ** para powers de e % para modulo)

Como alternativa, você pode criar um script em 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 variável PATH e defina seu sinalizador de executável para obter o mesmo comando calc como acima (não é necessário criar uma função Bash para executar um script Python).

Se você quiser um método no Bash puro, use a resposta do steeldriver. Essa resposta só é realmente vantajosa se você precisar das funções mais avançadas (por exemplo, de math ), pois o Python é relativamente lento em comparação ao Bash.

Não sei se isso quebra o seu "switch para python, isso pode ser feito e eu não o quero de tal forma." note, mas você não precisa digitar o prompt interativo e o resultado é acessível no Bash, então essa resposta parece válida (para mim, pelo menos).

    
por kiri 18.11.2013 / 09:45
fonte
21

Use o pacote gcalccmd de gnome-calculator (> = 13.04) ou gcalctool (< 13.04). Eu acho que o pacote é instalado por padrão

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

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

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

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

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

De agora em diante, você pode executar cálculos no terminal da seguinte forma:

$ c 10000-9000
1000
    
por user530873 18.11.2013 / 06:19
fonte
8

Aqui está uma modificação da parte apropriada de /etc/bash.bashrc (no Ubuntu 10.04) que modificará o manipulador command_not_found 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 link para obter uma lista de operadores aritméticos.

Observe que, se a expressão que você deseja avaliar contiver um * , você deverá citar as * com \ ou aspas, já que o shell executará a expansão do nome do arquivo antes de decidir qual comando será executado. Mesma coisa para outros operadores como >> .

Coloque isso no seu ~/.bashrc , digite . ~/.bashrc e 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 o nosso novo manipulador command_not_found ainda tentará procurar por 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
    
por Mark Plotnick 18.11.2013 / 18:05
fonte
8

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

sudo apt-get install qalc

para a versão CLI,

sudo apt-get install qalculate-gtk

para a GUI.

Tem vários recursos, como:

  • suporte para unidades : por exemplo %código%
  • constantes incorporadas , como 20 m / s * 12 h = 864 kilom , pi , e , c
  • muitas funções incorporadas : por ex. avogadro , sin(pi) = 0 , gamma(4) = 6 , 5! = 120
  • conversão de unidade, por exemplo:
% bl0ck_qu0te%
  • cálculo simbólico , por ex. %código%
  • integração, por exemplo log(1024, 2) = 10 , (x + y)^2 = x^2 + 2xy + y^2
  • ajuda integrada, por exemplo integrate 3*x^2 = x^3 , diff sin(x), pi
  • conclusão de comandos
  • tudo é traduzido, por exemplo meu sistema está em holandês, então posso escrever help convert e help integrate .
  • e muito mais ...

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

factorial(5)

bem como executá-lo como uma replicação.

    
por JW. 26.11.2013 / 11:46
fonte
7

dc ! É parte do coreutils, então é instalado no OS X, Ubuntu e praticamente tudo mais. É uma calculadora de RPN, então se você não gosta disso, não é para você.

Os comandos

Muito básico são os seguintes (a manpage 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 coloca no 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
    
por Yet Another User 18.11.2013 / 21:07
fonte
5

Eu uso o Octave para esse tipo de coisa: link

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

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

Exemplo de uso:

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

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

Aceita argumentos de linha de comando, assim como 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 está em engenharia, como eu, você poderia fazer uso do GNU Octave. Ele pode fazer todo tipo de coisa, representar graficamente, resolver equações simultâneas. Além disso, é uma alternativa gratuita ao Matlab

    
por Sergiy Kolodyazhnyy 22.09.2014 / 11:58
fonte
4

maneira simples é chamar python.

Exemplo:

>  python -c 'print 10000-9000'
    
por user2327875 20.11.2013 / 14:35
fonte
3

O que eu descobri é que não posso confiar nas opções expr, bc ou embutidas do Shell. Por isso eu usei o Perl que normalmente seria instalado no * linux distro's

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

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

Beneficie com o uso do Perl (detalhes de Prós e contras listados aqui )

  • Melhor captura de erros (dividir por 0 não parará o cálculo)
  • Pode fornecer fórmulas em um arquivo de configuração. Não há necessidade de escapar usando regex complexo
por diaryfolio 18.11.2013 / 11:14
fonte
3

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

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

Note que -l flag é muito importante. Sem isso, o uso de bc5 / 2 = 2 .

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

    
por vdm 19.11.2013 / 14:51
fonte
3

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
    
por Avinash Raj 05.01.2014 / 19:41
fonte
2

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 bc sem a nota de garantia, escreva no terminal bc -q

exemplo

[root@vaibhav ~]# bc -q
10+2
12
    
por Vaibhav Jain 19.11.2013 / 08:18
fonte
2

Você pode usar bind e bash C-a e C-e para 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 isso é feito?

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

Você pode escrever isso no seu arquivo ~/.inputrc :

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

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

  • 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"
  • algum outro?

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

Recurso:

por Braiam 20.11.2013 / 01:55
fonte
2

No passado, eu usei wcalc e um pequeno programa chamado e que é praticamente impossível google para. Agora eu uso um script python para fazer isso, que usa alguns recursos de e , como os colchetes. wcalc ainda é legal porque pode fazer precisão arbitrária e conversão de unidade, 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 (assumindo que o script foi salvo como e e 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
    
por jpkotta 18.11.2013 / 17:20
fonte
0

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

    
por bizzyunderscore 21.11.2013 / 02:29
fonte
0

Você também pode usar printf shell builtin 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
    
por Avinash Raj 16.04.2014 / 15:26
fonte
0

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

O Python 2 e o 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
    
por noone 27.08.2017 / 12:08
fonte
0

Crie 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 um "(" ou ")" devem ser incluídas   entre aspas.

    
por Vishnu N K 31.01.2014 / 18:17
fonte