Ubuntu için herhangi bir komut satırı hesaplayıcısı?

Başka herhangi bir ek ön ek ve son ek olmadan terminalde hesaplamalar yapabilen bir Hesap Makinesi arıyorum.

Örneğin: Terminalde 10000-9000 gibi bir şey yazdıysam cevap 1000 olmalı.

Bir kez daha söylüyorum, sadece herhangi bir karakter eklenmeden terminalde hızlı bir hesap makinesine ihtiyacım var. Python'a geçersem, bunu yapabilir, ancak böyle bir şey istemiyorum biliyorum.

Bash Aritmetik

Başka bir olası çözüm de Bash'in yerleşik aritmetiği için basit bir fonksiyon eklemek. Bunu .bashrcdenemek için dosyanıza ekleyin :

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

Şimdi, $((...))artık gerek yok, sadece =yeterince doğal görünüyor.

Değiştirme

Daha hızlı olmak istiyorsanız başka bir şey: pile +ve xile yerini değiştirebilirsiniz *. Bunun için çalışacak:

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

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

Artık ihtiyacın bile Shiftyok, tek şey = aritmetiğin önünde.

Onaltılık çıkış

İstenirse çıktı hem ondalık hem de onaltılık olarak görüntülenebilir. ( Not : xikamesi kullanmak 0x...hex sözdizimi ile çakışacaktır )

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

Örnek:

$ = 16 + 0x10
272 (0x110)

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

kullanma bc

Biraz daha gelişmiş hesaplamalar istiyorsanız, bunu istediğiniz bcgibi yönlendirebilirsiniz:

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

Sağlanan işlevler bcaşağıdaki gibidir (ve bulunabilir 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.

Ayrıca destekler if, for, whileve bunu isteseydi daha iyi olabilir, eğer olsa bir programlama dili gibi değişkenler bir dosyaya yazmak için.

Bunun yerine pve xişlev / değişken adlarında olacağını unutmayın . Sadece değiştirmeleri çıkarmak daha iyi olabilir.

kullanma gcalccmd

İşlev çağrısını gcalccmd(from gnome-calculator) şöyle yapabilirsiniz:

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

Mevcut işlevler (düz alınması gibi kaynak kodu ), ==eşdeğer işlevleri belirtmektedir:

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

Basit bir tamsayı aritmetiğini doğal olarak bash içerisinde ((...))sözdizimini kullanarak yapabilirsiniz , örn.

$ echo $((10000-9000))
1000

bcStandart girişte aritmetik ifadeleri kabul edebilen hesap makinesi de vardır.

$ echo "10000-9000" | bc
1000

bcProgram aynı zamanda kayar nokta aritmetik yapabilirsiniz

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

Kullanabilirsiniz calc. Varsayılan olarak yüklenmez, ancak aşağıdaki komutu kullanarak hızlı bir şekilde kurabilirsiniz:

sudo apt-get install apcalc

Kurduktan sonra istediğiniz herhangi bir hesaplama yapabilirsiniz:

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

Daha fazla bilgi için man sayfasını görüntüleyin.

Ne yazık ki, bunu yapmanın "kolay" bir yolu yoktur. Aksine çünkü komut satırında interaktif piton arayüzü, iyi gerekenler için uygundur olan apcalc\, pythonolduğu dahil Ubuntu. bcYine de dahil olup olmadığından emin değilim , ancak, python bu şeyler için eller aşağı favori.

Sadece etkileşimli pythonarayüzü komut satırından çalıştırabilir ve sonra bu şekilde matematik yapabilirsiniz. Bunu hesap makinen olarak kullanabilirsin.

Bunu yapmak için, terminali açın, yazın pythonve ardından Enterdüğmesine basın.

Ardından gösterir piton isteminde, daki matematik yazabilirsiniz. Örneğin, 10000 - 9000. Bir sonraki satır çıktısı sonuçtur.

Yine de, terminale yüklediğiniz ve bunu yapabileceğiniz bir şey olsa ...

10000 - 9000 ABD Doları
1000
$

... o zaman hayır, bunu sadece terminalde başka hiçbir şey olmadan yapmanın bir yolu yok , çünkü Bash böyle sayısal argümanlarla ilgilenmiyor.

Temel Python hesaplamaları için basit bir fonksiyon oluşturmanızı tavsiye ederim. Senin içinde böyle bir şey .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

Daha gelişmiş bir matematik yapmak istiyorsanız, mathmodülün tüm fonksiyonlarını içe aktaran aşağıdakileri kullanabilirsiniz . ( daha fazla bilgi için buraya bakınız )

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

(Not: Python bir programlama dili olduğundan, bazı şeyler garip gelebilir, örneğin modulo **ve güçleri %için)

Alternatif olarak, bir Python betiği oluşturabilirsiniz calc,

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

PATHdeğişkene dahil olan bir dizine yerleştirin ve calcyukarıdaki ile aynı komutu almak için yürütülebilir bayrağını ayarlayın (bir Python betiğini çalıştırmak için Bash işlevi oluşturmaya gerek yoktur).

Saf Bash'te bir yöntem istiyorsanız, steeldriver'ın cevabını kullanın. Bu cevap sadece mathPython Bash'e kıyasla nispeten yavaş olduğundan , daha gelişmiş fonksiyonlara (yani dan ) ihtiyacınız varsa gerçekten faydalıdır .

Bu, "python'a geçiş yap, bunu yapabilir ve böyle bir şekilde istemiyorum." not edin, ancak etkileşimli bilgi istemi girmeniz gerekmez ve sonuç Bash'de erişilebilir durumdadır, bu nedenle bu cevap geçerli görünür (en azından benim için).

Kullan gcalccmddan gnome-calculator(> = 13.04) ya da gcalctool(<13,04) paketinde. Paketin varsayılan olarak yüklendiğini düşünüyorum

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

İşte bunun için hızlı bir kabuk betiği:

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

Bunu "c" olarak kaydedin, sonra yolunuzda bir yere koyun (/ bin gibi), sonra çalıştırılabilir olarak işaretleyin.

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

Bundan böyle, terminaldeki hesaplamaları şöyle yapabilirsiniz:

$ c 10000-9000
1000

İşte uygun bölümüne bir değişiklik var /etc/bash.bashrcdeğiştirir ki (Ubuntu 10.04 üzerine) command_not_foundbilinmeyen komutunun ilk karakteri bir sayı veya eğer kabuk ifade değerlendirici çalıştırmak için işleyici -veya +.

Bu şekilde herhangi bir kabuk aritmetiği yapabileceksiniz; aritmetik operatörlerin bir listesi için bkz. http://www.gnu.org/software/bash/manual/bashref.html#Shell-Arithmetic .

Değerlendirmek istediğiniz ifade bir içeriyorsa *, hangi komutun çalıştırılacağına karar vermeden önce kabuk dosya adı genişletme işlemi yapacağından , *ile \veya tırnak işaretlerini eklemeniz gerekeceğini unutmayın. Gibi diğer operatörler için aynı şey >>.

Bunu içine koy ~/.bashrc, sonra da yaz . ~/.bashrcve dene.

# 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

Örnek çıktı: ( ctaYeni komut_not_found işleyicimizin hala bilinmeyen komutları aramaya çalışacağını test etmek için bir yazım hatası yapıyorum ).

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

Burada bahsetmediğim bir başka çözüm de Qalculate (qalc) .

sudo apt-get install qalc

CLI versiyonu için,

sudo apt-get install qalculate-gtk

GUI için.

Gibi bir dizi özellik vardır:

• birimler için destek : örneğin20 m / s * 12 h = 864 kilom
• Yerleşik sabitler gibi pi, e, c,avogadro
• Birçok yerleşik işlevleri : örneğin sin(pi) = 0, gamma(4) = 6, 5! = 120,log(1024, 2) = 10
• birim dönüştürme, örneğin:

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

• sembolik hesaplama , örneğin(x + y)^2 = x^2 + 2xy + y^2
• entegrasyonu, örneğin integrate 3*x^2 = x^3,diff sin(x), pi
• Yerleşik yardım, örneğin help convert,help integrate
• komutların sekmesi tamamlandı
• her şey benim sistem Hollandaca olduğunu örn çevrilmiştir, bu yüzden hem yazabilir factorial(5)ve faculteit(5).
• ve dahası...

Önek olmadan kullanmak istediğinizi söylüyorsunuz, peki ... bir önekle kullanabilirsiniz:

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

repl olarak çalıştırmak gibi.

dc! Bu çekirdek çekirdeklerin bir parçası, bu yüzden OS X, Ubuntu ve hemen hemen her şeyde yüklü. Bu bir RPN hesaplayıcısı, eğer beğenmiyorsanız, sizin için değil.

Çok temel komutlar aşağıdaki gibidir (manpage, dahil etmediğim tüm sözdizimine sahiptir. Üstelik, herkes?)

Sadece sayılar arasında boşluklara ihtiyacınız var. Diğer tüm durumlarda dikkate alınmazlar.

Bir sayı yazmak, onu yığının üstüne doğru iter.

+ 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

Bu tür bir şey için Octave kullanıyorum: http://www.gnu.org/software/octave/

Terminalde oktav yazarak kullanılabilecek bir matlab klonu (bunun aşırı basitleştirilmesi durumunda özür dileriz). Sudo apt-get install oktavını kurun

İstediğiniz tam olarak bu değil ama python'a alternatif olarak ekleyeceğimi düşündüm.

Örnek kullanım:

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

WCCC'yi çok seviyorum. Bu bir komut satırı bilimsel hesap makinesi. Ubuntu Yazılım Merkezinde kolayca bulabilir veya apt-get komutunu kullanabilirsiniz.

sudo apt-get install wcalc

Komut satırı argümanlarını kabul eder ve "kabuk" moduna sahiptir:

# 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

Ve eğer biri benim gibi mühendislik yapıyorsa, benim gibi, GNU Octave'ı kullanabilirsiniz. Her türlü şeyi yapabilir, grafik çizebilir, eşzamanlı denklemi çözebilir. Ayrıca Matlab'a ücretsiz bir alternatif

basit yol python çağırmaktır.

Örnek:

>  python -c 'print 10000-9000'

Bulduğum şey, expr, bc veya dahili Shell seçeneklerine güvenemem. Bu yüzden normalde * linux distro’ya kurulacak olan Perl’i kullandım.

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

Yukarıdaki hesaplama, $ VAL1'i $ VAL2'den çıkarır ve ondalık basamak içermez (0f)

Perl kullanmanın avantajı ( burada listelenen Artı ve eksilerin ayrıntıları )

• Daha iyi hata yakalama (0'a bölmek hesaplamayı durdurmaz)
• Bir yapılandırma dosyasında formüller sağlayabilir. Karmaşık regex kullanarak kaçmaya gerek yok

.Bashrc dosyanıza aşağıdaki işlevi ekleyebilirsiniz:

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

-lBayrağın çok önemli olduğunu unutmayın . Onsuz, kullanımı bcverir 5 / 2 = 2.

Yukarıda da belirtildiği gibi, hesaplamalar =formülün önündeki işaret kullanılarak yapılabilir .

Ayrıca terminal üzerinde bazı aritmetik hesaplamalar yapmak için awk kullanabilirsiniz.

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

"bc" komutunu kullanın ve sonra hesaplama yapabilirsiniz

örnek

[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

bcGaranti belgesi olmadan kullanmak için terminale yazınızbc -q

örnek

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

Bind ve bash tuşlarını C-ave C-eçıkışı kontrol etmek için kullanabilirsiniz . Örneğin, bunu kabuğunuzda çalıştırın:

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

Şimdi 10 + 15 gibi bir aritmetik işlem yazın ve Ctrl+ tuşuna basın J:

$ echo $(( 10 + 15 )) 
25

Bunu alacaksın. Şimdi nasıl yapılır?

• bind bu komut, kısayol tuşları gibi bash'ınızın bağını değiştirir.
• \C-j bu, Ctrl + J'ye bash değerine eşittir, komutumuza eklemek istediğimiz tuş birleşimi budur.
• \C-a bu bizi hattın başlangıcına götürür.
• echo $((Bu echo $((başında yazar .
• \C-e bizi çizginin sonuna götürüyor
• )) önceki parantezimizi kapattı
• \C-m Bu dönüş anahtarına eşdeğerdir.

Bunu ~/.inputrcdosyanıza yazabilirsiniz :

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

Elbette diğer cevaplar da geçerlidir! Sadece biraz tweaked:

• İSA'DAN önce: "\C-j": "\C-aecho " \C-e " | bc \C-m"
• apcalc: "\C-j": "\C-acacl \C-m"
• piton: "\C-j": "\C-apython3 -c "print( \C-e )" \C-m"
• herhangi diğerleri?

Ctrl + J'yi istediğiniz şekilde değiştirebilirsiniz, ancak hatırlayın, zaten bağlayıcı bir şey için değiştirmemeye çalışın;).

Kaynak:

• Bash'yi her zaman sayfa çıktısına göre yapılandırmanın bir yolu var mı?

Geçmişte kullanmıştım wcalcve bunun eiçin google'ı kullanmak oldukça imkansız olan küçük bir program kullandım . Şimdi bunu yapmak eiçin köşeli parantezlerin bazı özelliklerini kullanan bir python betiği kullanıyorum . wcalchala hoş, çünkü keyfi hassasiyet ve birim dönüşümü yapabiliyor, fakat neredeyse hiç bu özellikleri kullanmıyorum.

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

İşte nasıl kullanılacağı (betiğin olarak kaydedildiği eve bir yere konulduğu varsayılarak $PATH):

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

Tam olarak istediğinizi başarmanın bir adım yolu var. Yapmanız gereken tek şey shellhesabınızı için ayarlamak /bin/bc.

printf Terminalde aritmetik hesaplamalar yapmak için shell builtin'i de kullanabilirsiniz .

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

Örnek:

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

Python yorumlayıcısını hesaplama için kullanabilirsiniz. İşte bunun nasıl yapılacağı hakkında bir öğretici .

Python 2 ve python 3 varsayılan olarak Ubuntu'da kuruludur.

$ 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

Bir Terminal Hesap Makinesi Oluşturun

Aşağıdaki .bashrc dosyanıza koyun

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

Veya kabuk isteminde çalıştırın. Şimdi kabuktan "kalk" aşağıdaki şekilde çalışacaktır:

$ calc 3+45
   48

"(" Veya ")" işaretli tüm fonksiyonlar tırnak içine alınmalıdır.