Un calculateur en ligne de commande pour Ubuntu?
Je cherche une calculatrice pouvant effectuer des calculs dans le terminal lui-même sans autre préfixe ni suffixe supplémentaire.
Par exemple: si je saisis quelque chose comme 10000-9000 dans le terminal, la réponse devrait être 1000.
Encore une fois, je dis qu'il me faut une calculatrice rapide dans le terminal, sans aucun caractère ajouté. Je sais que si je passe à Python, cela peut le faire mais je ne le veux pas de cette façon.
Arithmétique Bash
Une autre solution possible consiste à ajouter une fonction simple pour l'arithmétique intégrée de Bash. Mettez ceci dans votre fichier .bashrc pour essayer:
=() {
echo "$(($@))"
}
Alors maintenant, vous n'avez même plus besoin de $((...)), juste de =, ce qui semble assez naturel.
Remplacement
Une autre chose si vous voulez être encore plus rapide: vous pouvez le faire remplacer ppar + et xpar *. Cela fonctionnera pour cela:
=() {
local IFS=' '
local calc="${*//p/+}"
calc="${calc//x/*}"
echo "$(($calc))"
}
= 5 x 5 # Returns 25
= 50p25 # Returns 75
Maintenant, vous n'avez même pas besoin Shift plus, la seule chose est = en face de l'arithmétique.
Sortie hexadécimale
La sortie peut être affichée en décimal et en hexadécimal, si vous le souhaitez. ( Remarque : l'utilisation de la substitution xentrera en conflit avec la syntaxe 0x... hex.
=() {
local answer="$(($@))"
printf '%d (%#x)\n' "$answer" "$answer"
}
Exemple:
$ = 16 + 0x10
272 (0x110)
$ = 16**3 + 16**4
69632 (0x11000)
Utilisation de bcname__
Si vous voulez des calculs légèrement plus avancés, vous pouvez le diriger vers bccomme ceci:
=() {
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)
Les fonctions fournies par bcsont les suivantes (et peuvent être trouvées à partir de 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.
Il supporte également ifname__, forname__, whileet des variables comme un langage de programmation, mais s'il est préférable d'écrire dans un fichier si vous le souhaitiez.
N'oubliez pas qu'il remplacera pet xdans les noms de fonction/variable. Il peut être préférable de simplement supprimer les remplaçants.
Utilisation de gcalccmdname__
Vous pouvez également définir l'appel de fonction gcalccmd(à partir de gnome-calculator) comme suit:
=() {
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
Les fonctions disponibles semblent être (prises directement de le code source ), == désigne des fonctions équivalentes:
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()
Vous pouvez utiliser l'arithmétique simple de nombres entiers de manière native dans bash à l'aide de la syntaxe ((...)), par exemple.
$ echo $((10000-9000))
1000
Il y a aussi la calculatrice bc, qui peut accepter des expressions arithmétiques sur une entrée standard
$ echo "10000-9000" | bc
1000
Le programme bc peut aussi faire de l'arithmétique en virgule flottante
$ echo "scale = 3; 0.1-0.09" | bc
.01
Vous pouvez utiliser calc . N’est pas installé par défaut, mais vous pouvez l’installer rapidement à l’aide de la commande suivante:
Sudo apt-get install apcalc
Une fois que vous avez installé, vous pouvez faire le calcul que vous souhaitez:
$ 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...
Pour plus d'informations, consultez sa page de manuel
Malheureusement, il n'y a pas de moyen "facile" de faire cela. L'interface interactive python de la ligne de commande est la mieux adaptée à vos besoins, car contrairement à apcalc \, python est inclus sous Ubuntu. Je ne suis pas sûr si bc est toujours inclus, cependant, python est le favori pour ce genre de choses.
Vous pouvez simplement exécuter l'interface interactive python sur la ligne de commande, puis faire les calculs de cette manière. Vous pouvez l'utiliser comme calculatrice.
Pour ce faire, vous ouvrez le terminal, tapez python, puis appuyez sur la touche Enter bouton.
Ensuite, dans l'invite python qui s'affiche, vous pouvez taper vos calculs. Par exemple, 10000 - 9000. La ligne suivante est le résultat.
Si vous voulez dire, cependant, quelque chose où vous venez de charger le terminal et pouvez le faire ...
10000 $ - 9000 1000 $
... alors non, il n'y a aucun moyen de faire cela dans juste le terminal sans rien d'autre, car Bash ne gère pas de tels arguments numériques.
Je vous conseillerais de créer une fonction simple pour les calculs de base Python. Quelque chose comme ça dans votre .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
Si vous voulez faire des calculs plus avancés, vous pouvez utiliser le suivant qui importe toutes les fonctions du module mathname__. (voir ici pour plus d'informations)
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
(Remarque: étant donné que Python est un langage de programmation, certaines choses peuvent paraître étranges, par exemple ** pour les pouvoirs de et % pour les modulo)
Vous pouvez également créer un Python script calcname__,
#!/usr/bin/python3
from math import *
import sys
print(eval(' '.join(sys.argv[1:])))
placez-le dans un répertoire inclus dans la variable PATHet définissez son indicateur exécutable pour obtenir la même commande calccomme ci-dessus (inutile de créer une fonction Bash pour exécuter un script Python.).
Si vous voulez une méthode en pur Bash, utilisez la réponse de steeldriver. Cette réponse n’est vraiment utile que si vous avez besoin des fonctions plus avancées (à savoir, de mathname__), car Python est relativement lent par rapport à Bash.
Je ne suis pas sûr que cela rompe votre "basculement vers python il peut le faire et je ne le veux pas de cette façon". remarque, mais vous n'avez pas besoin d'entrer l'invite interactive et le résultat est accessible dans Bash, donc cette réponse semble valide (du moins pour moi).
Utilisez le package gcalccmd from gnome-calculator (> = 13.04) ou gcalctool (<13.04). Je pense que le paquet est installé par défaut
% gcalccmd
> 2+3
5
> 3/2
1.5
> 3*2
6
> 2-3
−1
>
Voici un script rapide pour cela:
#!/bin/bash
echo "$@" | bcEnregistrez ceci sous "c", puis placez-le quelque part dans votre chemin (tel que/bin), puis marquez-le comme exécutable.
# nano /bin/c
# chmod +x /bin/c
A partir de maintenant, vous pouvez exécuter des calculs dans le terminal comme ceci:
$ c 10000-9000
1000Voici une modification de la partie appropriée de /etc/bash.bashrc (sur Ubuntu 10.04) qui modifiera le gestionnaire command_not_found pour exécuter l'évaluateur d'expression du shell si le premier caractère de la commande inconnue est un nombre ou - ou +.
Vous pourrez faire n'importe quelle arithmétique de Shell de cette façon; voir http://www.gnu.org/software/bash/manual/bashref.html#Shell-Arithmetic pour obtenir une liste des opérateurs arithmétiques.
Notez que si l'expression que vous voulez évaluer contient un *, vous devrez citer le * avec \ ou des guillemets, car le shell développera le nom du fichier avant de décider de la commande à exécuter. Même chose pour d'autres opérateurs comme >>.
Mettez ceci dans votre ~/.bashrc, puis tapez . ~/.bashrc et essayez-le.
# 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
Exemple de sortie: (Je tape cta, une faute de frappe, juste pour vérifier que notre nouveau gestionnaire command_not_found essayera toujours de rechercher des commandes inconnues).
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
Une autre solution que je n'ai pas vue mentionnée ici est Qalculate (qalc).
Sudo apt-get install qalc
pour la version CLI,
Sudo apt-get install qalculate-gtk
pour l'interface graphique.
Il a un tas de fonctionnalités telles que:
- support pour unités : par exemple.
20 m / s * 12 h = 864 kilom - constantes intégrées telles que
pi,e,c,avogadro - de nombreuses fonctions intégrées : par exemple.
sin(pi) = 0,gamma(4) = 6,5! = 120,log(1024, 2) = 10 - conversion d'unités, par exemple:
> 120 in120 * inch = 120 in> convert cm120 in = 304.8 centim
- calcul symbolique , par ex.
(x + y)^2 = x^2 + 2xy + y^2 - l'intégration, par exemple
integrate 3*x^2 = x^3,diff sin(x), pi - aide intégrée, par exemple
help convert,help integrate - tabulation des commandes
- tout est traduit, par exemple mon système est en néerlandais, je peux donc écrire à la fois
factorial(5)etfaculteit(5). - et plus...
Vous dites que vous voulez l'utiliser sans préfixes, eh bien ... vous pouvez l'utiliser avec un préfixe:
$ qalc 5 ft + 3 cm
(5 * foot) + (3 * centim) = 1.554 m
ainsi que de l'exécuter en tant que remplaçant.
dcname__! Cela fait partie de coreutils, donc il est installé sur OS X, Ubuntu et à peu près TOUT le reste. C'est une calculatrice RPN, donc si vous n'aimez pas ça, ce n'est pas pour vous.
Très basique les commandes sont les suivantes (la page de manuel a toute la syntaxe que je n’ai pas incluse. Exponentiation, ça vous tente?)
Vous avez seulement besoin d'espaces entre les nombres. Ils sont ignorés dans tous les autres cas.
Taper un nombre le pousse vers le haut de la pile.
+ 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
J'utilise Octave pour ce genre de chose: http://www.gnu.org/software/octave/
Il s’agit plutôt d’un clone matlab (excuses s’il s’agit d’une simplification excessive) qui peut être utilisé dans le terminal en tapant octave. Installer Sudo apt-get install octave
Ce n'est pas tout à fait ce que vous voulez, mais j'ai pensé l'ajouter comme alternative au python.
Exemple d'utilisation:
~ $ octave
octave:1> 9000 - 8000
ans = 1000
octave:2>
J'aime beaucoup wcalc. C'est une calculatrice scientifique en ligne de commande. Facile à trouver dans le Centre logiciel Ubuntu, ou utilisez simplement apt-get.
Sudo apt-get install wcalc
Il accepte les arguments de ligne de commande ainsi que le mode "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
Et si quelqu'un est en ingénierie, comme moi, vous pouvez utiliser GNU Octave. Il peut faire toutes sortes de choses, créer des graphiques, résoudre des équations simultanées. De plus, c'est une alternative gratuite à Matlab
manière simple est d'appeler python.
Exemple:
> python -c 'print 10000-9000'
Ce que j’ai trouvé, c’est que je ne peux pas faire confiance aux options expr, bc ou Shell intégrées. J'ai donc utilisé Perl qui serait normalement installé dans la distribution * linux
Perl -le 'printf "%.0f", eval"@ARGV"' "($VAL2-$VAL1)"
Le calcul ci-dessus soustrait $ VAL1 de $ VAL2 et imprimera sans décimale (0f)
Profitez de l’utilisation de Perl (détails de les avantages et les inconvénients sont listés ici )
- Meilleure capture d'erreur (diviser par 0 n'arrêtera pas le calcul)
- Peut fournir des formules dans un fichier de configuration. Pas besoin d'échapper à l'aide de regex complexe
Vous pouvez ajouter la fonction suivante à votre fichier .bashrc:
function = {
echo "$@" | bc -l
}
Notez que -l est très important. Sans cela, l'utilisation de bc donne 5 / 2 = 2.
Comme indiqué ci-dessus, les calculs peuvent être effectués à l'aide du signe = placé devant la formule.
Vous pouvez également utiliser awk pour effectuer des calculs arithmétiques sur le terminal,
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
Dans le passé, j’utilisais wcalc et un petit programme appelé e qui est quasiment impossible à rechercher sur Google. J'utilise maintenant un script python, qui utilise certaines fonctionnalités de e comme les crochets. wcalc est toujours agréable car il peut effectuer des conversions de précision et d'unités arbitraires, mais je n'utilise presque jamais ces fonctionnalités.
#!/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(")", "]"))
Voici comment l'utiliser (en supposant que le script a été enregistré sous le nom e et placé quelque part dans le $PATH):
$ e e**[pi*1i]
-1.0
$ e hex[10**3]
0x3e8
$ e "[0o400+3]&0xff" # need quotes because of '&'
3
utilisez la commande "bc" et vous pourrez alors calculer
exemple
[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
Pour utiliser bc sans la note de garantie, écrivez dans le terminal bc -q
exemple
[root@vaibhav ~]# bc -q
10+2
12
Vous pouvez utiliser bind et bash C-a et C-e pour contrôler la sortie. Par exemple, exécutez ceci dans votre shell:
bind '"\C-j": "\C-aecho $(( \C-e )) \C-m"'
Saisissez maintenant une opération arithmétique telle que 10 + 15 et appuyez sur Ctrl+J:
$ echo $(( 10 + 15 ))
25
Vous obtiendrez ceci. Maintenant, comment fait-on?
bindcette commande modifie la liaison de votre bash, comme les touches de raccourci.\C-jc'est l'équivalent bash de Ctrl + J, c'est la combinaison de touches que nous aimerions ajouter à notre commande.\C-aceci nous amène au début de la ligne.echo $((ceci écritecho $((au début.\C-enous amène à la fin de la ligne))ferme notre parenthèse précédente\C-mc'est l'équivalent de la clé de retour.
Vous pouvez l'écrire dans votre fichier ~/.inputrc:
"\C-j": "\C-aecho $(( \C-e )) \C-m"
Bien sûr, les autres réponses sont également valables! Juste un peu modifié:
- 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" - d'autres?
Vous pouvez changer Ctrl + J pour faire ce que vous voulez, mais rappelez-vous, essayez de ne pas le changer pour quelque chose qui a déjà une liaison;).
Ressource:
Vous pouvez également utiliser printf Shell intégré pour effectuer des calculs arithmétiques sur un terminal.
printf `expr $num1 + $num2` # num1,num2 are variables which stores numbers as values.
Exemple:
$ printf "$(expr 10000 + 9000)\n"
19000
$ printf "$(expr 10000 - 9000)\n"
1000
Créer une calculatrice de terminal
Mettez ce qui suit dans votre fichier .bashrc
function calc
{
echo "${1}"|bc -l;
}
Ou exécutez-le à l'invite du shell. Maintenant, "calc" de Shell fonctionnera comme suit:
$ calc 3+45
48
Toutes les fonctions avec "(" ou ")" doivent être entre guillemets.
Il existe une méthode en une étape pour accomplir exactement ce que vous voulez. Tout ce que vous avez à faire est de définir le Shell de votre compte sur /bin/bc.
Vous pouvez utiliser l'interprète python pour le calcul. Voici un tutoriel sur la façon de le faire .
Python 2 et python 3 sont installés par défaut dans 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