Como fazer cálculos de números inteiros e flutuantes, no bash ou em outros idiomas / estruturas?

Usar echo "20+5"literalmente produz o texto " 20+5".

Que comando posso usar para obter a soma numérica, 25neste caso?

Além disso, qual é a maneira mais fácil de fazer isso usando o bash para ponto flutuante? Por exemplo, echo $((3224/3807.0))imprime 0:(.

Estou procurando respostas usando o próprio shell de comando básico ('linha de comando') ou usando os idiomas disponíveis na linha de comando.

Existem muitas opções !!!

Sumário

$ 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

Detalhes

Cartuchos

Você pode usar a expansão aritmética POSIX para aritmética inteiraecho "$((...))" :

$ echo "$((20+5))"
25
$ echo "$((20+5/2))"
22

Bastante portátil ( ash dash yash bash ksh93 lksh zsh):
Usando a capacidade printf para imprimir carros alegóricos, podemos estender a maioria dos shells para fazer matemática de ponto flutuante, embora com um intervalo limitado (não mais que 10 dígitos):

$ printf %.10f\\n "$((1000000000 *   20/7  ))e-9"
2.8571428570

ksh93, yashe zshsuporta flutuadores aqui:

$ echo "$((1.2 / 3))"
0.4

somente ksh93(diretamente) e zshcarregando a biblioteca mathfunc aqui:

$ echo "$((4*atan(1)))"
3.14159265358979324

( zshprecisa carregar zmodload zsh/mathfuncpara obter funções como atan).

Interativamente com zsh:

$ autoload zcalc
$ zcalc
1> PI/2
1.5708
2> cos($1)
6.12323e-17
3> :sci 12
6.12323399574e-17

Com (t) csh (apenas número inteiro):

% @ a=25 / 3; echo $a
8

Na rcfamília shell, akangaé aquele com expansão aritmética:

; echo $:25/3
8

Ferramentas POSIX

bc(veja abaixo o modo interativo), manual aqui

Mnemonic: best calculator (embora o bé de fato para básico ).

$ echo 20+5/2 | bc
22
$ echo 'scale=4;20+5/2' | bc
22.5000

(suporta números de precisão arbitrários)

modo interativo 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

Solução do Rush , expr(sem modo interativo):

$ expr 20 + 5
25
$ expr 20 + 5 / 2
22

Solução de Josué : awk(sem modo interativo):

$ calc() { awk "BEGIN{print $*}"; }
$ calc 1/3
0.333333

Outras ferramentas mais ou menos portáteis

A solução da Arcegedc (modo interativo :)dc :

O que é ainda mais divertido, pois funciona com notação polonesa reversa.

$ echo 20 5 2 / + p | dc 
22
$ echo 4 k 20 5 2 / + p | dc 
22.5000

Mas não é tão prático, a menos que você trabalhe muito com a notação de polimento reverso.

^{Observe que dcé anterior bce bcfoi historicamente implementado como um invólucro, dcmas dcnão foi padronizado pelo POSIX}

DQdims ' calc(obrigatório sudo apt-get install apcalc):

$ calc 2 + 4
6

Intérpretes de linguagem de uso geral:

solução do manatwork , node(modo interativo :;node função de saída não necessária):

$ node -pe 20+5/2  # Uses the power of JavaScript, e.g. : node -pe 20+5/Math.PI
22.5

Perl (modo interativo:) perl -de 1:

$ perl -E "say 20+5/2"
22.5

Python (modo interativo python:; função de saída não necessária):

$ python -c "print(20+5/2)"
22 # 22.5 with python3
$ python -c "print(20+5/2.0)"
22.5

Também suporta números de precisão arbitrários:

$ python -c 'print(2**1234)'
295811224608098629060044695716103590786339687135372992239556207050657350796238924261053837248378050186443647759070955993120820899330381760937027212482840944941362110665443775183495726811929203861182015218323892077355983393191208928867652655993602487903113708549402668624521100611794270340232766099317098048887493809023127398253860618772619035009883272941129544640111837184

Se você clispinstalou, também pode usar a notação de polonês:

$ clisp -x "(+ 2 2)"

A solução de Marcolua (modo interativo:) lua:

$ lua -e "print(20+5/2)"
22.5

PHP (modo interativo:) php -a:

$ php -r 'echo 20+5/2;'
22.5

Ruby (modo interativo irb:; função de saída não necessária):

$ ruby -e 'p 20+5/2'
22
$ ruby -e 'p 20+5/2.0'
22.5

Guile (modo interativo:) guile:

$ guile -c '(display (+ 20 (/ 5 2)))'
45/2
$ guile -c '(display (+ 20 (/ 5 2.0)))'
22.5

S-Lang (modo interativo slsh:; função de saída não necessária, apenas um ;terminador):

$ slsh -e 'printf("%f",20+5/2)'
22.000000
$ slsh -e 'printf("%f",20+5/2.0)'
22.500000

Tcl (modo interativo tclsh:; função de saída não é necessária, mas expré):

$ tclsh <<< 'puts [expr 20+5/2]'
22
$ tclsh <<< 'puts [expr 20+5/2.0]'
22.5

Cascas 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
>

Vários SQL's:

SQLite (modo interativo:) 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

_As opções no mysql e no postgres interrompem a imagem 'ascii art'!

Linguagens especializadas em matemática:

R no modo simples - vamos gerar 1000 números aleatórios normais, obter o desvio padrão e imprimi-lo

$ R -q -e 'print(sd(rnorm(1000)))'
> print(sd(rnorm(1000)))
[1] 1.031997

R usando o script littler - permite imprimir pi ao quadrado

$ r -e 'cat(pi^2, "\n")'
9.869604
$  r -e 'print(sum(1:100))'
[1] 5050

PARI / GP , um extenso sistema de álgebra computacional para teoria dos números, álgebra linear e muitas outras coisas

$ 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

Oitava GNU (uma linguagem interpretada de alto nível, destinada principalmente a cálculos numéricos)

Também suporta números complexos:

$ octave
>> 1.2 / 7
ans =  0.17143
>> sqrt(-1)
ans =  0 + 1i

Julia , linguagem de alto desempenho e intérprete para computação científica e numérica.

Opção não interativa:

$ julia -E '2.5+3.7'
6.2

Existem muitas maneiras de calcular. Para expressões simples, você pode usar- bashse:

echo $((20+5))

ou expr:

expr 20 + 5

E para casos complexos, há uma ótima ferramenta bc:

echo "20+5" | bc

Btw, bc pode calcular até expressões muito complexas com raízes, logaritmos, cos, sin e assim por diante.

As soluções mencionadas são adequadas para cálculos muito simples, mas muito propensas a erros. Exemplos:

# 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

Um erro de sintaxe como os últimos é facilmente percebido, mas respostas inteiras com uma parte flutuante descartada podem facilmente passar despercebidas e levar a resultados incorretos.

É por isso que eu sempre uso uma linguagem de script como Lua para isso. Mas você pode escolher qualquer linguagem de script familiar. Eu apenas uso Lua como exemplo. As vantagens são

• uma sintaxe familiar
• funções familiares
• advertências familiares
• entrada flexível
• espaços geralmente não importam
• saída de ponto flutuante

Exemplos:

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

Ninguém mencionou awk ainda?

Usando funções shell POSIX e awk math power, basta definir esta função (uma linha):

calc(){ awk "BEGIN { print $*}"; }

Em seguida, basta executar coisas como calc 1+1oucalc 5/2

Nota: Para tornar a função sempre disponível, adicione-a em ~ / .bashrc (ou no arquivo de inicialização do seu shell correspondente)

Obviamente, um pequeno script chamado "calc" com o seguinte conteúdo:

#!/bin/sh -
awk "BEGIN { print $* }"

também poderia funcionar.

Você poderia usar bc. Por exemplo,

$ echo "25 + 5" | bc
30

Alternativamente bc <<< 25+5, também funcionará.

Ou interativamente, se você quiser fazer mais do que apenas um único cálculo simples:

$ 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

A implementação GNU de bcimprime essas informações de cabeçalho / direitos autorais na inicialização quando stdin e stdout vão para um terminal. Você pode suprimi-lo com a opção (específica ao GNU) -q. Para mais informações, consulte a página de manual bc

Você pode usar calc :

Se você simplesmente entrar calcsem outros argumentos, ele entra em um modo interativo, onde você pode continuar fazendo contas. Você sai dessa digitando 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

Ou você a usa com a expressão como argumento e ela fornecerá a resposta e sairá

$calc 2 + 4
    6
$

calcé semelhante a bc, eu apenas gosto da maneira como ele se comporta como padrão melhor

Eu gosto de iniciar o Python e usá-lo como uma calculadora interativa (mas, novamente, sou um programador de Python).

Como ninguém mais o mencionou, e embora não seja estritamente uma calculadora (mas nem todas essas linguagens de script de uso geral), eu gostaria de mencionar units:

$ units "1 + 1"
        Definition: 2
$ units "1 lb" "kg"
        * 0.45359237
         / 2.2046226

Ou, para menos saída, você pode obter apenas o número para usar $()e atribuir a algo:

$ units -t "1 + 1"
2
$ units -t "1 lb" "kg"
0.4539237

E até faz conversões de temperatura

$ units -t "tempC(20)" "tempF"
68

Para obter a conversão de temperatura em uma expressão para cálculo adicional, faça o seguinte:

$ units -t "~tempF(tempC(20))+1"
68.1

$> ghc -e '20 + 5'
25
it :: Integer

Além disso ghci, esse é o compilador Glasgow-Haskell no modo interativo ( ghc --interactiveao contrário de avaliar uma expressão com -e), cria uma "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

Não posso acreditar em ler "o poder do JavaScript" (mas tive que aprovar a resposta para as outras partes, exceto o perl, é claro).

Na prática, nos casos simples em que a aritmética inteira é suficiente, eu uso o buildin $ ((...)) e o recomendo. Senão, em quase todos os casos ecoam "..." | bc é suficiente.

Para algumas operações aritméticas, como estatísticas, operações de matriz e mais, Ré a melhor ferramenta:

echo 25 + 5 | R --vanilla

e para pequenos conjuntos de dados e resultados gráficos de descarte, oocalcé um bom utilitário.

Eu uso um pequeno script python que avaliará uma expressão python e imprimirá o resultado, para que eu possa executar algo como

$ pc '[i ** 2 for i in range(10)]'
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

o script é:

#!/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')

Infelizmente, não me lembro de onde peguei emprestado a maior parte do código, então não posso citá-lo.

Gnuplot

gnuplot - um programa de plotagem interativo
Siga o link acima ou digite ognuplotformulário no prompt e depoishelpdentro dointerpretador gnuplot .
O Gnuplot é um programa criado para plotar dados, mas também pode ser usado para o cálculo. Oferece a vantagem de poder definir funções e / ou usar as incorporadas.

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

Raiz (ou algum outro intérprete C )

O sistema ROOT fornece um conjunto de estruturas OO com toda a funcionalidade necessária para manipular e analisar grandes quantidades de dados de uma maneira muito eficiente ...

Você pode usá-lo como intérprete C , CINT , ou pode usar um dos muitos outros intérpretes C . IMHO, é enorme, complexo, poderoso e nem sempre amigável, mas também pode dar uma grande satisfação.

Se você realmente não quer ouvir a vozinha dentro de você que cita Confúcio e está pronto para quebrar uma mosca (manteiga) na roda, você pode usar a raiz . Nesse caso, -lé obrigatório evitar mostrar a tela inicial ...

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

Para aritmética de número inteiro (onde 3/2 = 1)

• bash echo $(( 1+1 ))
• fish math 1+1
• zsh* echo $((1+1))

*: e ksh93, yash

Para aritmética de ponto flutuante (onde 3/2 = 1,5)

• bash awk "BEGIN {print 10/3}" (baixa precisão)
• bash echo "10/3"|bc -l (alta precisão)
• fish math -s4 10/3
• zsh* echo $((10./3))

*: e ksh93, yash

Obviamente, você pode configurar seu shell para usar o awk com o mínimo de digitação calc 10/3(consulte as notas sobre como fazê-lo para o bash ¹ e o fish ² ).

A principal razão para sugerir o awk para o bash é que ele é pré-instalado em quase todos os sistemas operacionais semelhantes ao Unix e é razoavelmente leve (é claro que existe o custo de iniciar um processo) com uma saída menos precisa, mas mais amigável ao homem do bc -lque imprime 20 decimais dígitos (embora você certamente possa ajustar o awk para obter mais dígitos decimais ).

Notas

(1) Como usar a sintaxe simplificada no bash

Adicione esta função bash ao seu ~/.bashrc:

calc(){ awk "BEGIN { print $*}"; }

(2) Como usar a sintaxe simplificada em peixes

Crie uma calcfunção de peixe (ou seja, um arquivo de texto chamado /home/ndemou/.config/fish/functions/calc.fish):

function calc
    awk "BEGIN{ print $argv }" ;
end

Para cálculos de console, eu uso concalc. ( sudo aptitude install concalc)

Depois disso, basta digitar concalc e pressionar enter. Ele não fornecerá um prompt, mas apenas digite seu cálculo (sem espaços) e pressione enter e, na próxima linha, fornecerá o valor numérico.

SQLite :

echo 'select 1 + 1;' | sqlite3 

MySQL :

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

PostgreSQL :

psql -c 'select 1 + 1 as sum;'

Use a Biblioteca Aritmética de Precisão Múltipla GNU através do run-exprprograma fornecido :

• Faça o download e extraia (você precisará do lzip): tar -xvf gmp-5.1.3.tar.lz
• No diretório superior ./configuree make(não é necessário instalar)
• Em demos / expr, make run-expr
• Eu gosto de criar um link simbólico para ele no meu ~/bindiretório:ln -s /path/to/gmp/demos/expr/run-expr ~/bin/run-expr
• Adicione um alias para facilitar o uso; por exemplo, alias calcf='run-expr -f'para avaliação de ponto flutuante

Resultado:

# calcf '2/3'
"2/3" base 0: result 0.666666666666666666667e0

Do run-expr.carquivo:

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 o manual para obter diferenças e detalhes das classes de funções.