Come eseguire calcoli interi e float, in bash o altre lingue / framework?


294

L'uso echo "20+5"letterale produce il testo " 20+5".

Quale comando posso usare per ottenere la somma numerica, 25in questo caso?

Inoltre, qual è il modo più semplice per farlo semplicemente usando bash per virgola mobile? Ad esempio, echo $((3224/3807.0))stampa 0:(.

Sto cercando risposte utilizzando la shell dei comandi di base ('riga di comando') stessa o usando le lingue disponibili dalla riga di comando.


1
Se stai andando bc, potrebbe valere la pena leggere -lsull'opzione nella pagina man.
Glenn Jackman,

Presumo che l'autore stia chiedendo la riga di comando bash, mentre tutte le risposte tendono a diversificarsi a tutti i tipi di linguaggi di scripting.
tintinnio il

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

1
@zinking Bene, bash è progettato per essere facilmente in grado di invocare facilmente gli interpreti per un gran numero di altri linguaggi di scripting.
Casuale 832

Insegna a bash divisione intera con risultati in virgola mobile: stackoverflow.com/a/24431665/3776858
Cyrus,

Risposte:


399

Ci sono molte opzioni!!!

Sommario

$ 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

Dettagli

conchiglie

È possibile utilizzare POSIX espansione aritmetica per interi aritmetica echo "$((...))":

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

Abbastanza portatile ( ash dash yash bash ksh93 lksh zsh):
Usando l'abilità printf per stampare float possiamo estendere la maggior parte delle shell per fare matematica in virgola mobile anche se con un intervallo limitato (non più di 10 cifre):

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

ksh93, yashE zshfare carri di supporto qui:

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

solo ksh93(direttamente) e zshcaricando la libreria mathfunc qui:

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

zshnecessario caricare zmodload zsh/mathfuncper ottenere funzioni simili atan).


Interattivo con zsh:

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

Con (t) csh (solo numero intero):

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

Nella rcfamiglia di conchiglie akangac'è quella con espansione aritmetica:

; echo $:25/3
8

Toolchest POSIX

bc(vedi sotto per la modalità interattiva), manuale qui

Mnemonico: best calculator (anche se bin effetti è di base ).

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

(supporta numeri di precisione arbitrari)


bc modalità interattiva:

$ 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

Soluzione di Rush , expr(nessuna modalità interattiva):

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

La soluzione di Joshua : awk(nessuna modalità interattiva):

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

Altri strumenti più o meno portatili

La soluzione di Arcege , dc(modalità interattiva :)dc :

Il che è ancora più divertente poiché funziona con la notazione polacca inversa.

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

Ma non è pratico a meno che non lavori molto con la notazione polacca inversa.

Si noti che è dcprecedente bced bcè stato storicamente implementato come un wrapper dcma dcnon è stato standardizzato da POSIX


DQdims 's calc(richiesto sudo apt-get install apcalc):

$ calc 2 + 4
6

Interpreti di lingua per scopi generici:

soluzione di manatwork , node(modalità interattiva :;node funzione di output non necessaria):

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

Perl (modalità interattiva:) perl -de 1:

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

Python (modalità interattiva python:; funzione di output non necessaria):

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

Supporta anche numeri di precisione arbitrari:

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

Se hai clispinstallato, puoi anche usare la notazione polacca:

$ clisp -x "(+ 2 2)"

Soluzione di Marco , lua(modalità interattiva:) lua:

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

PHP (modalità interattiva:) php -a:

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

Ruby (modalità interattiva irb:; funzione di output non necessaria):

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

Guile (modalità interattiva:) guile:

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

S-Lang (modalità interattiva slsh:; funzione di output non necessaria, solo un ;terminatore):

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

Tcl (modalità interattiva tclsh:; funzione di output non necessaria, ma exprè):

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

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

Vari SQL:

SQLite (modalità interattiva:) 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

_Le opzioni su mysql e postgres fermano l'immagine 'ascii art'!

Lingue specializzate orientate alla matematica:

R in modalità normale: consente di generare 1000 numeri casuali normali, ottenere la deviazione standard e stamparla

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

R usando lo script più piccolo : consente di stampare al quadrato

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

PARI / GP , un ampio sistema di algebra computerizzata per la teoria dei numeri, l'algebra lineare e molte altre cose

$ 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

GNU Octave (un linguaggio interpretato di alto livello, destinato principalmente ai calcoli numerici)

Supporta anche numeri complessi:

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

Julia , linguaggio ad alte prestazioni ed interprete per informatica scientifica e numerica.

Opzione non interattiva:

$ julia -E '2.5+3.7'
6.2

3
e bc è interessante: whatis bc-> An arbitrary precision calculator language Interessante! Grazie!
Michael Durrant,

@MichaelDurrant potresti rivedere le tue modifiche, devo averlo respinto per errore?
Lgarzo,

4
C'è anche dc, che è ancora più divertente poiché funziona con la notazione polacca inversa. echo 20 5 + p | dc Ma non è pratico a meno che non lavori molto con la notazione polacca inversa.
Arcege,

2
Come variazione dell'approccio bc, ho aggiunto la seguente funzione (che ho trovato su stackexchange da qualche parte) al mio file .bashrc. Posso solo inserire calc 2 + 3 e ottenere 5. ## Command line calculator calc () { bc -l <<< "$@" }
Joe

1
@ Chris, il pesce è un bersaglio mobile. Stanno lavorando sul loro nuovo mathbuiltin (o come si chiama ora) mentre parliamo. Sentiti libero di modificare. Non è la mia risposta ed è wiki della community.
Stéphane Chazelas,

35

Esistono molti modi per calcolare. Per espressioni semplici puoi usare bashse stesso:

echo $((20+5))

oppure expr:

expr 20 + 5

E per casi complessi c'è un ottimo strumento bc:

echo "20+5" | bc

A proposito, bc può calcolare anche espressioni molto complesse con radici, logaritmi, cos, sin e così via.


Ho aggiunto la tua expropzione alla risposta accettata. Ho dovuto sceglierne uno da accettare e centralizzare.
Michael Durrant,

3
Stai cercando di eseguire expr 20+5. È necessario digitare spazi tra i numeri e più per farlo funzionare: expr 20 + 5. È importante.
precipita il

24

Le soluzioni menzionate vanno bene per calcoli molto semplici, ma molto inclini agli errori. Esempi:

# 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

Si può facilmente notare un errore di sintassi come gli ultimi, ma le risposte intere con una parte float scartata possono facilmente passare inosservate e portare a risultati errati.

Ecco perché uso sempre un linguaggio di scripting come Lua. Ma puoi scegliere qualsiasi linguaggio di scripting che conosci. Uso solo Lua come esempio. I vantaggi sono:

  • una sintassi familiare
  • funzioni familiari
  • avvertenze familiari
  • input flessibile
  • gli spazi di solito non contano
  • uscita a virgola mobile

Esempi:

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
bcIl risultato non è intero, ma arrotondato a scale, il cui valore predefinito è 0. Quindi, bc <<< 'scale=4;9.0/2.0'se si desidera la parte frazionaria.
arte

Grazie per la correzione. Tuttavia, è soggetto a errori. Ricorderò di aggiungerlo scalese lo userò bctra un paio di settimane? Probabilmente no. E anche se c'è un modo per cambiarlo permanentemente, ti morderà se sei su un sistema con le impostazioni predefinite.
Marco,

3
Personalmente me ne ricordo da scalequando mi sono incontrato la bcprima volta anni fa. Ma ho sempre dimenticato se la funzione di output luaè puto puts. ;)
arte

Conta bc come uno dei linguaggi di scripting. So sempre se ho bisogno di risultati interi o no - se l'intero va bene rimango in bash, altrimenti raramente ho motivo di usare bc. Per lua, devi ricordare -e, stampa e parentesi.
utente sconosciuto

7
Usa sempre bc -lpiuttosto che semplice bc, quindi non preoccuparti scale.
Dalker

23

Nessuno ha ancora menzionato Awk?

Usando le funzioni shell POSIX e la potenza matematica awk, basta definire questa funzione (una riga):

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

Quindi esegui cose come calc 1+1ocalc 5/2

Nota: per rendere la funzione sempre disponibile, aggiungila a ~ / .bashrc (o al file di avvio della shell corrispondente)

Naturalmente, un piccolo script chiamato "calc" con i seguenti contenuti:

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

potrebbe anche funzionare.


2
Wow, questo è il migliore, supporta anche i float. Funziona senza installare nulla!
CMCDragonkai

1
Molto bello, volevo fare un confronto fluttuante, ecco come l'ho fatto con il tuo aiuto: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

Puoi usare bc. Per esempio,

$ echo "25 + 5" | bc
30

In alternativa bc <<< 25+5funzionerà anche.

O in modo interattivo, se vuoi fare più di un semplice semplice calcolo:

$ 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

L'implementazione GNU bcstampa le informazioni di intestazione / copyright all'avvio quando sia lo stdin che lo stdout vanno su un terminale. Puoi sopprimerlo con l' -qopzione (specifica per GNU) . Per maggiori informazioni consultare la pagina man di bc


1
+1 per entrambe le opzioni di pipe ("|") e modalità interattiva per bs. Uno ctrl-dper uscire?
Michael Durrant,

1
@MichaelDurrant Sì, ^ D farà il trucco come faràquit
Levon

c () { bc -l <<< "$@" } definirà una funzione c per un utilizzo facile e veloce. ad esempio c 3/2ti darà 1.50000000000000000000. Il link sopra che descrive come farlo è morto.
ijoseph,

1
@Levon il collegamento alla pagina man funziona ancora. Tuttavia, viene visualizzato il collegamento: paweng.com/2008/08/15/unix-command-line-calculator , fornito come obiettivo di "Questo" nella frase "Questa pagina mostra anche come impostare un alias ..." morto.
ijoseph,

1
@ijoseph Grazie .. Ho rimosso il riferimento a quel link di 6 anni (vorrei che i link si distinguessero più chiaramente sul mio browser - non l'ho nemmeno visto quando ho guardato ieri)
Levon

16

Puoi usare calc:

Se entri calcsenza altri argomenti, entra in una modalità interattiva in cui puoi semplicemente continuare a fare matematica. Si esce 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

Oppure lo usi con l'espressione come argomento e fornirà la risposta e poi uscirà

$calc 2 + 4
    6
$

calcè simile a bc, mi piace il modo in cui si comporta meglio come predefinito


1
Non è necessario accedere alla modalità interattiva, a meno che non si desideri, ad esempio: calc -e '2+4; 3+5; 3.4+5; 2^4stampa 4 righe di output o solo calc -e 33+(3^3).. +1 Mi piace l'idea di utilizzare qualcosa chiamato "calc" per una calcolatrice :)
Peter.O

1
Mi sono appena reso conto che l' -eopzione non è necessaria quando c'è solo un'espressione ... pulita! ..
Peter.O

10

Mi piace accendere Python e usarlo come una calcolatrice interattiva (ma, di nuovo, sono un programmatore Python).


anch'io! Python è il mio coltellino svizzero
Levon,

Ho sempre una finestra screensolo con Python.
Arcege,

1
pythonpy ( github.com/russell91/pythonpy ) è un bel modo di fare questo e altre cose nella sintassi di Python senza dover avviare una shell interattiva: py '3.2 * 5' => 16
RussellStewart

Mi piace Python, ma il tempo di avvio diventa importante se vuoi solo aggiungere due numeri in alcuni punti del tuo script Bash
ndemou,

@ndemou Ho detto calcolatrice "interattiva". Anche se vale la pena notare che a un certo punto se stai facendo cose abbastanza complesse in una sceneggiatura, la sanità mentale ti impone di usare qualcosa di diverso da bash (come Python).
asmeurer,

10

Dal momento che nessun altro l'ha menzionato, e sebbene non sia strettamente una calcolatrice (ma non lo sono nemmeno tutti questi linguaggi di scripting generici), vorrei menzionare units:

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

Oppure, per un output inferiore in modo da poter ottenere solo il numero da utilizzare $()per assegnare a qualcosa:

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

E fa anche conversioni di temperatura

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

Per ottenere la conversione della temperatura in un'espressione per ulteriori calcoli, procedere come segue:

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

Ci sono così tante opzioni che non richiedono l'installazione di un programma aggiuntivo che non vedo perché uno vorrebbe andare in quel modo.
ndemou,

@ndemou È installato di default su alcune distribuzioni ... e molte di queste altre risposte non lo sono. E hai davvero bisogno di commentarlo su una risposta che ha cinque anni?
Casuale 832,

1
Penso che sia positivo commentare quando voto in basso ed è una pratica che è anche incoraggiata da SE. Non vedo perché cinque anni siano rilevanti. Lo stesso commento si applica a tutte le risposte simili - niente di personale. (A proposito, anche il programma più oscuro può essere installato di default su alcune distribuzioni. In questo caso ho testato le recenti installazioni di Debian, Ubuntu, CentOS e RedHat e le unità non lo sono)
ndemou,

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

Inoltre ghci, questo è il compilatore di Glasgow-Haskell in modalità interattiva ( ghc --interactive, al contrario di valutare un'espressione con -e), crea un affascinante "calcolatore":

$>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
È questo ghcsignificato Glasgow Haskell Compiler?
arte

facendo un passaggio sui programmi che devo installare ma grazie.
Michael Durrant,

4

Non riesco a credere di leggere "il potere di JavaScript" (ma ho dovuto votare la risposta per le altre parti, tranne ovviamente perl.

In pratica, per i semplici casi in cui l'aritmetica dei numeri interi è sufficiente, utilizzo buildin $ ((...)) e lo consiglio. Altrimenti, quasi tutti i casi fanno eco "..." | bc è sufficiente.

Per alcune operazioni aritmetiche come statistiche, operazioni a matrice e altro Rè lo strumento migliore:

echo 25 + 5 | R --vanilla

e per piccoli set di dati e risultati grafici di eliminazione, oocalcè una bella utility.


4

Uso un piccolo script Python che valuterà un'espressione Python e stamperà il risultato, quindi posso eseguire qualcosa del genere

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

lo 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')

Sfortunatamente non ricordo da dove ho preso in prestito la maggior parte del codice, quindi non posso citarlo.


non print(eval(' '.join(sys.argv[1:])))farebbe la stessa cosa?
g.rocket,

Stai usando un martello per colpire una mosca qui
ndemou,

4

gnuplot

gnuplot - un programma di tracciamento interattivo
Segui il link sopra o digitagnuplotil prompt e poihelpall'interno dell'interprete gnuplot .
Gnuplot è un programma nato per tracciare dati, ma può essere utilizzato anche per il calcolo. Offre il vantaggio di poter definire funzioni o utilizzare quelle integrate.

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

Root (o qualche altro interprete C )

Il sistema ROOT fornisce una serie di framework OO con tutte le funzionalità necessarie per gestire e analizzare grandi quantità di dati in un modo molto efficiente ...

È possibile utilizzarlo come C interprete , CINT , oppure è possibile utilizzare uno dei molti molti altri interpreti C . IMHO, è enorme, complesso, potente e non sempre amichevole, ma può anche dare grandi soddisfazioni.

Se davvero non vuoi ascoltare la vocina dentro di te che cita Confucio e sei pronto a rompere un (burro) volo sulla ruota , puoi usare root . In questo caso -lè obbligatorio evitare di mostrare la schermata iniziale ...

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

Per aritmetica intera (dove 3/2 = 1)

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

*: e ksh93, yash

Per aritmetica in virgola mobile (dove 3/2 = 1.5)

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

*: e ksh93, yash

Puoi ovviamente configurare la tua shell per usare awk con una digitazione minima come calc 10/3(vedi note su come farlo per bash 1 e fish 2 ).

Il motivo principale per suggerire awk per bash è che è preinstallato su quasi tutti i sistemi operativi simili a Unix ed è ragionevolmente leggero (c'è ovviamente il costo di avviare un processo) con un output meno preciso ma più rispettoso dell'uomo di bc -lcui stampa 20 decimali cifre (anche se puoi certamente modificare awk per ottenere più cifre decimali ).


Appunti

(1) Come usare la sintassi semplificata in bash

Aggiungi questa funzione bash al tuo ~/.bashrc:

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

(2) Come utilizzare la sintassi semplificata nei pesci

Crea una calcfunzione fish (ovvero un file di testo chiamato /home/ndemou/.config/fish/functions/calc.fish):

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

awkutilizzerà il tipo a doublevirgola mobile del sistema , quindi sarà preciso come la maggior parte degli altri strumenti che non fanno precisione arbitraria (nota che gawk può fare precisione arbitraria). awkusa la OFMTvariabile per convertire il numero nella sua rappresentazione di stringa per l'output ( %.6gper impostazione predefinita, potresti volerlo cambiare %.17gse vuoi maggiore precisione ).
Stéphane Chazelas,

Si noti che fish's mathè solo una funzione che chiama bc(anche se questo è di cambiare )
Stéphane Chazelas

1
Bene, era una funzione che chiama bc. Non è più nelle versioni più recenti in cui cose come math "scale=4; 10/3"non funzioneranno più ( math -s4 10/3invece ora)
Stéphane Chazelas,

Grazie Stéphane Chazelas - ho aggiornato la mia risposta ( math -s4sembra essere supportato anche nelle versioni precedenti)
ndemou

3

Per i calcoli della console, io uso concalc. ( sudo aptitude install concalc)

Dopodiché, basta digitare concalc e premere invio. Non fornirà un prompt, ma basta digitare il calcolo (senza spazi) e premere invio, e nella riga successiva, ti darà il valore numerico.


3

SQLite :

echo 'select 1 + 1;' | sqlite3 

MySQL :

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

PostgreSQL :

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

3
Alcuni dettagli minori meritano di essere menzionati: 1) from dualè necessario a Oracle, MySQL è in grado di farlo selectsenza fromclausole. 2) PostgreSQL non richiede l'alias. 3) È ;richiesto solo da SQLite. 4) MySQL e PostgreSQL funzioneranno solo se sono in grado di connettersi a un server di database. 5) MySQL e PostgreSQL disegneranno una tabella di arte ASCII attorno ai risultati. Per ottenere solo il valore: mysql -BNe 'select 1+1'e psql -tAc 'select 1+1.
arte

2

Utilizzare l' aritmetica libreria GNU multipla di precisione attraverso la dotazione run-exprdel programma:

  • Scarica ed estrai (avrai bisogno di lzip): tar -xvf gmp-5.1.3.tar.lz
  • Nella directory principale ./configuree make(non è necessario installare)
  • In demo / expr, make run-expr
  • Mi piace creare un link simbolico ad esso nella mia ~/bindirectory:ln -s /path/to/gmp/demos/expr/run-expr ~/bin/run-expr
  • Aggiungi un alias per un facile utilizzo; ad esempio alias calcf='run-expr -f'per la valutazione in virgola mobile

Produzione:

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

Dal run-expr.cfile:

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.

Consultare il manuale per differenze e dettagli delle classi di funzioni.

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.