Każdy kalkulator wiersza poleceń dla Ubuntu?

Szukam kalkulatora, który może wykonywać obliczenia w samym terminalu bez żadnych dodatkowych prefiksów i sufiksów.

Na przykład: jeśli wpiszesz w terminalu coś takiego jak 10000-9000, odpowiedź powinna pojawić się jako 1000.

Jeszcze raz mówię: potrzebuję tylko szybkiego kalkulatora w terminalu, bez żadnych znaków. Wiem, że jeśli przestawię się na Python, może to zrobić, ale nie chcę tego w taki sposób.

Arytmetyka Bash

Innym możliwym rozwiązaniem jest dodanie prostej funkcji do wbudowanej arytmetyki Bash. Umieść to w swoim .bashrcpliku, aby spróbować:

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

Więc teraz już nie potrzebujesz $((...)), =co wydaje się dość naturalne.

Zastąpienie

Inną rzeczą, jeśli chcesz być jeszcze szybciej: można je zastąpić pz +i xz *. To zadziała do tego:

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

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

Teraz już nawet nie potrzebujesz Shift, jedyne, co jest = przed arytmetyką.

Wyjście szesnastkowe

W razie potrzeby dane wyjściowe mogą być wyświetlane zarówno w systemie dziesiętnym, jak i szesnastkowym. ( Uwaga : użycie xpodstawienia spowoduje konflikt ze 0x...składnią szesnastkową)

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

Przykład:

$ = 16 + 0x10
272 (0x110)

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

Za pomocą bc

Jeśli chcesz nieco bardziej zaawansowanych obliczeń, możesz odpowiednio potokować bc:

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

Funkcje zapewniane przez bcsą następujące (i można je znaleźć w 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.

Wspiera on także if, for, whilei zmienne, takie jak język programowania ale jeśli może lepiej byłoby napisać do pliku jeśli chciałeś to.

Należy pamiętać, że będzie on zastąpić pi xw funkcji / nazw zmiennych. Lepiej po prostu usunąć zamienniki.

Za pomocą gcalccmd

Możesz także wykonać wywołanie funkcji gcalccmd(z gnome-calculator) w następujący sposób:

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

Dostępne funkcje wydają się być (wzięte bezpośrednio z kodu źródłowego ), co ==oznacza równoważne funkcje:

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

Możesz wykonać prostą arytmetykę liczb całkowitych w trybie bash przy użyciu ((...))składni, np

$ echo $((10000-9000))
1000

Istnieje również bckalkulator, który może przyjmować wyrażenia arytmetyczne na standardowym wejściu

$ echo "10000-9000" | bc
1000

bcProgram może zrobić arytmetyki zmiennoprzecinkowej oraz

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

Możesz użyć calc. Nie jest instalowany domyślnie, ale można go szybko zainstalować za pomocą następującego polecenia:

sudo apt-get install apcalc

Po zainstalowaniu możesz wykonać dowolne obliczenia:

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

Aby uzyskać więcej informacji, zobacz jego stronę podręcznika

Niestety nie ma „łatwiejszego” sposobu na zrobienie tego. Interaktywny interfejs python w wierszu poleceń jest najlepiej dostosowany do potrzeb, ponieważ w przeciwieństwie do apcalc\, pythonjest zawarty w Ubuntu. Nie jestem jednak pewien, czy bcnadal jest uwzględniony, jednak python jest ulubionym faworytem do tych rzeczy.

Możesz po prostu uruchomić interaktywny pythoninterfejs w wierszu poleceń, a następnie wykonać matematykę w ten sposób. Możesz użyć tego jako kalkulatora.

Aby to zrobić, otwórz terminal, wpisz python, a następnie naciśnij Enterprzycisk.

Następnie w wierszu Pythona, który przedstawia się, można wpisać matematyki. Na przykład 10000 - 9000. Wynik następnego wiersza jest wynikiem.

Jeśli masz na myśli coś, w którym po prostu ładujesz terminal i możesz to zrobić ...

10000–9000 USD
1000
$

... więc nie ma sposobu, aby to zrobić tylko w terminalu bez niczego innego, ponieważ Bash nie obsługuje takich argumentów liczbowych.

Radzę ci stworzyć prostą funkcję do podstawowych obliczeń Pythona. Coś takiego w twoim .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

Jeśli chcesz zrobić bardziej zaawansowaną matematykę, możesz użyć poniższej, która importuje wszystkie funkcje mathmodułu. (zobacz tutaj, aby uzyskać więcej informacji)

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

(Uwaga: Ponieważ Python jest językiem programowania, niektóre rzeczy mogą wydawać się dziwne, np. **Dla mocy i %modulo)

Alternatywnie możesz utworzyć skrypt w języku Python calc,

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

umieść go w katalogu zawartym w PATHzmiennej i ustaw jego flagę wykonywalną, aby uzyskać takie samo calcpolecenie jak powyżej (nie trzeba tworzyć funkcji Bash, aby uruchomić skrypt w języku Python).

Jeśli chcesz zastosować metodę w czystej wersji Bash, użyj odpowiedzi steeldriver. Ta odpowiedź jest naprawdę przydatna tylko wtedy, gdy potrzebujesz bardziej zaawansowanych funkcji (tj. Od math), ponieważ Python jest stosunkowo wolny w porównaniu z Bash.

Nie jestem pewien, czy to zepsuje „przejście na Python, może to zrobić i nie chcę tego w taki sposób”. Uwaga, ale nie trzeba wprowadzać interaktywnego monitu, a wynik jest dostępny w Bash, więc ta odpowiedź wydaje się poprawna (przynajmniej dla mnie).

Użyj pakietu gcalccmdfrom gnome-calculator(> = 13.04) lub gcalctool(<13.04). Myślę, że pakiet jest instalowany domyślnie

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

Oto szybki skrypt powłoki dla tego:

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

Zapisz to jako „c”, następnie umieść go gdzieś na swojej ścieżce (np. / Bin), a następnie oznacz go jako wykonywalny.

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

Od teraz możesz uruchamiać obliczenia w terminalu w następujący sposób:

$ c 10000-9000
1000

Oto modyfikacja odpowiedniej części /etc/bash.bashrc(w Ubuntu 10.04), która zmodyfikuje command_not_foundmoduł obsługi, aby uruchomić ewaluator wyrażeń powłoki, jeśli pierwszym znakiem nieznanego polecenia jest liczba lub -lub +.

W ten sposób będziesz mógł wykonać dowolną arytmetykę powłoki; zobacz http://www.gnu.org/software/bash/manual/bashref.html#Shell-Arithmetic, aby uzyskać listę operatorów arytmetycznych.

Zauważ, że jeśli wyrażenie chcesz ocenić zawiera *, trzeba zacytować *z \lub cytaty ponieważ powłoka zrobi rozszerzenie nazwy pliku, przed podjęciem decyzji, które polecenie do uruchomienia. To samo dotyczy innych operatorów, takich jak >>.

Włóż to do swojego ~/.bashrc, a następnie wpisz . ~/.bashrci wypróbuj.

# 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

Przykładowe dane wyjściowe: (Piszę cta, literówka, tylko po to, aby sprawdzić, czy nasz nowy moduł obsługi polecenia_nie_found nadal będzie szukał nieznanych poleceń).

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

Innym rozwiązaniem, o którym nie wspomniałem tutaj, jest Qalculate (qalc) .

sudo apt-get install qalc

dla wersji CLI,

sudo apt-get install qalculate-gtk

dla GUI.

Ma wiele funkcji, takich jak:

• obsługa jednostek : np20 m / s * 12 h = 864 kilom
• Wbudowany w stałych takich jak pi, e, c,avogadro
• wiele wbudowanych funkcji : np sin(pi) = 0, gamma(4) = 6, 5! = 120,log(1024, 2) = 10
• konwersja jednostek, np .:

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

• obliczenia symboliczne , np(x + y)^2 = x^2 + 2xy + y^2
• integracja, np integrate 3*x^2 = x^3,diff sin(x), pi
• wbudowaną pomoc, na przykład help convert,help integrate
• uzupełnianie poleceń tabulatorami
• wszystko jest przetłumaczone, np. mój system jest w języku niderlandzkim, więc mogę pisać zarówno, jak factorial(5)i faculteit(5).
• i więcej...

Mówisz, że chcesz go używać bez prefiksów, cóż ... możesz go używać z prefiksem:

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

a także uruchamianie go jako repl.

dc! Jest częścią coreutils, więc jest zainstalowany na OS X, Ubuntu i prawie WSZYSTKO. To kalkulator RPN, więc jeśli ci się nie podobają, to nie jest dla ciebie.

Bardzo podstawowe polecenia są następujące (manpage ma całą składnię, której nie uwzględniłem. Potęgowanie, ktoś?)

Potrzebujesz tylko spacji między liczbami. Są one ignorowane we wszystkich innych przypadkach.

Wpisanie liczby wypycha ją na górę stosu.

+ 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

Używam Octave do tego typu rzeczy: http://www.gnu.org/software/octave/

Jest to w zasadzie klon matlab (przeprasza, jeśli jest to nadmierne uproszczenie), którego można użyć w terminalu, wpisując oktawę. Zainstaluj sudo apt-get install octave

Nie jest to dokładnie to, czego chcesz, ale pomyślałem, że dodam go jako alternatywę dla Pythona.

Przykładowe użycie:

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

Bardzo lubię wcalc. To kalkulator naukowy z linii poleceń. Łatwo go znaleźć w Centrum oprogramowania Ubuntu lub po prostu użyj apt-get.

sudo apt-get install wcalc

Akceptuje argumenty wiersza poleceń, a także ma tryb „powłoki”:

# 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

A jeśli ktoś jest inżynierem, tak jak ja, możesz skorzystać z GNU Octave. Potrafi robić różne rzeczy, wykresy, rozwiązywanie równań. Plus to darmowa alternatywa dla Matlaba

Prostym sposobem jest wywołanie Pythona.

Przykład:

>  python -c 'print 10000-9000'

Odkryłem, że nie mogę ufać opcjom expr, bc lub wbudowanym Shell. Dlatego użyłem Perla, który normalnie byłby zainstalowany w dystrybucji * Linux

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

Powyższe obliczenia odejmują $ VAL1 od $ VAL2 i drukują bez miejsc dziesiętnych (0f)

Korzyści z korzystania z Perla to (szczegóły na temat zalet i wad wymienionych tutaj )

• Lepsze wychwytywanie błędów (dzielenie przez 0 nie zatrzyma obliczeń)
• Może dostarczyć formuły w pliku konfiguracyjnym. Nie trzeba uciekać przy użyciu złożonego wyrażenia regularnego

Możesz dodać następującą funkcję do swojego pliku .bashrc:

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

Pamiętaj, że -lflaga jest bardzo ważna. Bez tego użycie bcdaje 5 / 2 = 2.

Jak wspomniano powyżej, obliczenia można wykonać za pomocą =znaku przed wzorem.

Możesz także użyć awk, aby wykonać obliczenia arytmetyczne na terminalu,

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

użyj polecenia „bc”, a następnie możesz wykonać obliczenia

przykład

[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

Aby korzystać bcbez gwarancji, napisz w terminalubc -q

przykład

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

Możesz użyć bind i bash C-aoraz C-ekontrolować dane wyjściowe. Na przykład wykonaj to w swojej powłoce:

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

Teraz wpisz dowolną operację arytmetyczną, taką jak 10 + 15 i naciśnij Ctrl+ J:

$ echo $(( 10 + 15 )) 
25

Dostaniesz to. Jak to się robi?

• bind to polecenie zmienia wiązanie twojego basha, podobnie jak klawisze skrótów.
• \C-j to jest odpowiednik Ctrl + J, to jest kombinacja klawiszy, którą chcielibyśmy dodać do naszej komendy.
• \C-a zabiera nas to na początek linii.
• echo $((to pisze echo $((na początku.
• \C-e zabiera nas do końca linii
• )) zamyka nasz poprzedni nawias
• \C-m jest to odpowiednik klucza powrotu.

Możesz zapisać to w swoim ~/.inputrcpliku:

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

Oczywiście inne odpowiedzi też są poprawne! Właśnie poprawiłem trochę:

• pne: "\C-j": "\C-aecho " \C-e " | bc \C-m"
• apcalc: "\C-j": "\C-acacl \C-m"
• pyton: "\C-j": "\C-apython3 -c "print( \C-e )" \C-m"
• ktoś jeszcze?

Możesz zmienić Ctrl + J na cokolwiek zechcesz, ale pamiętaj, staraj się nie zmieniać tego na coś, co już ma powiązanie;).

Ratunek:

• Czy istnieje sposób skonfigurowania bash tak, aby zawsze wyświetlał strony?

W przeszłości korzystałem wcalcz małego programu, ektóry jest prawie niemożliwy do znalezienia w Google. Teraz używam do tego skryptu Pythona, który korzysta z niektórych funkcji, etakich jak nawiasy kwadratowe. wcalcjest nadal fajny, ponieważ potrafi wykonywać dowolną precyzję i konwersję jednostek, ale prawie nigdy nie używam tych funkcji.

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

Oto jak go użyć (zakładając, że skrypt został zapisany jako ei umieszczony gdzieś w $PATH):

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

Istnieje jeden krok, aby osiągnąć dokładnie to, czego chcesz. Wszystko, co musisz zrobić, to ustawić shelldla swojego konta na /bin/bc.

Możesz także użyć printf wbudowanej powłoki, aby wykonać obliczenia arytmetyczne na terminalu.

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

Przykład:

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

Do obliczeń można użyć interpretera python. Oto samouczek, jak to zrobić .

Python 2 i python 3 są domyślnie instalowane w Ubuntu.

$ 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

Utwórz kalkulator terminala

Umieść następujące elementy w pliku .bashrc

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

Lub uruchom go w wierszu poleceń powłoki. Teraz „calc” z powłoki będzie działał w następujący sposób:

$ calc 3+45
   48

Wszystkie funkcje ze znakiem „(” lub „)” muszą być ujęte w cudzysłów.