Qualche calcolatore della riga di comando per Ubuntu?

Sto cercando un calcolatore che può fare calcoli nel terminale stesso senza altri prefissi e suffissi aggiuntivi.

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

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

Bash Arithmetic

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

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

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

Sostituzione

Un'altra cosa se vuoi essere ancora più veloce: puoi farlo sostituire pcon +e xcon *. 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 nemmeno Shiftpiù bisogno , l'unica cosa è = di fronte all'aritmetica.

Uscita esadecimale

L'output può essere visualizzato sia in decimale sia in esadecimale, se lo si desidera. ( Nota : l'utilizzo della xsostituzione sarà in conflitto con la 0x...sintassi esadecimale)

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

Esempio:

$ = 16 + 0x10
272 (0x110)

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

utilizzando bc

Se desideri calcoli leggermente più avanzati, puoi inoltrarlo in questo bcmodo:

=() {
    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 bcsono 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, whilee variabili come un linguaggio di programmazione anche se può essere meglio per scrivere in un file se si voleva che.

Tieni presente che sostituirà pe xin nomi di funzioni / variabili. Potrebbe essere meglio rimuovere solo le sostituzioni.

utilizzando gcalccmd

Puoi anche effettuare la chiamata di 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 dal codice sorgente ), ==denotano 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()

Puoi eseguire l'aritmetica di interi interi in modo nativo in bash usando la ((...))sintassi, ad es

$ echo $((10000-9000))
1000

C'è anche la bccalcolatrice, che può accettare espressioni aritmetiche sull'input standard

$ echo "10000-9000" | bc
1000

Il bcprogramma può eseguire anche l'aritmetica in virgola mobile

$ echo "scale = 3; 0.1-0.09" | bc
.01

È possibile utilizzare calc. Non è installato per impostazione predefinita, ma è possibile installarlo rapidamente utilizzando 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, consultare la sua pagina man

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

Puoi semplicemente eseguire l' pythoninterfaccia interattiva dalla riga di comando, quindi fare matematica in quel modo. Puoi usarlo come calcolatrice.

Per fare ciò, apri il terminale, digita python, quindi premi il Enterpulsante.

Quindi, nel prompt di Python che viene visualizzato, puoi digitare la tua matematica. Ad esempio 10000 - 9000,. L'output della riga successiva è il risultato.

Se intendi, però, qualcosa in cui carichi il terminale e puoi farlo ...

$ 10000 - 9000
1000
$

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

Ti consiglierei di creare una semplice funzione per i calcoli di base di Python. Qualcosa del genere 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 usare quella seguente che importa tutte le mathfunzioni del modulo. (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 i poteri 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 PATHvariabile e imposta il suo flag eseguibile per ottenere lo stesso calccomando di cui sopra (non è necessario creare una funzione Bash per eseguire uno script Python).

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

Non sono sicuro che questo rompa il tuo "passaggio a Python, può farlo e 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).

Utilizzare il pacchetto gcalccmdfrom gnome-calculator(> = 13.04) o gcalctool(<13.04). Penso che il pacchetto sia installato di default

% gcalccmd
> 2+3
5
> 3/2
1.5
> 3*2
6
> 2-3
−1
> 

Ecco uno script di shell rapido per questo:

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

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

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

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

$ c 10000-9000
1000

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

Sarai in grado di eseguire qualsiasi aritmetica della shell in questo modo; consultare http://www.gnu.org/software/bash/manual/bashref.html#Shell-Arithmetic per un elenco di operatori aritmetici.

Si noti che se l'espressione che si desidera valutare contiene un *, sarà necessario citare il *con \o le virgolette poiché la shell eseguirà l'espansione del nome file prima di decidere quale comando eseguire. Stessa cosa per altri operatori come >>.

Inseriscilo nel tuo ~/.bashrc, quindi digita . ~/.bashrce 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 scrivendo cta, un errore di battitura, solo per testare 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

Un'altra soluzione che non ho visto menzionato 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 funzionalità come:

• supporto per unità : es20 m / s * 12 h = 864 kilom
• incorporato costanti come pi, e, c,avogadro
• molti built-in funzioni : ad esempio sin(pi) = 0, gamma(4) = 6, 5! = 120,log(1024, 2) = 10
• conversione di unità, ad esempio:

> 120 in
120 * inch = 120 in
> convert cm
120 in = 304.8 centim

• calcolo simbolico , ad esempio(x + y)^2 = x^2 + 2xy + y^2
• integrazione, ad es integrate 3*x^2 = x^3.diff sin(x), pi
• guida integrata, ad es help convert.help integrate
• tab completamento dei comandi
• tutto è tradotto, ad esempio il mio sistema è in olandese, quindi posso scrivere sia factorial(5)e faculteit(5).
• e altro ancora ...

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

$ qalc 5 ft + 3 cm
(5 * foot) + (3 * centim) = 1.554 m

oltre a eseguirlo come sostituto.

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

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

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

Digitare un numero lo spinge in cima alla pila.

+ 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

Uso Octave per questo genere di cose: http://www.gnu.org/software/octave/

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

Non è proprio quello che vuoi, ma ho pensato di aggiungerlo come alternativa a Python.

Esempio di utilizzo:

~ $ octave
octave:1> 9000 - 8000
ans =  1000
octave:2> 

Mi piace molto wcalc. È un calcolatore scientifico della riga di comando. Facile da trovare in Ubuntu Software Center o semplicemente usare 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 usare GNU Octave. Può fare ogni sorta di cose, rappresentare graficamente, risolvere equazioni simultanee. Inoltre è un'alternativa gratuita a Matlab

il modo semplice è chiamare Python.

Esempio:

>  python -c 'print 10000-9000'

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

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

Il calcolo sopra sottrarrà $ VAL1 da $ VAL2 e stamperà senza decimali (0f)

Il vantaggio derivante dall'uso di Perl è (dettagli su Pro e contro elencati qui )

• Migliore acquisizione degli errori (la divisione per 0 non interromperà il calcolo)
• Può fornire formule in un file di configurazione. Non c'è bisogno di scappare usando regex complesso

È possibile aggiungere la seguente funzione al file .bashrc:

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

Nota che la -lbandiera è molto importante. Senza di essa, l'uso di bcdà 5 / 2 = 2.

Come è stato menzionato sopra, i calcoli possono essere fatti usando il =segno davanti alla formula.

Puoi anche usare 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

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 bcsenza la nota di garanzia scrivere nel terminalebc -q

esempio

[root@vaibhav ~]# bc -q
10+2
12

È possibile utilizzare bind e bash C-ae C-eper controllare l'output. Ad esempio, esegui questo nella tua shell:

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

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

$ echo $(( 10 + 15 )) 
25

Lo capirai. Ora, come si fa?

• bind questo comando modifica l'associazione di bash, come i tasti di scelta rapida.
• \C-j questo è l'equivalente bash di Ctrl + J, questa è quale combinazione di tasti 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 linea
• )) chiude la nostra precedente parentesi
• \C-m questo è l'equivalente di chiave di ritorno.

Puoi scrivere questo nel tuo ~/.inputrcfile:

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

Naturalmente, anche le altre risposte sono valide! Ho appena modificato un po ':

• avanti Cristo: "\C-j": "\C-aecho " \C-e " | bc \C-m"
• apcalc: "\C-j": "\C-acacl \C-m"
• pitone: "\C-j": "\C-apython3 -c "print( \C-e )" \C-m"
• chiunque altro?

Puoi cambiare Ctrl + J come preferisci, ma ricorda, cerca di non cambiarlo per qualcosa che ha già un'associazione;).

Risorsa:

• C'è un modo per configurare bash per l'output della pagina?

In passato, ho usato wcalce chiamato un piccolo programma eche è praticamente impossibile per Google. Ora uso uno script Python per fare questo, che usa alcune caratteristiche ecome le parentesi quadre. wcalcè ancora bello perché può fare arbitraria precisione e conversione di unità, ma non uso quasi mai quelle funzionalità.

#!/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 ee messo da qualche parte nel $PATH):

$ e e**[pi*1i]
-1.0
$ e hex[10**3]
0x3e8
$ e "[0o400+3]&0xff" # need quotes because of '&'
3

C'è un modo in un solo passaggio per realizzare esattamente quello che vuoi. Tutto quello che devi fare è impostare il shelltuo account su /bin/bc.

È inoltre possibile utilizzare la printf shell incorporata 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

È possibile utilizzare l'interprete Python per il calcolo. Ecco un tutorial su come farlo .

Python 2 e python 3 sono installati in Ubuntu per impostazione predefinita.

$ 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

Crea una calcolatrice terminale

Inserisci quanto segue nel tuo file .bashrc

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

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

$ calc 3+45
   48

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