☰

Como fazer cálculos inteiros e flutuantes, em bash ou outras linguagens/frameworks?

tag-icon • tag-icon shell command-line arithmetic floating-point calculator
Como fazer cálculos inteiros e flutuantes, em bash ou outras linguagens/frameworks?

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

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

Além disso, qual é a maneira mais fácil de fazer isso usando bash como 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 idiomas disponíveis na linha de comando.

Responder1

São muitas opções!!!

Resumo

$ printf %.10f\\n "$((10**9 * 20/7))e-9"   # many shells. Not mksh.
$ echo "$((20.0/7))"                       # (ksh93/zsh/yash, some 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
$ gs -q  <<< "5 2 div 20 add  ="

Detalhes

Cartuchos

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

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

Bastante portátil (ash dash yash bash ksh93 lksh zsh):
Usando a habilidade printf para imprimir floats, 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,yashezshapoie flutuadores aqui:

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

apenasksh93(diretamente) ezshcarregando 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 (somente número inteiro):

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

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

; echo $:25/3
8

Caixa de ferramentas POSIX

bc(veja abaixo o modo interativo),manual aqui

Mnemônico: best calculator (embora bseja de fato parabá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

Correra solução,expr(sem modo interativo):

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

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

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

Outras ferramentas mais ou menos portáteis

Arcegéa solução,dc(modo interativo dc:):

O que é ainda mais divertido, pois funciona com notação de polimento reverso.

$ 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 notação de polimento reverso.

Observe que dcé anterior bce bcfoi historicamente implementado como um wrapper, dcmas dcnão foi padronizado pelo POSIX

DQ diminuidecalc(obrigatório sudo apt-get install apcalc):

$ calc 2 + 4
6

Intérpretes de idiomas de uso geral:

homem a trabalhara solução,node(modo interativo:; nodefunçã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

Pitão(modo interativo:; pythonfunçã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ê temclispinstalado, você também pode usar a notação polonesa:

$ clisp -x "(+ 2 2)"

Marcoa solução,lua(modo interativo lua:):

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

PHP(modo interativo php -a:):

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

Rubi(modo interativo:; irbfunção de saída não necessária):

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

Astúcia(modo interativo guile:):

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

Gíria(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

JavaScriptcartuchos:

$ 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 SQLs:

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 do mysql e postgres param a imagem 'ascii art'!

Linguagens especializadas orientadas para a matemática:

Rno 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

Rusando omenorscript - vamos 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

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

Opção não interativa:

$ julia -E '2.5+3.7'
6.2

GhostScript GhostScript é um interpretador PostScript, muito comumente instalado mesmo em distribuições muito antigas.
VerDocumentos PostScriptpara obter uma lista de comandos matemáticos suportados.

Exemplo interativo:

$ GS_DEVICE=display gs
GPL Ghostscript 9.07 (2013-02-14)
Copyright (C) 2012 Artifex Software, Inc.  All rights reserved.
This software comes with NO WARRANTY: see the file PUBLIC for details.
GS>5 2 div 20 add  =
22.5
GS>

Responder2

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

echo $((20+5))

ou expr:

expr 20 + 5

E para casos complexos existe uma ótima ferramenta bc:

echo "20+5" | bc

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

Responder3

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 a ~/.bashrc (ou ao arquivo de inicialização do seu shell correspondente)

Claro, um pequeno script chamado “calc” com o seguinte conteúdo:

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

também poderia funcionar.

Responder4

Você pode usar calc:

Se você entrar calcsem outros argumentos, ele entrará em um modo interativo onde você poderá continuar fazendo contas. Você sai 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ê o usa com a expressão como argumento e ele fornecerá a resposta e então sairá

$calc 2 + 4
    6
$

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

informação relacionada