Ты можешь использовать calc, По умолчанию не устанавливается, но вы можете быстро установить его, используя следующую команду:

sudo apt-get install apcalc

После установки вы можете сделать любой расчет по вашему желанию:

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

Для получения дополнительной информации, смотрите его man-страницу

Вы можете сделать простую целочисленную арифметику в bash, используя ((...)) синтаксис, например

$ echo $((10000-9000))
1000

Также есть bc калькулятор, который может принимать арифметические выражения на стандартный ввод

$ echo "10000-9000" | bc
1000

bc Программа также может выполнять арифметику с плавающей запятой

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

К сожалению, нет более простого способа сделать это. Интерактивный интерфейс Python в командной строке лучше всего подходит для того, что вам нужно, потому что в отличие от apcalc\, python включен в Ubuntu. Я не уверен, если bc все еще включен, однако, питон является практическим фаворитом для этого материала.

Вы можете просто запустить интерактив python интерфейс в командной строке, а затем сделать математику таким образом. Вы можете использовать это как свой калькулятор.

Для этого вы открываете терминал, набираете python, затем нажмите кнопку Enter.

Затем в появившемся приглашении python вы можете ввести свою математику. Например, 10000 - 9000, Вывод следующей строки - результат.

Если вы имеете в виду, что-то, где вы просто загружаете терминал и можете сделать это...

10000 - 9000 долларов
1000
$

... тогда нет, нет способа сделать это только в терминале без чего-либо еще, потому что Bash не обрабатывает числовые аргументы, подобные этому.

Я бы посоветовал вам создать простую функцию для базовых вычислений Python. Как то так в вашем .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

Если вы хотите сделать более сложную математику, вы можете использовать следующий, который импортирует все math функции модуля. (см. здесь для получения дополнительной информации)

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

(Примечание: поскольку Python является языком программирования, некоторые вещи могут показаться странными, например, ** для полномочий и % по модулю)

В качестве альтернативы вы можете создать скрипт Python calc,

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

поместите его в каталог, включенный в PATH переменная и установите свой исполняемый флаг, чтобы получить то же самое calc команда, как указано выше (не нужно создавать функцию Bash для запуска скрипта Python).

Если вы хотите метод в чистом Bash, используйте ответ Steeldriver. Этот ответ действительно полезен, только если вам нужны более продвинутые функции (например, от math), так как Python относительно медленный по сравнению с Bash.

Я не уверен, что это сломает ваш "переход на python, он может это сделать, и я не хочу этого таким образом". обратите внимание, но вам не нужно вводить интерактивное приглашение, и результат доступен в Bash, поэтому этот ответ кажется верным (по крайней мере, мне).

Использовать gcalccmd от gnome-calculator (>=13.04) или gcalctool (<13.04) пакет. Я думаю, что пакет установлен по умолчанию

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

Другое решение, о котором я не упомянул, это Qalculate (qalc).

sudo apt-get install qalc

для версии CLI,

sudo apt-get install qalculate-gtk

для графического интерфейса.

Он имеет множество функций, таких как:

• поддержка юнитов: например 20 m / s * 12 h = 864 kilom
• встроенные константы, такие как pi, e, c, avogadro
• много встроенных функций: например sin(pi) = 0, gamma(4) = 6, 5! = 120, log(1024, 2) = 10
• перевод единиц, например:

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

• символьный расчет, например (x + y)^2 = x^2 + 2xy + y^2
• интеграция, например integrate 3*x^2 = x^3, diff sin(x), pi
• встроенная помощь, например help convert, help integrate
• завершение команд на вкладке
• все переведено, например, моя система на голландском, поэтому я могу написать как factorial(5) а также faculteit(5),
• и больше...

Вы говорите, что хотите использовать его без префиксов, ну... вы можете использовать его с префиксом:

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

а также запустить его как репл.

Вот быстрый скрипт для этого:

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

Сохраните его как "c", затем поместите его где-нибудь на вашем пути (например, /bin), затем отметьте его как исполняемый.

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

Теперь вы можете выполнять вычисления в терминале следующим образом:

$ c 10000-9000
1000

Вот модификация соответствующей части /etc/bash.bashrc (в Ubuntu 10.04), который изменит command_not_found обработчик для запуска средства оценки выражений оболочки, если первый символ неизвестной команды является числом или - или же +,

Вы сможете выполнить любую арифметику оболочки таким образом; см. http://www.gnu.org/software/bash/manual/bashref.html для получения списка арифметических операторов.

Обратите внимание, что если выражение, которое вы хотите оценить, содержит *, вам придется процитировать * с \ или кавычки, поскольку оболочка выполнит расширение имени файла, прежде чем решить, какую команду запустить. То же самое для других операторов, таких как >>,

Поместите это в свой ~/.bashrcзатем введите . ~/.bashrc и попробуй это.

# 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

Пример вывода: (Я печатаю cta, опечатка, просто чтобы проверить, что наш новый обработчик command_not_found все еще будет пытаться искать неизвестные команды).

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

dc! Он является частью coreutils, поэтому он установлен на OS X, Ubuntu и почти все остальное. Это калькулятор RPN, так что если он вам не нравится, он не для вас.

Очень простые команды: (man-страница имеет весь синтаксис, который я не включил. Расшифровка, кто-нибудь?)

Вам нужны только пробелы между числами. Они игнорируются во всех других случаях.

Ввод числа подталкивает его к вершине стека.

+ 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

Я использую Octave для такого рода вещей: http://www.gnu.org/software/octave/

Это в значительной степени клон matlab (извините, если это слишком упрощенно), который можно использовать в терминале, набрав октаву. Установить sudo apt-get установить октаву

Это не совсем то, что вы хотите, но я решил добавить его в качестве альтернативы Python.

Пример использования:

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

Мне очень нравится Wcalc. Это научный калькулятор командной строки. Легко найти в Ubuntu Software Center или просто использовать apt-get.

sudo apt-get install wcalc

Он принимает аргументы командной строки, а также имеет режим "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

И если кто-то, как и я, занимается разработкой, вы можете использовать GNU Octave. Он может делать все что угодно, строить графики, решать уравнения одновременно. Плюс это бесплатная альтернатива Matlab

Вы также можете использовать awk для выполнения некоторых арифметических вычислений на терминале,

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

Простой способ - вызвать Python.

Пример:

>  python -c 'print 10000-9000'

Вы можете добавить следующую функцию в ваш файл.bashrc:

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

Обратите внимание, что -l флаг очень важен. Без этого, использование bc дает 5 / 2 = 2,

Как было сказано выше, расчеты могут быть выполнены с использованием = знак перед формулой.

Я обнаружил, что я не могу доверять expr, bc или встроенным параметрам Shell. Поэтому я использовал Perl, который обычно устанавливается в дистрибутиве *linux

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

Приведенный выше расчет вычитает $VAL1 из $VAL2 и печатает без десятичных разрядов (0f)

Преимущество использования Perl (подробности о плюсах и минусах приведены здесь)

• Лучшее отслеживание ошибок (деление на 0 не остановит вычисления)
• Может предоставить формулы в конфигурационном файле. Не нужно убегать, используя сложное регулярное выражение

Используйте команду "BC", а затем вы можете сделать расчет

пример

[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

Использовать bc без гарантийного талона пиши в терминал bc -q

пример

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

В прошлом я использовал wcalc и маленькая программа под названием e это практически невозможно для Google. Теперь я использую скрипт Python для этого, который использует некоторые функции e как квадратные скобки. wcalc все еще хорош, потому что он может выполнять произвольную точность и преобразование единиц, но я почти никогда не использую эти функции.

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

Вот как это использовать (при условии, что скрипт был сохранен как e и положить где-то в $PATH):

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

Вы можете использовать bind и bash Ca и Ce для управления выводом. Например, выполните это в вашей оболочке:

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

Теперь введите любую арифметическую операцию, например 10 + 15, и нажмите Ctrl+J:

$ echo $(( 10 + 15 )) 
25

Вы получите это. Теперь, как это сделать?

• bind эта команда изменяет привязку вашего bash, как сочетания клавиш.
• \C-j это bash-эквивалент Ctrl + J, вот какую комбинацию клавиш мы хотели бы добавить в нашу команду.
• \C-a это приводит нас к началу линии.
• echo $(( это пишет echo $(( в начале.
• \C-e подводит нас к концу линии
• )) закрывает нашу предыдущую скобку
• \C-m это эквивалент возврата ключа.

Вы можете написать это в свой ~/.inputrc файл:

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

Конечно, другие ответы тоже действительны! Просто немного подправил:

• До нашей эры: "\C-j": "\C-aecho " \C-e " | bc \C-m"
• apcalc: "\C-j": "\C-acacl \C-m"
• питон: "\C-j": "\C-apython3 -c "print( \C-e )" \C-m"
• любые другие?

Вы можете изменить Ctrl + J на ​​все что угодно, но помните, старайтесь не менять его на то, что уже имеет привязку;).

Ресурс:

• Есть ли способ настроить bash, чтобы всегда вывод страницы?

Гений

Когда вам нужно что-то более мощное, чем bc. Например, Genius позволяет выполнять возведение в степень с рациональными (не целыми) показателями:

genius --exec='81^0.75'

печатает

27,0

awk встроен, поэтому я создал небольшую функцию-оболочку в моем ~/.bashrcфункции и будут использовать ее в будущих проектах. Вот как им пользоваться:

$ a=2.2; b=3.3

$ math c = $a / $b
$ echo $c
0.666667

$ math c = $a * $b
* not allowed, use x to multiply

$ math c = $a x $b
$ echo $c
7.26

$ math c = $a - $b
$ echo $c
-1.1

Вот функция:

math () {

    [[ $2 != "=" ]] && { echo "Second parm must be '='"; return 1; }

    # Declare arg as reference to argument provided (Bash 4.3 or greater)
    declare -n mathres=$1

    math_op="$4"    # '*' as parameter changes operator to 'aptfielout' and
                    # operand2 to 'aptfilein' so force 'x' instead.
    [[ $math_op == "aptfielout" ]] && \
        { echo "* not allowed, use x to multiply"; return 2;}
    [[ $math_op == "x" ]] && math_op="*"

    mathres=$(awk "BEGIN { print ($3 $math_op $5) }")

#    test=$(awk "BEGIN { print ($3 $math_op $5) }")
#    echo "1:$1 2:$2 3:$3 4:$4 5:$5 result=$test"

} # math

Вы также можете использовать printf Встроенная оболочка для выполнения арифметических вычислений на терминале.

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

Пример:

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

Вы можете использовать интерпретатор Python для расчета. Вот учебник о том, как это сделать.

Python 2 и python 3 установлены в 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

Создать калькулятор терминала

Поместите следующее в ваш файл.bashrc

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

Или запустите его в командной строке. Теперь "calc" из оболочки будет работать следующим образом:

$ calc 3+45
   48

Все функции с "(" или ")" должны быть заключены в кавычки.

Существует один шаг, чтобы выполнить именно то, что вы хотите. Все, что вам нужно сделать, это установить shell для вашего аккаунта в /bin/bc,