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


294

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.


1
Se você continuar bc, pode valer a pena ler sobre a -lopção na página de manual.
glenn jackman

Presumo que o autor esteja solicitando a linha de comando do bash, enquanto todas as respostas tendem a se diversificar para todos os tipos de linguagens de script.
zinking

2
man bash → / expressão
ДМИТРИЙ МАЛИКОВ

1
@zinking Bem, o bash foi projetado para ser capaz de chamar facilmente os intérpretes para um grande número de outras linguagens de script.
Random832

Ensinar divisão de números inteiros bash com resultados de ponto flutuante: stackoverflow.com/a/24431665/3776858
Cyrus

Respostas:


399

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

3
e bc é interessante: whatis bc-> An arbitrary precision calculator language Interessante! Obrigado!
Michael Durrant

@MichaelDurrant você poderia revisar novamente suas edições? Devo ter rejeitado por engano?
Lgarzo

4
Há também dc, o que é ainda mais divertido, pois funciona por notação de polimento reverso. echo 20 5 + p | dc Mas não é tão prático, a menos que você trabalhe muito com a notação de polimento reverso.
Arcege

2
Como variação da abordagem bc, adicionei a seguinte função (encontrada em stackexchange algures) ao meu arquivo .bashrc. Eu posso simplesmente digitar calc 2 + 3 e obter 5. # ## Command line calculator calc () { bc -l <<< "[email protected]" }
186 Joe

1
@ Chris, o peixe é um alvo em movimento. Eles estão trabalhando em seu novo mathprédio (ou como é chamado agora) enquanto falamos. Sinta-se livre para editar. Não é minha resposta e é um wiki da comunidade.
Stéphane Chazelas

35

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.


Eu adicionei sua expropção à resposta aceita. Tinha que escolher um para aceitar e centralizar.
precisa

3
Você está tentando executar expr 20+5. Você precisa digitar espaços entre os números e mais para fazer o trabalho: expr 20 + 5. Isso é importante.
corrida

24

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

2
bcO resultado de não é inteiro, apenas arredondado para scale, cujo valor padrão é 0. Portanto, bc <<< 'scale=4;9.0/2.0'se você deseja a parte fracionária.
manatwork

Obrigado pela correção. Mas ainda assim, é propenso a erros. Lembrarei de adicionar scalese usar bcem algumas semanas? Provavelmente não. E mesmo que haja uma maneira de alterá-lo permanentemente, ele o morderá se você estiver em um sistema com as configurações padrão.
Marco

3
Pessoalmente, lembro-me scaledesde que conheci a bcprimeira vez anos atrás. Mas eu sempre esqueci se a função de saída luaé putou nãoputs . ;)
manatwork

Apenas conte bc como uma das linguagens de script. Eu sempre sei se preciso de resultados inteiros ou não - se o número inteiro estiver bom, fico no bash, caso contrário, raramente tenho motivos para usar o bc. Para lua, você deve se lembrar de -e, print e parênteses.
usuário desconhecido

7
Sempre use sempre, em bc -lvez de simplesmente bc, e nunca se preocupe scale.
Dalker

23

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.


2
Uau, isso é o melhor, suporta até carros alegóricos. Funciona sem instalar nada!
precisa saber é o seguinte

1
Muito bom, eu queria ter uma comparação flutuante, aqui está como eu fiz isso com a sua ajuda:a=0; b=0.0; if echo "$a" "$b" | awk '{ exit ($1 == $2) ? 0 : 1 }'; then echo 'equals'; else echo 'not equals'; fi
Paul Tobias

18

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


1
+1 nas opções de canal ("|") e modo interativo para bs. Alguém ctrl-dsai?
precisa

1
@MichaelDurrant Sim, ^ D irá fazer o truque tão vontadequit
Levon

c () { bc -l <<< "[email protected]" } definirá uma função c para uso rápido e fácil. por exemplo c 3/2, lhe dará 1.50000000000000000000. O link acima descreve como fazer isso está inoperante.
ijoseph

1
@Levon o link da página de manual ainda funciona. No entanto, o link: paweng.com/2008/08/15/unix-command-line-calculator , que você fornece como destino de "This" na frase "Esta página também mostra como configurar um alias ..." aparece morto.
ijoseph

1
@ijoseph Thanks .. Tirei a referência a esse elo de 6 anos (desejo as ligações destacou-se mais claramente no meu navegador - nem sequer vê-lo quando eu olhei ontem)
Levon

16

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


1
Você não precisa entrar no modo interativo, a menos que deseje particularmente, por exemplo: calc -e '2+4; 3+5; 3.4+5; 2^4imprime 4 linhas de saída ou apenas calc -e 33+(3^3).. +1 Eu gosto da idéia de usar algo chamado 'calc' para uma calculadora :)
Peter.O

1
Eu só percebi que a -eopção não é necessária quando há apenas uma expressão ... puro ..!
Peter.O

10

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


eu também! Python é o meu canivete suíço
Levon

Eu sempre tenho uma janela screenapenas executando o Python.
Arcege

1
pythonpy ( github.com/russell91/pythonpy ) é uma boa maneira de fazer isso e outras coisas na sintaxe python sem precisar ativar um shell interativo: py '3.2 * 5' => 16
RussellStewart

Eu gosto de python, mas é tempo de arranque torna-se importante se você quiser apenas adicionar dois números em alguns lugares do seu script bash
ndemou

@ndemou eu disse calculadora "interativa". Embora também seja interessante notar que, em algum momento, se você estiver fazendo coisas complexas o suficiente em um script, a sanidade dita que você use algo diferente de bash (como Python).
asmeurer

10

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

Existem tantas opções que não exigem a instalação de um programa extra que não vejo por que alguém iria querer seguir esse caminho.
Ndemou

@ndemou Ele é instalado por padrão em algumas distribuições ... e muitas dessas outras respostas não são. E você realmente precisava comentar isso em uma resposta de cinco anos?
precisa saber é o seguinte

1
Eu acho que é bom comentar quando faço uma votação baixa e é uma prática que também é incentivada pela SE. Não vejo por que cinco anos são relevantes. O mesmo comentário se aplica a todas as respostas semelhantes - nada pessoal. (Aliás, mesmo o programa mais obscura pode ser ser instalado por padrão em alguns de distribuição Neste caso eu testei instalações recentes do Debian, Ubuntu, CentOS e RedHat e unidades é não.)
ndemou

6
$> 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

3
Isso ghcsignifica Glasgow Haskell Compiler?
manatwork

tendo um passe em programas que eu preciso instalar, mas thx.
Michael Durrant

4

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.


4

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.


não print(eval(' '.join(sys.argv[1:])))faria a mesma coisa?
g.rocket

Você está usando um martelo para bater uma mosca aqui
ndemou

4

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

4

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 1 e o fish 2 ).

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

awkusará o doubletipo de ponto flutuante do seu sistema , portanto, será tão preciso quanto a maioria das outras ferramentas que não fazem precisão arbitrária (observe que o gawk pode fazer precisão arbitrária). awkusa a OFMTvariável para converter o número em sua representação de seqüência de caracteres para saída ( %.6gpor padrão, convém alterar isso para que %.17gvocê queira maior precisão ).
Stéphane Chazelas

Note-se que fish's mathé apenas uma função que chama bc(embora isso é para mudar )
Stéphane Chazelas

1
Bem, foi uma função que chama bc. Já não está nas versões mais recentes, onde coisas como math "scale=4; 10/3"não funcionam mais ( math -s4 10/3agora)
Stéphane Chazelas

Graças Stéphane Chazelas - Eu atualizei a minha resposta ( math -s4parece ser suportado em versões mais antigas também)
ndemou

3

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.


3

SQLite :

echo 'select 1 + 1;' | sqlite3 

MySQL :

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

PostgreSQL :

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

3
Alguns detalhes menores que vale a pena mencionar: 1) from dualsão necessários pelo Oracle, o MySQL é capaz selectsem fromcláusula. 2) O PostgreSQL não requer o alias. 3) Isso ;é requerido apenas pelo SQLite. 4) O MySQL e o PostgreSQL funcionarão apenas se puderem se conectar a um servidor de banco de dados. 5) MySQL e PostgreSQL desenharão a tabela ASCII-art em torno dos resultados. Para obter apenas o valor: mysql -BNe 'select 1+1'e psql -tAc 'select 1+1.
manatwork

2

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.

Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.