Un calculateur en ligne de commande pour Ubuntu?

Je cherche une calculatrice capable d'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 .bashrcfichier pour essayer:

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

Alors maintenant, vous n’avez même $((...))plus besoin de =quoi, cela semble assez naturel.

Remplacement

Une autre chose si vous voulez être encore plus rapide: vous pouvez le remplacer ppar +et xavec *. 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 Shiftplus besoin de rien , la seule chose à faire est = d’être 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 xsubstitution sera en conflit avec la 0x...syntaxe hexadécimale)

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

Exemple:

$ = 16 + 0x10
272 (0x110)

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

En utilisant bc

Si vous souhaitez des calculs légèrement plus avancés, vous pouvez le diriger de la bcmanière suivante:

=() {
    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 prend également en charge if, for, whileet les variables comme un langage de programmation mais s'il peut être préférable d'écrire dans un fichier si vous voulez que.

Gardez à l'esprit qu'il substituera pet xdans les noms de fonction / variable. Il peut être préférable de simplement supprimer les remplaçants.

En utilisant gcalccmd

Vous pouvez également appeler la fonction gcalccmd(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 du code source ), ==dénote 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 faire de l’arithmétique d’entiers simple de manière native dans bash en utilisant la ((...))syntaxe, par exemple:

$ echo $((10000-9000))
1000

Il y a aussi la bccalculatrice, qui peut accepter des expressions arithmétiques sur une entrée standard

$ echo "10000-9000" | bc
1000

Le bcprogramme 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 python interactive sur la ligne de commande est la mieux adaptée à vos besoins, car contrairement à apcalc\, elle pythonest incluse dans Ubuntu. Je ne sais pas si bcest toujours inclus, cependant, python est le préféré pour ce genre de choses.

Vous pouvez simplement exécuter l' pythoninterface interactive sur la ligne de commande, puis faire les calculs de cette façon. Vous pouvez l'utiliser comme calculatrice.

Pour ce faire, vous ouvrez le terminal, tapez python, puis appuyez sur le Enterbouton.

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

10 000 $ à 9 000 $
1000
$

... alors pas il n'y a pas moyen de le faire dans tout le terminal sans rien d' autre, parce que Bash ne gère pas d' arguments numériques comme ça.

Je vous conseillerais de créer une fonction simple pour les calculs de base de 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 mathfonctions du module. (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: Python étant un langage de programmation, certaines choses peuvent paraître étranges, par exemple **pour les puissances de et %pour le modulo)

Sinon, vous pouvez créer un script Python calc,

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

placez-le dans un répertoire inclus dans la PATHvariable et définissez son indicateur exécutable pour obtenir la même calccommande que 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 les plus avancées (c’est-à-dire de math), car Python est relativement lent par rapport à Bash.

Je ne sais pas si cela casse votre "passage en 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 gcalccmdfrom 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 shell rapide pour cela:

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

Enregistrez ceci sous "c", puis placez-le quelque part dans votre chemin (comme / 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
1000

Voici une modification de la partie appropriée de /etc/bash.bashrc(sur Ubuntu 10.04) qui modifiera le command_not_foundgestionnaire 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 coquille 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 ou *avec les \guillemets, car le shell fera l'expansion du nom de fichier avant de décider quelle commande exécuter. Même chose pour d'autres opérateurs comme >>.

Mettez ceci dans votre ~/.bashrc, puis tapez . ~/.bashrcet 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:

• soutien aux unités : par exemple20 m / s * 12 h = 864 kilom
• intégré des constantes telles que pi, e, c,avogadro
• beaucoup intégrés fonctions : par exemple sin(pi) = 0, gamma(4) = 6, 5! = 120,log(1024, 2) = 10
• Conversion d'unités, par exemple:

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

• calcul symbolique , par exemple(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 les deux factorial(5)et faculteit(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.

dc! Cela fait partie de coreutils, donc il est installé sur OS X, Ubuntu et à peu près TOUT autre. C'est une calculatrice RPN, donc si vous n'aimez pas ça, ce n'est pas pour vous.

Les commandes très basiques 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/

C'est à peu près un clone matlab (excuses s'il s'agit d'une simplification excessive) qui peut être utilisé dans le terminal en tapant octave. Installez 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 is (détails des avantages et inconvénients répertorié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 le -ldrapeau est très important. Sans cela, l'utilisation de bcdonne 5 / 2 = 2.

Comme il a été mentionné ci-dessus, les calculs peuvent être effectués en utilisant le =signe 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

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

À utiliser bcsans la note de garantie, écrivez dans le terminalbc -q

exemple

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

Vous pouvez utiliser bind et bash C-aet C-epour contrôler la sortie. Par exemple, exécutez ceci dans votre shell:

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

Maintenant tapez une opération arithmétique comme 10 + 15 et appuyez sur Ctrl+ J:

$ echo $(( 10 + 15 )) 
25

Vous obtiendrez ceci. Maintenant, comment fait-on?

• bind Cette commande change la liaison de votre bash, comme les raccourcis clavier.
• \C-j c'est l'équivalent bash de Ctrl + J, c'est la combinaison de touches que nous voudrions ajouter à notre commande.
• \C-a cela nous amène au début de la ligne.
• echo $((cela écrit echo $((au début.
• \C-e nous amène au bout de la ligne
• )) ferme notre parenthèse précédente
• \C-m c'est l'équivalent de la clé de retour.

Vous pouvez écrire ceci dans votre ~/.inputrcfichier:

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

Bien sûr, les autres réponses sont également valables! Juste un peu modifié:

• avant JC: "\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 comme bon vous semble, mais rappelez-vous, essayez de ne pas le changer pour quelque chose qui a déjà une liaison;).

Ressource:

• Y at-il un moyen de configurer bash pour toujours la sortie de la page?

Dans le passé, j’utilisais wcalcun petit programme appelé equasiment impossible à rechercher sur Google. Maintenant, j'utilise un script python pour cela, qui utilise des fonctionnalités etelles que les crochets. wcalcest toujours agréable car il peut effectuer des conversions de précision et des 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é sauvegardé eet placé quelque part dans le fichier $PATH):

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

Il existe une méthode en une étape pour accomplir exactement ce que vous voulez. Tout ce que vous avez à faire est de configurer le shellpour votre compte /bin/bc.

Vous pouvez également utiliser le 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

Vous pouvez utiliser l'interpréteur python pour le calcul. Voici un tutoriel sur la façon de le faire .

Python 2 et Python 3 sont installés dans Ubuntu par défaut.

$ 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

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" à partir de la coque fonctionnera comme suit:

$ calc 3+45
   48

Toutes les fonctions avec "(" ou ")" doivent être entre guillemets.