Irgendein Befehlszeilenrechner für Ubuntu?

Ich bin auf der Suche nach einem Rechner, der Berechnungen im Terminal selbst ohne zusätzliche Präfixe und Suffixe durchführen kann.

Beispiel: Wenn ich im Terminal so etwas wie 10000-9000 eingetippt habe, sollte die Antwort 1000 lauten.

Ich sage noch einmal, ich brauche nur einen schnellen Taschenrechner im Terminal, ohne dass irgendwelche Zeichen hinzugefügt werden. Ich weiß, wenn ich zu Python wechsle, kann es das, aber ich möchte es nicht so.

Bash-Arithmetik

Eine andere mögliche Lösung besteht darin, eine einfache Funktion für die in Bash integrierte Arithmetik hinzuzufügen. Fügen Sie dies in Ihre .bashrcDatei ein, um Folgendes zu versuchen:

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

Jetzt brauchen Sie nicht einmal $((...))mehr, =was natürlich genug erscheint.

Ersatz

Eine andere Sache , wenn Sie wollen noch schneller sein: Sie können es machen ersetzen pmit +und xmit *. Das wird dafür funktionieren:

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

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

Jetzt brauchst du nicht Shiftmehr, das Einzige, was du tun musst , ist = Rechnen.

Hexadezimale Ausgabe

Die Ausgabe kann auf Wunsch sowohl dezimal als auch hexadezimal erfolgen. ( Hinweis : Die Verwendung der xErsetzung widerspricht der 0x...Hex-Syntax.)

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

Beispiel:

$ = 16 + 0x10
272 (0x110)

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

Verwenden bc

Wenn Sie etwas fortgeschrittenere Berechnungen wünschen, können Sie es bcso weiterleiten:

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

Die von bereitgestellten Funktionen bcsind wie folgt (und können von man bc) gefunden werden:

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.

Es unterstützt aber ifauch for, whileund Variablen wie eine Programmiersprache, wenn es besser ist, in eine Datei zu schreiben, wenn Sie das möchten.

Denken Sie daran, dass es pund xin Funktions- / Variablennamen ersetzen wird . Es kann besser sein, nur die Ersetzungen zu entfernen.

Verwenden gcalccmd

Sie können den Funktionsaufruf gcalccmd(von gnome-calculator) auch folgendermaßen ausführen:

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

Die verfügbaren Funktionen scheinen (direkt aus dem Quellcode entnommen ) ==gleichwertige Funktionen zu sein:

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

Sie können einfache Ganzzahlarithmetik nativ in Bash ausführen, indem Sie die ((...))Syntax verwenden, z

$ echo $((10000-9000))
1000

Es gibt auch den bcTaschenrechner, der arithmetische Ausdrücke auf Standardeingabe akzeptieren kann

$ echo "10000-9000" | bc
1000

Das bcProgramm kann auch Gleitkomma-Arithmetik ausführen

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

Sie können verwenden calc. Wird nicht standardmäßig installiert, kann jedoch mit dem folgenden Befehl schnell installiert werden:

sudo apt-get install apcalc

Nach der Installation können Sie eine beliebige Berechnung durchführen:

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

Weitere Informationen finden Sie in der Manpage

Leider gibt es keinen "einfacheren" Weg, dies zu tun. Die interaktive Python - Schnittstelle auf der Kommandozeile ist am besten geeignet für das, was Sie brauchen, denn im Gegensatz zu apcalc\, pythonist enthalten in Ubuntu. Ich bin mir nicht sicher, ob bces noch enthalten ist, aber Python ist der absolute Favorit für dieses Zeug.

Sie können die interaktive pythonSchnittstelle einfach in der Befehlszeile ausführen und dann auf diese Weise rechnen. Das können Sie als Taschenrechner verwenden.

Dazu öffnen Sie das Terminal, geben ein pythonund Enterdrücken dann die Taste.

Dann wird in der Python - Eingabeaufforderung , die nach oben zeigt, können Sie Ihre mathematische in eingeben. Zum Beispiel 10000 - 9000. Die nächste Zeilenausgabe ist das Ergebnis.

Wenn Sie meinen, etwas, wo Sie nur das Terminal laden und dies tun können ...

10000 bis 9000 US-Dollar
1000
$

... dann nein, es gibt keine Möglichkeit, dies nur im Terminal ohne irgendetwas anderes zu tun , da Bash solche numerischen Argumente nicht verarbeitet.

Ich rate Ihnen, eine einfache Funktion für grundlegende Python-Berechnungen zu erstellen. So etwas in deinem .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

Wenn Sie weiterführende Berechnungen durchführen möchten, können Sie die folgende Methode verwenden, mit der alle Funktionen des mathModuls importiert werden. (siehe hier für mehr Infos)

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

(Hinweis: Da Python eine Programmiersprache ist, können einige Dinge seltsam erscheinen, z. B. **für Potenzen von und %für Modulo.)

Alternativ können Sie ein Python-Skript erstellen calc,

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

Platzieren Sie es in einem Verzeichnis, das in der PATHVariablen enthalten ist, und setzen Sie das ausführbare Flag, um denselben calcBefehl wie oben zu erhalten (es ist nicht erforderlich, eine Bash-Funktion zu erstellen, um ein Python-Skript auszuführen).

Wenn Sie eine reine Bash-Methode wünschen, verwenden Sie die Antwort von steeldriver. Diese Antwort ist nur dann wirklich nützlich, wenn Sie die erweiterten Funktionen (z. B. von math) benötigen , da Python im Vergleich zu Bash relativ langsam ist.

Ich bin mir nicht sicher, ob dies Ihre "Umstellung auf Python, das kann es, und ich möchte es nicht so." Beachten Sie, dass Sie die interaktive Eingabeaufforderung nicht eingeben müssen und das Ergebnis in Bash verfügbar ist, sodass diese Antwort (zumindest für mich) gültig zu sein scheint.

Verwenden Sie das Paket gcalccmdfrom gnome-calculator(> = 13.04) oder gcalctool(<13.04). Ich denke, das Paket ist standardmäßig installiert

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

Hier ist ein schnelles Shell-Skript dafür:

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

Speichern Sie dies als "c", fügen Sie es irgendwo in Ihren Pfad ein (z. B. / bin) und markieren Sie es als ausführbar.

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

Von nun an können Sie Berechnungen im Terminal wie folgt ausführen:

$ c 10000-9000
1000

Hier ist eine Modifikation des entsprechenden Teils von /etc/bash.bashrc(unter Ubuntu 10.04), die den command_not_foundHandler so modifiziert , dass der Ausdrucksauswerter der Shell ausgeführt wird, wenn das erste Zeichen des unbekannten Befehls eine Zahl oder -oder ist +.

Auf diese Weise können Sie jede beliebige Shell-Arithmetik ausführen. Eine Liste der arithmetischen Operatoren finden Sie unter http://www.gnu.org/software/bash/manual/bashref.html#Shell-Arithmetic .

Beachten Sie, dass Sie, wenn der Ausdruck, den Sie auswerten möchten, ein a enthält *, das *mit \oder die Anführungszeichen in Anführungszeichen setzen müssen, da die Shell die Dateinamenerweiterung vornimmt, bevor Sie entscheiden, welcher Befehl ausgeführt werden soll. Gleiches gilt für andere Betreiber wie >>.

Setzen Sie diese in Ihre ~/.bashrc, geben Sie . ~/.bashrcund probieren Sie es aus.

# 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

Beispielausgabe: (Ich schreibe ctaeinen Tippfehler, um zu testen, ob unser neuer command_not_found-Handler weiterhin versucht, nach unbekannten Befehlen zu suchen.)

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

Eine andere Lösung, die ich hier nicht gesehen habe, ist Qalculate (qalc) .

sudo apt-get install qalc

für die CLI-Version,

sudo apt-get install qalculate-gtk

für die GUI.

Es hat eine Reihe von Funktionen wie:

• Unterstützung für Einheiten : zB20 m / s * 12 h = 864 kilom
• Einbau- Konstanten wie pi, e, c,avogadro
• viele eingebaute in Funktionen : zB sin(pi) = 0, gamma(4) = 6, 5! = 120,log(1024, 2) = 10
• Einheitenumrechnung, zB:

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

• symbolische Berechnung , z(x + y)^2 = x^2 + 2xy + y^2
• Integration, zum Beispiel integrate 3*x^2 = x^3,diff sin(x), pi
• Die eingebaute Hilfe, zum Beispiel help convert,help integrate
• Tab Vervollständigung von Befehlen
• alles übersetzt, zum Beispiel mein System in Niederländisch ist, so kann ich beide schreiben factorial(5)und faculteit(5).
• und mehr...

Sie sagen, Sie möchten es ohne Präfixe verwenden, nun ... Sie können es mit einem Präfix verwenden:

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

sowie es als Antwort ausführen.

dc! Es ist Teil von coreutils, daher ist es unter OS X, Ubuntu und so ziemlich ALLEN anderen Betriebssystemen installiert. Es ist ein RPN-Rechner, wenn Sie diese also nicht mögen, ist es nichts für Sie.

Die grundlegenden Befehle lauten wie folgt: (Die Manpage hat die gesamte Syntax, die ich nicht angegeben habe. Potenzierung, wer?)

Sie brauchen nur Leerzeichen zwischen Zahlen. Sie werden in allen anderen Fällen ignoriert.

Wenn Sie eine Zahl eingeben, wird sie an die Spitze des Stapels verschoben.

+ 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

Ich benutze Octave für solche Dinge: http://www.gnu.org/software/octave/

Es ist so ziemlich ein Matlab-Klon (entschuldigt, wenn dies eine übermäßige Vereinfachung ist), der im Terminal durch Eingabe von Octave verwendet werden kann. Installieren Sie sudo apt-get install octave

Es ist nicht ganz das, was Sie wollen, aber ich dachte, ich würde es als Alternative zu Python hinzufügen.

Anwendungsbeispiel:

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

Ich mag wcalc sehr. Es ist ein wissenschaftlicher Kommandozeilenrechner. Einfach im Ubuntu Software Center zu finden oder einfach apt-get verwenden.

sudo apt-get install wcalc

Es akzeptiert Kommandozeilenargumente und hat den "Shell" -Modus:

# 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

Und wenn sich jemand wie ich im Ingenieurwesen befindet, können Sie GNU Octave nutzen. Es kann alles Mögliche tun, grafisch darstellen und gleichzeitig Gleichungen lösen. Außerdem ist es eine kostenlose Alternative zu Matlab

Ein einfacher Weg ist, Python aufzurufen.

Beispiel:

>  python -c 'print 10000-9000'

Was ich gefunden habe, ist, ich kann expr, bc oder eingebauten Shell-Optionen nicht vertrauen. Daher habe ich Perl verwendet, das normalerweise in * Linux-Distributionen installiert ist

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

Die obige Berechnung subtrahiert $ VAL1 von $ VAL2 und gibt ohne Dezimalstellen aus (0f)

Die Verwendung von Perl bietet folgende Vorteile: (Einzelheiten zu den Vor- und Nachteilen finden Sie hier )

• Bessere Fehlererfassung (Division durch 0 stoppt die Berechnung nicht)
• Kann Formeln in einer Konfigurationsdatei bereitstellen. Mit komplexem Regex müssen Sie nicht entkommen

Sie können Ihrer .bashrc-Datei folgende Funktion hinzufügen:

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

Beachten Sie, dass die -lFlagge sehr wichtig ist. Ohne sie Verwendung bcgibt 5 / 2 = 2.

Wie oben erwähnt, können Berechnungen mit dem =Vorzeichen vor der Formel durchgeführt werden.

Sie können auch awk verwenden , um einige arithmetische Berechnungen am Terminal durchzuführen.

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

benutze den "bc" Befehl und dann kannst du rechnen

Beispiel

[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

Zur Verwendung bcohne Garantiehinweis in das Terminal schreibenbc -q

Beispiel

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

Sie können bind und bash C-aund verwenden C-e, um die Ausgabe zu steuern. Führen Sie dies beispielsweise in Ihrer Shell aus:

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

Geben Sie nun eine arithmetische Operation wie 10 + 15 ein und drücken Sie Ctrl+ J:

$ echo $(( 10 + 15 )) 
25

Du wirst das bekommen. Nun, wie geht das?

• bind Dieser Befehl ändert die Bindung Ihrer Bash wie Tastenkombinationen.
• \C-j Dies ist die Bash-Entsprechung zu Strg + J. Dies ist die Tastenkombination, die wir unserem Befehl hinzufügen möchten.
• \C-a Dies bringt uns zum Anfang der Linie.
• echo $((das schreibt echo $((am anfang.
• \C-e bringt uns ans Ende der Linie
• )) schließt unsere vorherige Klammer
• \C-m Dies entspricht der Return-Taste.

Sie können dies in Ihre ~/.inputrcDatei schreiben :

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

Natürlich gelten auch die anderen Antworten! Nur ein bisschen optimiert:

• 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"
• irgendwelche anderen?

Sie können Strg + J nach Belieben ändern, aber denken Sie daran, es nicht für etwas zu ändern, das bereits eine Bindung hat;).

Ressource:

• Gibt es eine Möglichkeit, bash so zu konfigurieren, dass immer eine Seitenausgabe erfolgt?

In der Vergangenheit habe ich wcalcein kleines Programm namens verwendet e, nach dem man kaum googeln kann. Dazu verwende ich ein Python-Skript, das einige Funktionen ewie die eckigen Klammern verwendet. wcalcist immer noch nett, weil es willkürliche Präzision und Einheitenumrechnung kann, aber ich benutze diese Funktionen fast nie.

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

So verwenden Sie es (vorausgesetzt, das Skript wurde gespeichert eund irgendwo im $PATH):

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

Es gibt nur einen Schritt, um genau das zu erreichen, was Sie wollen. Alles, was Sie tun müssen, ist die shellfür Ihr Konto auf /bin/bc.

Sie können auch die printf eingebaute Shell verwenden, um arithmetische Berechnungen am Terminal durchzuführen.

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

Beispiel:

$ printf "$(expr 10000 + 9000)\n"
19000
$ printf "$(expr 10000 - 9000)\n"
1000

Sie können den Python-Interpreter zur Berechnung verwenden. Hier ist ein Tutorial, wie das geht .

Python 2 und Python 3 werden standardmäßig in Ubuntu installiert.

$ 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

Erstellen Sie einen Terminalrechner

Fügen Sie Folgendes in Ihre .bashrc-Datei ein

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

Oder führen Sie es an der Shell-Eingabeaufforderung aus. Jetzt funktioniert "calc" aus der Shell wie folgt:

$ calc 3+45
   48

Alle Funktionen mit einem "(" oder ")" müssen in Anführungszeichen gesetzt werden.