Az Ubuntu parancssori számológépe?

117

Olyan számológépet keresek, amely számításokat végezhet a terminálon anélkül, hogy további előtagokat és utótagokat tartalmazna.

Például: Ha a terminálon 10000-9000-et írtam be, akkor a válasz 1000-nek kell lennie.

Még egyszer azt mondom, szükségem van egy gyors számológépre a terminálon, anélkül, hogy bármilyen karaktert hozzáadnának. Tudom, hogy átváltok-e Pythonra, meg tudod csinálni, de nem akarom ilyen módon.

    
készlet rɑːdʒɑ 18.11.2013 03:37
forrás

23 válasz

73

Bash aritmetika

Egy másik lehetséges megoldás egy egyszerű funkció hozzáadása a Bash beépített aritmetikájához. Tegye ezt a.bashrc fájlba a következő próbálkozáshoz:

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

Tehát most már nem kell több$((...)) -ot, csak=, ami elég természetesnek tűnik.

cseréje

A másik dolog, ha még gyorsabb is lehet: cserélhetip -ra+ -al ésx -al* -al. Ehhez fog működni:

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

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

Most már nem kell Shift többé, az egyetlen dolog az az aritmetika előtt.

Hexadecimális kimenet

A kimenet mind decimális, mind hexadecimálisan megjeleníthető, ha szükséges. ( Megjegyzés :x helyettesítés ellentétes a0x... hex szintaxissal)

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

Példa:

$ = 16 + 0x10
272 (0x110)

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

bc

Ha kissé fejlettebb számításokat szeretne, akkorbc -ra csévélheti, így:

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

Abc által megadott függvények a következők (és megtalálható aman bc -ban):

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.

Ezenkívül támogatja aif, afor, awhile és a változók, mint a programozási nyelv, bár ha jobb lenne írni egy fájlt, ha azt akarod.

Ne feledje, hogy ap és ax helyettesítheti a függvény / változók nevét. Lehet, hogy csak eltávolítja a helyettesítő elemeket.

gcalccmd

Agcalccmd (gnome-calculator) függvényhívást is így teheti:

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

Úgy tűnik, hogy a rendelkezésre álló függvények (közvetlenül a forráskódból vannak) == egyenértékű függvényeket jelöl:

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()
    
válasz adott kiri 19.11.2013 10:33
forrás
89

A bash-ban a((...)) szintaxist használva egyszerűen egész számtani aritmetikát tehetsz, pl.

$ echo $((10000-9000))
1000

Van még abc számológép, amely elfogadhat aritmetikai kifejezéseket a standard bemeneten

$ echo "10000-9000" | bc
1000

Abc program lebegőpontos aritmetikai is lehet

$ echo "scale = 3; 0.1-0.09" | bc
.01
    
válasz adott steeldriver 18.11.2013 03:59
forrás
88

Használhatja a calc szolgáltatást. Alapértelmezés szerint nincs telepítve, de gyorsan telepítheti a következő parancsot:

sudo apt-get install apcalc

Miután telepítette, tetszőleges számításokat tehet:

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

További információkért tekintse meg man-page

    
válasz adott Radu Rădeanu 18.11.2013 10:16
forrás
30

Sajnos nincs "könnyebb" módja ennek. Az interaktív python-felület a parancssorban a legmegfelelőbb az Ön számára, mivel aapcalc \,python tartalmazza az Ubuntuban. Nem vagyok biztos benne, hogy abc szerepel benne, de a python a kedvenc kedvenc.

Az interaktívpython felületet futtathatja a parancssorban, majd végezze el a matematikát. Ezt a számológépet használhatja.

Ehhez nyissa meg a terminált, írja be apython parancsot, majd nyomja meg a Enter gombot.

Ezután a megjelenő Python-promptban beírhatja a matematikát. Például:10000 - 9000. A következő sor kimenete az eredmény.

Ha azonban valami olyat akarsz érteni, ahol csak betölted a terminált, és ezt teheted ...

$ 10000 - 9000
1000
$

... akkor nincs semmi módja a csak terminálnak semmi más nélkül, mert a Bash nem kezeli a numerikus argumentumokat.

    
válasz adott Thomas Ward 18.11.2013 03:40
forrás
23

Javaslom, hogy hozzon létre egy egyszerű függvényt az alapvető Python-számításokhoz. Valami ilyesmit a.bashrc -ban:

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

Ha fejlettebb matematikát szeretne, akkor a következőt használhatja, amely az összesmath modul funkcióját importálja. (további információért lásd itt )

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

(Megjegyzés: Mivel a Python egy programnyelv, néhány dolog furcsának tűnhet, például** for powers és% for modulo)

Alternatívaként létrehozhat egy Python szkriptet:calc,

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

helyezze aPATH változóban lévő könyvtárba, és állítsa be a végrehajtható zászlóját, hogy ugyanazt acalc parancsot kapja, mint a fenti (nincs szükség Bash függvény létrehozására Python script futtatásához).

Ha szeretne egy módszert a tiszta Bash-ban, akkor használja a Steeldriver válaszát. Ez a válasz csak nagyon előnyös, ha a fejlettebb funkciókra van szüksége (pl.math), mivel a Python viszonylag lassú a Bash-hoz képest.

Nem tudom, hogy ez megszakítja-e a "pythonra való átállást, és ezt én nem szeretném". de nem kell megadnia az interaktív promptot, és az eredmény elérhető a Bash-ban, így ez a válasz érvényes (legalábbis nekem).

    
válasz adott kiri 18.11.2013 09:45
forrás
21

Használja agcalccmd -otgnome-calculator (> = 13,04) vagygcalctool (< 13,04) csomagból. Szerintem a csomag alapértelmezés szerint telepítve van

% gcalccmd
> 2+3
5
> 3/2
1.5
> 3*2
6
> 2-3
−1
> 
    
válasz adott Flint 18.11.2013 04:12
forrás
10

Itt van egy gyors shell parancsfájl:

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

Mentse ezt "c" -ként, majd helyezze el valahol az elérési útjába (például / bin), majd jelölje meg a végrehajthatóvá.

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

Mostantól számításokat végezhet a terminálon:

$ c 10000-9000
1000
    
válasz adott user530873 18.11.2013 06:19
forrás
8

A/etc/bash.bashrc (Ubuntu 10.04-es verziójának) megfelelő részének módosítása, amely módosítja acommand_not_found kezelőt a shell kifejezésértékelőjének futtatásához, ha az ismeretlen parancs első karaktere egy szám vagy- vagy+.

Ezzel a módszerrel bármilyen shell-számtani műveletet elvégezhetsz; nézze meg az linket a számtani operátorok listájához.

Vegye figyelembe, hogy ha az értékelendő kifejezés egy* -ot tartalmaz, akkor a* -ot a\ -kal vagy idézőjelekkel kell idéznie, mivel a shell a filename kiterjesztését fogja csinálni, mielőtt eldönti, melyik parancsot futtatja. Ugyanaz a helyzet más operátorokra is, mint a>>.

Tegye ezt a~/.bashrc -ban, majd írja be a. ~/.bashrc parancsot, és próbálja ki.

# 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 [[  == [0-9+-]* ]]; then
           echo $(( $@ ))
        elif [ -x /usr/lib/command-not-found ]; then
           /usr/bin/python /usr/lib/command-not-found -- 
           return $?
        elif [ -x /usr/share/command-not-found ]; then
           /usr/bin/python /usr/share/command-not-found -- 
           return $?
        else
           return 127
        fi
    }
fi

Minta kimenet: (cta -ot írok be egy typo-nak, csak annak tesztelésére, hogy az új command_not_found handler továbbra is megpróbál keresni ismeretlen parancsokat).

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
    
válasz adott Mark Plotnick 18.11.2013 18:05
forrás
8

Egy másik megoldás, amelyet még nem láttam itt: Qalculate (qalc) .

sudo apt-get install qalc

a CLI verzióhoz

sudo apt-get install qalculate-gtk

a GUI számára.

Számos funkcióval rendelkezik, mint például:

  • támogatás egységekhez : pl. 20 m / s * 12 h = 864 kilom
  • beépített állandók , mintpi,e,c,avogadro
  • sok beépített funkció : pl. sin(pi) = 0,gamma(4) = 6,5! = 120,log(1024, 2) = 10
  • egység konverziója, például:
  

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

  • szimbolikus számítás , pl. (x + y)^2 = x^2 + 2xy + y^2
  • integráció, pl. integrate 3*x^2 = x^3,diff sin(x), pi
  • beépített segítség, pl. help convert,help integrate
  • a parancsok befejezése
  • mindent lefordítanak, pl. a rendszerem holland nyelven van, így mind afactorial(5), mind afaculteit(5) -ot írhatom.
  • és így tovább ...

Azt mondod, hogy előtag nélkül szeretnéd használni, jól ... használhatod egy előtaggal:

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

, valamint repl parancsként történő futtatását.

    
válasz adott JW. 26.11.2013 11:46
forrás
7

dc! Ez része a coreutilsnak, ezért telepítve van OS X, Ubuntu, és nagyon sok minden más. Ez egy RPN számológép, tehát ha nem tetszik nekik, akkor nem az Ön számára.

Nagyon alaptartozó parancsok a következők (manpage minden olyan szintaxist, amelyet nem vettem fel.) Exponentiation, bárki?)

Szükség van a számok közötti számokra. Minden más esetben figyelmen kívül hagyják őket.

Egy szám beírása a köteg tetejére tolja.

+ 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
    
válasz adott Yet Another User 18.11.2013 21:07
forrás
5

Az Octave-t ilyen típusú dolgokra használom: link

Nagyjából egy matlab-klón (bocsánatkérés, ha ez egy túlzott egyszerűsítés), amelyet a terminálban az oktáv beírásával lehet használni. Telepítse a sudo apt-get install oktávot

Ez nem egészen az, amit akarsz, de azt gondoltam, hogy hozzáadhatom a python alternatívájaként.

Példahasználat:

~ $ octave
octave:1> 9000 - 8000
ans =  1000
octave:2> 
    
válasz adott Andy T 18.11.2013 15:39
forrás
5

Nagyon szeretem a wcalc-t. Ez egy parancssori tudományos számológép. Könnyű megtalálni az Ubuntu Software Center-ben, vagy csak az apt-get segítségével.

sudo apt-get install wcalc

Elfogadja a parancssori argumentumokat, valamint a "shell" módot:

# 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

És ha valaki olyan mérnöki munkát végez, mint én, használhatja a GNU Octave-t. Mindenféle dolgot meg tud csinálni, ábrázolva, egyidejű egyenlet megoldásával. Plusz ez egy ingyenes alternatíva a Matlab-hez

    
válasz adott Sergiy Kolodyazhnyy 22.09.2014 11:58
forrás
4

egyszerű módja a python hívása.

Példa:

>  python -c 'print 10000-9000'
    
válasz adott user2327875 20.11.2013 14:35
forrás
3

Amit találtam, nem bízhatok expr, bc vagy beépített Shell opcióknál. Ezért használtam a Perl-et, amelyet általában a * linux distro-ban telepítettem

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

A fenti számítás kivonja a $ VAL1 értéket a $ VAL2 értékből és a tizedeshelyekkel (0f)

Előnyök a Perl használatával (részletek a Előnyök és ellenérvek listája itt )

  • Jobb hibakeresés (a 0-al osztás nem állítja le a számítást)
  • Képleteket adhat egy konfigurációs fájlban. Nem szükséges elkerülni a komplex regex használatát
válasz adott diaryfolio 18.11.2013 11:14
forrás
3

A következő funkciót hozzáadhatja a .bashrc fájlhoz:

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

A-l flag nagyon fontos. Enélkül abc használata5 / 2 = 2.

A fent leírt módon a számítások a= jel használatával végezhetők el a képlet előtt.

    
válasz adott vdm 19.11.2013 14:51
forrás
3

A awk használatával is használható a terminál számtani számítása,

echo 10000 9000 | awk '{print -}'
1000
echo 10000 9000 | awk '{print +}'
19000
echo 10000 9000 | awk '{print /}'
1.11111
echo 10000 9000 | awk '{print *}'
90000000
    
válasz adott Avinash Raj 05.01.2014 19:41
forrás
2

használja a "bc" parancsot, majd u végezhet számításokat

példa

[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

Abc használatához a jótállási jegyzet nélkül írja be abc -q

terminálba

Például

[root@vaibhav ~]# bc -q
10+2
12
    
válasz adott Vaibhav Jain 19.11.2013 08:18
forrás
2

A kimenet vezérlésére a bind és bash C-a és C-e állományokat használhatja. Például hajtsa végre ezt a héjban:

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

Most írja be az összes olyan számtani műveletet, mint a 10 + 15, és nyomja meg a Ctrl + J

$ echo $(( 10 + 15 )) 
25

Ezt megkapja. Most, hogyan történik ez?

  • bind ez a parancs megváltoztatja a bash parancsot, például a gyorsbillentyűket.
  • \C-j Ez a bash a Ctrl + J-vel egyenértékű, ez az a kombináció, amit hozzá szeretnénk adni a parancsunkhoz.
  • \C-a ez a sor elejére visz.
  • echo $(( ezt írjaecho $(( -ra a kezdetnél.
  • \C-e elvezet minket a vonal végéhez
  • A (z))) bezárja korábbi zárójelzéseket
  • \C-m ez a visszatérési kulcsnak felel meg.

Ezt a~/.inputrc fájlba írhatja:

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

Természetesen a többi válasz is érvényes! Csak csípett egy kicsit:

  • 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"
  • mások?

A Ctrl + J-t tetszés szerint változtathatod meg, de ne felejtsd el, ne változtasd meg valamit, ami már kötelező;).

Resource:

válasz adott Braiam 20.11.2013 01:55
forrás
2

A múltban használtam a wcalc programot és egy kis programot, amelye -nak nevezhető. google for. Most használok egy python parancsfájlt, ami ae néhány funkcióját használja, mint a szögletes zárójelek. wcalc még mindig szép, mert tetszőleges pontosságot és mértékegységet tud konvertálni, de szinte soha nem használom ezeket a szolgáltatásokat.

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

A következőképpen kell használni (feltételezve, hogy a szkripte -ként lett elmentve, és valahol a$PATH -ban van elhelyezve):

$ e e**[pi*1i]
-1.0
$ e hex[10**3]
0x3e8
$ e "[0o400+3]&0xff" # need quotes because of '&'
3
    
válasz adott jpkotta 18.11.2013 17:20
forrás
0

Van egy lépés az eléréséhez, amit pontosan akarsz. Mindössze annyit kell tennie, hogy fiókjánakshell -át/bin/bc -ra állítja be.

    
válasz adott bizzyunderscore 21.11.2013 02:29
forrás
0

Aprintf beépített shell-ot is használhatja a terminál számtani kiszámításához.

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

Példa:

$ printf "$(expr 10000 + 9000)\n"
19000
$ printf "$(expr 10000 - 9000)\n"
1000
    
válasz adott Avinash Raj 16.04.2014 15:26
forrás
0

Használhatja a python interpretert számításhoz. Itt van egy bemutató .

A Python 2 és a python 3 alapértelmezés szerint Ubuntuban vannak telepítve.

$ 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
    
válasz adott noone 27.08.2017 12:08
forrás
0

Terminálkalkulátor létrehozása

Tegye a következőket a .bashrc fájlba

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

Vagy futtasd a parancssorba. Most   A "calc" a shellből a következőképpen működik:

$ calc 3+45
   48

Minden "(" vagy ")" funkcióval ellátott funkciót mellékelni kell   idézetekben.

    
válasz adott Vishnu N K 31.01.2014 18:17
forrás