Qualsiasi calcolatore da riga di comando per Ubuntu?

118

Sto cercando una calcolatrice che possa eseguire calcoli nel terminale stesso senza altri prefissi e suffissi aggiuntivi.

Ad esempio: se ho digitato qualcosa come 10000-9000 nel terminale, la risposta dovrebbe uscire come 1000.

Ancora una volta sto dicendo, ho solo bisogno di una calcolatrice rapida nel terminale, senza alcun carattere aggiunto. So che se passo a Python, può farlo ma non lo voglio in questo modo.

    
posta rɑːdʒɑ 18.11.2013 - 03:37
fonte

23 risposte

74

Aritmetica bash

Un'altra possibile soluzione è aggiungere una semplice funzione per l'aritmetica incorporata di Bash. Metti questo nel tuo file .bashrc per provare:

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

Quindi ora non hai più bisogno di $((...)) più, solo = che sembra abbastanza naturale.

Sostituzione

Un'altra cosa se vuoi essere ancora più veloce: puoi sostituirlo con p con + e x con * . Questo funzionerà per questo:

=() {
    local IFS=' '
    local calc="${*//p/+}"
    calc="${calc//x/*}"
    echo "$(($calc))"
}

= 5 x 5  # Returns 25
= 50p25  # Returns 75

Ora non hai più bisogno di Maiusc , l'unica cosa è davanti all'aritmetica.

Uscita esadecimale

L'output può essere visualizzato sia in decimale sia in esadecimale, se lo si desidera. ( Nota : l'uso della sostituzione di x è in conflitto con la sintassi esadecimale 0x... )

=() {
    local answer="$(($@))"
    printf '%d (%#x)\n' "$answer" "$answer"
}

Esempio:

$ = 16 + 0x10
272 (0x110)

$ = 16**3 + 16**4
69632 (0x11000)

Uso di bc

Se desideri calcoli leggermente più avanzati, puoi reindirizzarlo a bc in questo modo:

=() {
    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)

Le funzioni fornite da bc sono le seguenti (e possono essere trovate da 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.

Supporta anche if , for , while e variabili come un linguaggio di programmazione anche se potrebbe essere meglio scrivere su un file se lo si desidera.

Ricorda che sostituirà p e x nei nomi di funzioni / variabili. Potrebbe essere meglio rimuovere semplicemente le sostituzioni.

Uso di gcalccmd

Puoi anche chiamare la funzione gcalccmd (da gnome-calculator ) in questo modo:

=() {
    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

Le funzioni disponibili sembrano essere (prese direttamente da codice sorgente ), == denota funzioni equivalenti:

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()
    
risposta data kiri 19.11.2013 - 10:33
fonte
91

Puoi eseguire l'aritmetico intero semplice in modo nativo in bash utilizzando la sintassi ((...)) , ad es.

$ echo $((10000-9000))
1000

C'è anche la calcolatrice bc , che può accettare espressioni aritmetiche su input standard

$ echo "10000-9000" | bc
1000

Anche il programma bc può eseguire aritmetici in virgola mobile

$ echo "scale = 3; 0.1-0.09" | bc
.01
    
risposta data steeldriver 18.11.2013 - 03:59
fonte
89

Puoi utilizzare calc . Non è installato di default, ma puoi installarlo rapidamente usando il seguente comando:

sudo apt-get install apcalc

Dopo aver installato, puoi fare qualsiasi calcolo desideri:

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

Per ulteriori informazioni, consulta la man-page

    
risposta data Radu Rădeanu 18.11.2013 - 10:16
fonte
30

Sfortunatamente, non esiste un modo "più semplice" per farlo. L'interfaccia python interattiva sulla riga di comando è la più adatta per ciò di cui hai bisogno, perché a differenza di apcalc \, python è incluso in Ubuntu. Non sono sicuro che bc sia incluso, tuttavia, python è il preferito a mani basse per questa roba.

È sufficiente eseguire l'interfaccia interattiva python sulla riga di comando, quindi eseguire la matematica in questo modo. Puoi usarlo come calcolatrice.

Per farlo, apri il terminale, digita python , quindi premi il pulsante Invio .

Quindi, nel prompt python che appare, puoi digitare la matematica. Ad esempio, 10000 - 9000 . Il risultato della riga successiva è il risultato.

Se intendi, però, qualcosa in cui devi solo caricare il terminale e farlo ...

$ 10000 - 9000
1000
$

... quindi non c'è modo di farlo in solo il terminale senza nient'altro, perché Bash non gestisce argomenti numerici del genere.

    
risposta data Thomas Ward 18.11.2013 - 03:40
fonte
23

Ti consiglierei di creare una semplice funzione per i calcoli Python di base. Qualcosa di simile nel tuo .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 vuoi fare matematica più avanzata, puoi utilizzare la seguente che importa tutte le funzioni del modulo math . (vedi qui per maggiori informazioni)

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: poiché Python è un linguaggio di programmazione, alcune cose possono sembrare strane, ad esempio ** per le potenze di e % per modulo)

In alternativa puoi creare uno script Python calc ,

#!/usr/bin/python3
from math import *
import sys
print(eval(' '.join(sys.argv[1:])))

posizionalo in una directory inclusa nella variabile PATH e imposta il suo flag eseguibile per ottenere lo stesso comando calc come sopra (non è necessario creare una funzione di Bash per eseguire uno script Python).

Se vuoi un metodo in puro Bash, usa la risposta di steeldriver. Questa risposta è davvero utile se hai bisogno delle funzioni più avanzate (cioè da math ), dato che Python è relativamente lento rispetto a Bash.

Non sono sicuro che se questo interrompe il tuo "passaggio a Python può farlo e io non lo voglio in questo modo". nota, ma non è necessario inserire il prompt interattivo e il risultato è accessibile in Bash, quindi questa risposta sembra valida (almeno per me).

    
risposta data kiri 18.11.2013 - 09:45
fonte
21

Utilizza il pacchetto gcalccmd da gnome-calculator (& gt; = 13.04) o gcalctool (& lt; 13.04). Penso che il pacchetto sia installato di default

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

Ecco uno script di shell veloce per questo:

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

Salva questo come "c", quindi mettilo da qualche parte nel tuo percorso (come / bin), quindi contrassegnalo come eseguibile.

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

Da ora in poi, puoi eseguire calcoli nel terminale in questo modo:

$ c 10000-9000
1000
    
risposta data user530873 18.11.2013 - 06:19
fonte
8

Ecco una modifica della parte appropriata di /etc/bash.bashrc (su Ubuntu 10.04) che modificherà il gestore command_not_found per eseguire l'analizzatore di espressioni della shell se il primo carattere del comando sconosciuto è un numero o - o% % co_de.

Sarai in grado di eseguire qualsiasi aritmetica di shell in questo modo; vedi link per un elenco di operatori aritmetici.

Nota che se l'espressione che vuoi valutare contiene un + , dovrai citare il * con * o virgolette poiché la shell farà l'espansione del nome del file prima di decidere quale comando eseguire. Stessa cosa per altri operatori come \ .

Metti questo nella tua >> , quindi digita ~/.bashrc e provalo.

# 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

Output di esempio: (sto digitando . ~/.bashrc , un errore di battitura, solo per verificare che il nostro nuovo gestore command_not_found proverà ancora a cercare comandi sconosciuti).

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
    
risposta data Mark Plotnick 18.11.2013 - 18:05
fonte
8

Un'altra soluzione che non ho visto qui è Qalculate (qalc) .

sudo apt-get install qalc

per la versione della CLI,

sudo apt-get install qalculate-gtk

per la GUI.

Ha un sacco di funzioni come:

  • supporto per unità : ad es. %codice%
  • built-in costanti come 20 m / s * 12 h = 864 kilom , pi , e , c
  • molte funzioni integrate : ad es. avogadro , sin(pi) = 0 , gamma(4) = 6 , 5! = 120
  • conversione delle unità, ad esempio
% Bl0ck_qu0te%
  • calcolo simbolico , ad es. %codice%
  • integrazione, ad es. log(1024, 2) = 10 , (x + y)^2 = x^2 + 2xy + y^2
  • aiuto integrato, ad es. integrate 3*x^2 = x^3 , diff sin(x), pi
  • tab completamento dei comandi
  • tutto è tradotto, ad es. il mio sistema è in olandese, quindi posso scrivere sia help convert che help integrate .
  • e altro ...

Dici che vuoi usarlo senza prefissi, beh ... puoi usarlo con un prefisso:

factorial(5)

oltre a eseguirlo come repl.

    
risposta data JW. 26.11.2013 - 11:46
fonte
7

dc ! Fa parte di coreutils, quindi è installato su OS X, Ubuntu e praticamente TUTTO. È un calcolatore RPN, quindi se non ti piacciono, non è per te.

I comandi

Molto di base sono i seguenti (la manpage ha tutta la sintassi che non ho incluso. Esponenziazione, chiunque?)

Hai solo bisogno di spazi tra i numeri. Vengono ignorati in tutti gli altri casi.

Digitando un numero lo spinge in cima allo stack.

+ 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
    
risposta data Yet Another User 18.11.2013 - 21:07
fonte
5

Uso Octave per questo genere di cose: link

È praticamente un clone MATLAB (scusate se si tratta di una semplificazione eccessiva) che può essere utilizzato nel terminale digitando l'ottava. Installa sudo apt-get install octave

Non è esattamente quello che vuoi ma ho pensato di aggiungerlo come alternativa a python.

Esempio di utilizzo:

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

Mi piace molto wcalc. È un calcolatore scientifico da riga di comando. Facile da trovare in Ubuntu Software Center, o semplicemente utilizzare apt-get.

sudo apt-get install wcalc

Accetta gli argomenti della riga di comando e ha la modalità "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 qualcuno è in ingegneria, come me, potresti fare uso di GNU Octave. Può fare ogni sorta di cose, creare grafici, risolvere equazioni simultanee. Inoltre è un'alternativa gratuita a Matlab

    
risposta data Sergiy Kolodyazhnyy 22.09.2014 - 11:58
fonte
4

il modo semplice è chiamare python.

Esempio:

>  python -c 'print 10000-9000'
    
risposta data user2327875 20.11.2013 - 14:35
fonte
3

Quello che ho trovato è che non posso fidarmi di expr, bc o delle opzioni di shell integrate. Quindi ho usato Perl che verrebbe normalmente installato in * linux distro's

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

Il calcolo precedente sottrae $ VAL1 da $ VAL2 e stampa senza cifre decimali (0f)

Beneficiare dell'uso di Perl è (dettagli su Pro e amplienti elencati qui )

  • Migliore acquisizione degli errori (dividi per 0 non fermerà il calcolo)
  • Può fornire formule in un file di configurazione. Non è necessario sfuggire utilizzando espressioni regolari complesse
risposta data diaryfolio 18.11.2013 - 11:14
fonte
3

Puoi aggiungere la seguente funzione al tuo file .bashrc:

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

Nota che il flag -l è molto importante. Senza di esso, l'uso di bc5 / 2 = 2 .

Come accennato sopra, i calcoli possono essere eseguiti utilizzando il segno = davanti alla formula.

    
risposta data vdm 19.11.2013 - 14:51
fonte
3

Puoi usare anche awk per fare alcuni calcoli aritmetici sul terminale,

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

usa il comando "bc" e poi puoi fare il calcolo

esempio

[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

Per utilizzare bc senza scrivere la nota di garanzia nel terminale bc -q

Esempio

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

Puoi usare bind e bash C-a e C-e per controllare l'output. Ad esempio, eseguilo nella tua shell:

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

Ora scrivi qualsiasi operazione aritmetica come 10 + 15 e premi Ctrl + J :

$ echo $(( 10 + 15 )) 
25

Otterrai questo. Ora, come è fatto?

  • bind questo comando cambia il binding della tua bash, come i tasti di scelta rapida.
  • \C-j questo è l'equivalente bash di Ctrl + J, questa è la combinazione di tasti che vorremmo aggiungere al nostro comando.
  • \C-a questo ci porta all'inizio della linea.
  • echo $(( questo scrive echo $(( all'inizio.
  • \C-e ci porta alla fine della riga
  • )) chiude la nostra parentesi precedente
  • \C-m questo è l'equivalente di restituire la chiave.

Puoi scrivere questo nel tuo file ~/.inputrc :

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

Ovviamente anche le altre risposte sono valide! Appena ottimizzato un po ':

  • 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"
  • altri?

Puoi cambiare Ctrl + J in qualsiasi modo desideri, ma ricorda, prova a non modificarlo per qualcosa che ha già un legame;).

Resource:

risposta data Braiam 20.11.2013 - 01:55
fonte
2

In passato, ho utilizzato wcalc e un piccolo programma chiamato e che è praticamente impossibile google per. Ora uso uno script python per fare ciò, che usa alcune funzioni di e come le parentesi quadre. wcalc è ancora bello perché può fare precisione arbitraria e conversione di unità, ma non uso quasi mai quelle funzioni.

#!/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(")", "]"))

Ecco come usarlo (supponendo che lo script sia stato salvato come e e messo da qualche parte in $PATH ):

$ e e**[pi*1i]
-1.0
$ e hex[10**3]
0x3e8
$ e "[0o400+3]&0xff" # need quotes because of '&'
3
    
risposta data jpkotta 18.11.2013 - 17:20
fonte
0

C'è un modo in più per ottenere esattamente quello che vuoi. Tutto ciò che devi fare è impostare shell per il tuo account su /bin/bc .

    
risposta data bizzyunderscore 21.11.2013 - 02:29
fonte
0

Puoi anche usare printf shell integrata per eseguire calcoli aritmetici sul terminale.

printf 'expr $num1 + $num2'   # num1,num2 are  variables which stores numbers as values.

Esempio:

$ printf "$(expr 10000 + 9000)\n"
19000
$ printf "$(expr 10000 - 9000)\n"
1000
    
risposta data Avinash Raj 16.04.2014 - 15:26
fonte
0

Puoi usare l'interprete python per il calcolo. Ecco un tutorial su come farlo .

Python 2 e python 3 sono installati in Ubuntu di default.

$ 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
    
risposta data noone 27.08.2017 - 12:08
fonte
0

Crea un calcolatore del terminale

Inserisci quanto segue nel tuo file .bashrc

function calc
{
 echo "${1}"|bc -l;
}

Oppure eseguilo al prompt della shell. Adesso   "calc" dalla shell funzionerà come segue:

$ calc 3+45
   48

Tutte le funzioni con un "(" o ")" devono essere racchiuse   tra virgolette.

    
risposta data Vishnu N K 31.01.2014 - 18:17
fonte

Leggi altre domande sui tag