Calculatrice simple en ligne de commande

19

Problème:

De temps en temps, je dois faire de l'arithmétique simple dans un environnement en ligne de commande. EG étant donné la sortie suivante:

Disk /dev/sdb: 256GB
Sector size (logical/physical): 512B/512B
Partition Table: gpt
Disk Flags: 

Number  Start   End     Size    File system     Name  Flags
 1      1049kB  106MB   105MB   fat32                 hidden, diag
 2      106MB   64.1GB  64.0GB  ext4
 3      64.1GB  192GB   128GB   ext4
 5      236GB   256GB   20.0GB  linux-swap(v1)

Quel est un moyen simple de calculer sur la ligne de commande la taille de l'espace non alloué entre la partition 3 et 5?

Ce que j'ai déjà essayé:

avant JC

bc
bc 1.06.95
Copyright 1991-1994, 1997, 1998, 2000, 2004, 2006 Free Software Foundation, Inc.
This is free software with ABSOLUTELY NO WARRANTY.
For details type `warranty'. 
236-192
44
quit

où le gras ci - dessus est tous les trucs que je dois taper faire simple 236-192comme bc 1+1échosFile 1+1 is unavailable.

expr

expr 236 - 192

où je dois taper des espaces avant et après l'opérateur comme de expr 1+1simples échos 1+1.

Fabby
la source
3
Si vous avez l'intention de le faire de manière interactive, vous n'avez pas besoin de taper quitdans bc; appuyant sur ctrl-Dfera l'affaire, comme dans tout programme interactif.
marcelm
2
dcest (OMI) bien supérieur à bc.
William Pursell
1
Je pense que l'espace non alloué entre ptn 3 et 5 devrait être 236 - 192, et non 236 - 128?
Digital Trauma
@DigitalTrauma bon œil! (Ce n'était qu'un exemple et personne n'a repéré celui-là!)
Fabby
1
@JanM. Je suis celui qui a voté positivement .... ;-)
Fabby

Réponses:

33

Vous pouvez réduire considérablement le niveau de verbosité impliqué dans l'utilisation bc:

$ bc <<<"236-192"
44
$ bc <<<"1+1"
2

(en supposant que votre shell le supporte).

Si vous préférez avoir cela en fonction:

$ c() { printf "%s\n" "$*" | bc }
$ c 1+1
2

Enregistrez la cdéfinition dans votre fichier de démarrage shell préféré si vous souhaitez la rendre toujours disponible.

Stephen Kitt
la source
2
bc<RET>236-128<RET>quit<RET>est de 16 touches. bc<<<"236-128"<RET>est de 15 touches. Ce n'est pas ce que j'appellerais "une quantité de frappe considérablement réduite" :-) De plus, bcpeut être quitté avec ^D, donc la première option est réduite à 13 frappes (comptant ^Dpour deux).
L. Levrel
Bon, c'est plus une question de verbosité ;-).
Stephen Kitt
2
@ L.Levrel Avec la fonction, c'est c 1+1exactement ce dont j'avais besoin! :-) (réponse mise à jour pour que ce soit plus clair)
Fabby
Et si vous faites des virgules flottantes: c 'scale = 2; 17/3 '(ou mieux, mettez à l'échelle une variable utilisée dans la fonction' c () ', et définissez sa valeur chaque fois que vous avez besoin de n chiffres décimaux. La valeur par défaut est 0.)
Olivier Dulac
1
Utilisez-la plutôt bc -ldans la définition de la fonction pour la rendre plus performante.
Isaac
22

coquille

Le calcul le plus simple en CLI est le CLI (shell) lui-même (If IFSest par défaut):

$ echo $(( 22 + 333 ))
355

Les espaces peuvent être omis:

$ echo $((22*333))
7326

Comme il fait partie de POSIX, presque tous les shells l'ont. Et il inclut la plupart des fonctionnalités mathématiques du langage C (sauf que zsh a une priorité différente, définissez C_PRECEDENCES pour le restaurer à une valeur compatible):

$ echo $((22*333^2))
7324

Et certains shells ont la plupart de la syntaxe mathématique du langage C (y compris la virgule):

$ echo $((a=22,b=333,c=a*b,c))
7326

Mais ce ne sont que des mathématiques entières (et généralement moins de 2 63 dans les systèmes d'exploitation actuels) dans certains shells:

$ echo $((1234/3))
411

$ zsh -c 'echo $((2**63))'
-9223372036854775808

Certains obus pourraient faire des calculs flottants:

$ ksh -c 'echo $((1234/3.0))'
411.333333333333333

$ ksh -c 'echo $((12345678901234567890123/3.0))'
4.11522630041152263e+21

Évitez zsh (zcalc a des problèmes similaires):

$ zsh -c 'echo $((12345678901234567890123 + 1))'
zsh:1: number truncated after 22 digits: 12345678901234567890123 + 1
-1363962815083169259

Je vous recommande d'éviter expr, il faut parfois des évasions bizarres:

$ expr 22 \* 333
7326

avant JC

Au niveau suivant est ( également POSIX ) bc(cousin de RPN dc)

$ echo '22*333' | bc
7326

$ echo '22 333 * p' | dc
7326

Le dc était Posix mais ils nous ont enlevé en 2017 .

Plus court si votre shell le prend en charge:

$ bc <<<'22*333'
7326

Ou même:

$ <<<'22*333' bc
7326

Les deux sont des calculateurs de précision arbitraires avec quelques fonctions mathématiques internes:

$ bc <<<2^200
1606938044258990275541962092341162602522202993782792835301376

$ echo 's(3.1415/2)' | bc -l        # sine function
.99999999892691403749

awk

Après ces outils de calcul vraiment basiques , vous devez passer à d'autres langues

$ awk "BEGIN {print (22*33)/7}"
103.714

$ perl -E "say 22*33/7"
103.714285714286

$ python3 -c "print(22*33/7)"
103.71428571428571

$ php -r 'echo 22*33/7,"\n";'
103.71428571429

une fonction

Vous pouvez définir une fonction de l'une des options ci-dessus:

c () 
{ 
    local in="$(echo " $*" | sed -e 's/\[/(/g' -e 's/\]/)/g')";
    gawk -M -v PREC=201 -M 'BEGIN {printf("%.60g\n",'"${in-0}"')}' < /dev/null
}

Et utilise:

$ c 22* 33 /7                   # spaces or not, it doesn't matter.
103.714285714285714285714285714285714285714285714285714285714
Isaac
la source
20

En lisant les commentaires de cette page , je vois un programme UNIX / Linux appelé calcqui fait exactement ce que vous voulez. Si sur Debian / Ubuntu / dérivés:

sudo apt-get install apcalc

Ensuite vous pouvez:

calc 236-192

et si vous ajoutez un alias alias c='calc'à votre .bashrcou /etc/bash.bashrcalors il devient juste:

c 1+1

sur la ligne de commande.

nombre9
la source
1
Pas parfait, mais assez bon pour un vote positif. Incompréhension corrigée dans le chat et downvote supprimée par un autre utilisateur . Supprimé ma propre réponse (inférieure) ... ;-)
Fabby
15

Dans zsh:

$ autoload zcalc # best in  ~/.zshrc
$ zcalc
1> 1+1
2
2> ^D
$ zcalc 5+5
1> 10
2>
Stéphane Chazelas
la source
9

Le unitsprogramme, bien qu'il ne soit pas destiné à être utilisé comme une calculatrice, fonctionne plutôt bien comme tel.

$ units "236-192"
    Definition: 44
$ 

S'il y a des espaces dans l'expression, alors l'expression doit être protégée par des guillemets.
Il prend en charge les exponentielles et l'imbrication profonde des supports

CSM
la source
3
Il est polyvalent: units -t -d 10 "236GB - 192GB" GBsorties 44, units -t -d 15 "236GB - 192GB" bytessorties 44000000000, etc.
agc
6

Comme indiqué dans un commentaire à une réponse précédente, le shell standard (ba) sh permet d'évaluer les expressions arithmétiques à l'intérieur $((...)). Je n'ai pas pu vérifier si cela fait partie de la norme POSIX, mais j'ai vérifié que cela fonctionne également sur Cygwin et le shell Mingw32.

Pour voir le résultat, il faudrait en effet taper echo $((...)), ce qui rend certains caractères plus que (utilisation interactive de) bc. Cependant, pour utiliser le résultat dans un script, ce sera probablement plus court que la bcsolution (ce qui pourrait être, par exemple `echo ...|bc`).

Concernant la verbosité, la bccommande permet l'option -qqui supprime la sortie de "l' bcaccueil GNU normal " .

En guise de remarque finale, légèrement limite, notons qu'il bcne s'agit pas seulement d'une calculatrice mais plutôt d'un langage de programmation à part entière (y compris les fonctions définies par l'utilisateur, les boucles while et for, etc., etc.). Un autre fait qui suggère de préférer les capacités arithmétiques intégrées pour de tels calculs simples, plutôt qu'un programme externe. Cela dit, l'extraction des données pour le (s) numéro (s) de partition donné (s) et le traitement des suffixes "M", "G", comme la question d'origine semblait demander, pourraient appeler (g)awkplutôt que bc.

Sources: https://www.gnu.org/software/bc/manual/html_mono/bc.html https://www.gnu.org/software/gawk/manual/html_node/Getting-Started.html

Max
la source
Merci! Excellente première réponse! +1
Fabby
2
$((...))s'appelle Arithmetic Expansion et fait partie de POSIX: pubs.opengroup.org/onlinepubs/9699919799/utilities/… Pour moi, le plus gros inconvénient de cette fonctionnalité d'un shell POSIX est qu'il ne prend en charge que l'arithmétique entière :(
pabouk
6

Ce que je fais dans zsh c'est:

$ <<< $(( 236 - 192 ))
44

En bash, je devrais mentionner explicitement cat:

$ cat <<< $(( 236 - 192 ))
44

Si je voulais que le résultat comprenne des chiffres fractionnaires (fonctionne en zsh, pas en bash), j'ajouterais un point radix à l'un des opérandes

$ <<< $(( 236 / 128 )) 
1
$ <<< $(( 236. / 128 ))
1.84375
JoL
la source
7
echo $((236 - 128))fonctionne aussi ;-).
Stephen Kitt
Évitez zsh: zsh -c 'print $((12345678901234567890123 + 1))' zsh:1: number truncated after 22 digits: 12345678901234567890123 + 1 -1363962815083169259.
Isaac
@Isaac au moins zsh vous dit que c'est tronqué; bash vous donne juste une réponse incorrecte sans vous plaindre.
Stephen Kitt
@StephenKitt Le problème avec zsh est plus complexe que ne le montre une sortie. Comparez: zsh -c 'print $((12345678901234567890123 + 1))'et zsh -c 'print $((123456789012345678901 + 1))'. Il est tronqué à différentes longueurs et produit des résultats numériques différents.
Isaac
@StephenKitt Au lieu de cela, Bash suit le manuel (et le langage C sur le débordement d'un int signé). Non pas que je l'aime personnellement, mais c'est documenté comme tel. Essayez bash -c 'echo $((1<<63))'et `` bash -c 'echo $ (((1 << 63) -1))' '.
Isaac
6

Personnellement, j'aime libqalculate (la version en ligne de commande de Qalculate ).

$ qalc
> 236-192

  236 - 192 = 44

Bien que l'interface soit certainement simple, (lib) qalculate est une calculatrice puissante et à part entière. par exemple

> fibonacci(133) to hex

  fibonacci(133) = approx. 0x90540BE2616C26F81F876B9

> 100!

  factorial(100) = approx. 9.3326215E157

> sin(pi)

  sin(pi * radian) = 0

Il fait également des choses utiles comme la complétion de tabulation, ouvre / ferme les parenthèses si nécessaire et imprime son interprétation de la requête.

> 18-2)/4

  (18 - 2) / 4 = 4

Pour sortir, j'appuie simplement sur Ctrl + d.

Pour un accès encore plus rapide, définissez-le sur quelque chose comme alias ca='qalc'.

Sparhawk
la source
J'ai lu la table des matières du manuel mais je n'ai rien trouvé sur CLI. (+1 en attendant)
Fabby
1
Merci @Fabby. Je suis devenu confus et la partie CLI est en fait légèrement différente. J'ai mis à jour la réponse pour clarifier.
Sparhawk
J'aimerais pouvoir vous voter deux fois! ;-)
Fabby
4

Python ouvert dans un autre onglet?

Python 3.6.3 (v3.6.3:2c5fed8, Oct  3 2017, 17:26:49) [MSC v.1900 32 bit (Intel)] on 
win32
Type "help", "copyright", "credits" or "license" for more information.
>>> 3+3
6
>>>
Michael Hearn
la source
Non, pas vraiment, mais une bonne idée quand même! :-) +1
Fabby
powershell peut également faire la même chose
phuclv
1
@phuclv oui, mais personne n'aime PS
Dev
3
@Dev des tonnes de personnes Unix aiment PS
phuclv
2

dc -e '236 192-p'

... bien sûr, si vous n'êtes pas familier dcet que vous avez besoin de plus que de soustraire deux nombres, vous passerez plus de temps à rechercher comment utiliser dc(et peut-être RPN en général) que vous n'en économiserez avec des méthodes plus familières.

Aaron Thomas
la source
Oui, j'ai regardé la calculatrice de bureau pendant 3 minutes et je savais que ce n'était pas pour moi: j'étais un TI, pas un étudiant HP.
Fabby
2

Si vous avez installé gradle, vous avez groovy ...

Si groovy est correctement acheminé, vous devriez pouvoir utiliser:

groovy -e "println 1+1"

Cela peut sembler un peu redondant avec tous les autres exemples, mais:

  • groovy est un langage puissant
  • peut-être le meilleur support de bibliothèque disponible
  • fonctions mathématiques puissantes et simples (comme les mathématiques de précision arbitraire)
  • utilise stdout redirigeable pour sa sortie, il est donc incroyablement flexible (idéal pour utiliser à l'intérieur des fichiers batch avec des backticks `` et similaires).

Si vous n'avez pas installé java, cela ne vaut probablement pas la peine d'installer groovy & java - c'est juste une option si groovy est déjà disponible.

Bill K
la source
Non, pas vraiment, mais une bonne idée quand même! :-) +1
Fabby
2

Avez-vous essayé concalc ?

Description: console calculator concalc est une calculatrice pour la console Linux. Il s'agit simplement de l'algorithme parseur d'extcalc intégré dans un programme de console simple. Vous pouvez l'utiliser si vous avez besoin d'une calculatrice dans votre shell. concalc est également capable d'exécuter des scripts écrits dans un langage de programmation de type C.

$ concalc 1+1
2
$ concalc sqrt2
1.41421356237309505

Installer avec:

sudo apt-get install concalc
Jan M.
la source
1
preuve ... Graag gedaan ... :-D
Fabby
2

Avant que l'une des autres réponses brillantes ne soit publiée, j'ai fini par créer le script /usr/local/bin/ccontenant:

#!/bin/sh
IFS=' '               # to be on the safe side, some shells fail to reset IFS.
if [ "$#" -eq 0 ];  then
    echo "$(basename "$0"): a (very) simple calculator."
    echo "type $(basename "$0") expression to evaluate (uses bc internally)"
fi

printf '%s\n' "$*" | bc -l  # safe for most shells
                            # we may use 'bc -l <<<"$*"` for ksh, bash, zsh

donc: en tapant les c 1+1rendements2 ! :-)

Remarque 1: J'ai utilisé ccar cette commande n'existe sur aucun système Unix que j'ai pu trouver. Si vous auriez donné un alias à votre compilateur c, utilisez tout ce qui est court et vous ne l'utilisez pas.
Remarque 2: source

Fabby
la source
1
(1) J'ai décidé de l'utiliser echo "$*" | bc -lcomme le shebang que vous avez utilisé /bin/shet je ne sais pas si vous avez ksh / bash / zsh disponible. (2) Notez que vous pouvez modifier l'échelle à calculer si vous exécutez l'échelle `c '= 60; 777/333', par exemple. J'espère que ça aide @Fabby
Isaac
1

Si python est installé, vous pouvez effectuer de nombreuses opérations mathématiques via la ligne de commande. J'ai essayé de fournir un exemple ci-dessous.

J'ai utilisé, python3vous pouvez utiliser python. La différence entre pythonet python3se produit quand une opération divisée (fractionnelle) se produit, pour éviter le problème, voir ci-dessous python vs python3 .

Remarque: La dernière version distante de Linux est livrée avec Python 2.7 et Python 3.5 par défaut. Si vous avez besoin d'installer python, cliquez ici .

Ajouter, soustraire, multiplier et diviser:

$ python3 <<< "print(12+3)"
15
$ python3 <<< "print(12-3)"
9
$ python3 <<< "print(12*3)"
36
$ python3 <<< "print(12/3)"
4

Module - reste de la division:

$ python3 <<< "print(14%3)"
2

Division au sol:

$ python3 <<< "print(14//3)"
4

Exposant - x à la puissance de y (x ^ y):

$ python3 <<< "print(3**2)"
9

Racine carrée (ex: √4 = 2):

$ python3 <<< "print(4**0.5)"
2

Plus scientifique, vous aurez besoin d'une bibliothèque mathématique d' importation . Ex:

Le logarithme naturel de x = log (x):

$ python3 <<< "import math; print(math.log(4))"
1.386294361119890e6

Le logarithme en base 10 de x = log10 (x):

$ python3 <<< "import math; print(math.log10(10))"
1.0

Factorielle (ex: 3! = 3.2.1 = 6):

$ python3 <<< "import math; print(math.factorial(3))"
6

Trigonometry- sin(x), cos(x), tan(x):

$ python3 <<< "import math; print(math.sin(90))"
0.8939966636005579

Pour plus de fonctions mathématiques, vérifiez ici .

pythonVs python3:

-Pour diviser: (utiliser float):

$ python <<< "print(10.0/3)"
3.33333333333

-au lieu de

$ python <<< "print(10/3)"
3

Vous pouvez également utiliser un terminal direct:

$ python3
Python 3.6.8 (default, Jan 14 2019, 11:02:34) 
[GCC 8.0.1 20180414 (experimental) [trunk revision 259383]] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> 1+3
4
>>> import math
>>> math.log10(4)
0.6020599913279624
>>> math.sqrt(4)
2.0
>>> 

C'est ça. Bon codage!

AHJeebon
la source
0

Soit bcou qalc.


Pour avoir automatiquement un bcarrondi toujours à deux chiffres: (l'exécuter avec -lest difficile à gérer pour les choses quotidiennes)

Modifiez votre ~/.bashrc:

alias bc="BC_ENV_ARGS=<(echo "scale=2") \bc"

Ouvrez un nouveau shell et exécutez- bcy.

sjas
la source
-1

Création d'une doublure:

$ c () { echo $(( ${1} )) }

Vous pouvez maintenant utiliser des mathématiques entières simples:

$ c 1+1
2

$ c 25*4
100

$ c 25*4-10
90

$ c 20*5/4
25
WinEunuuchs2Unix
la source
Ceci est déjà discuté dans la réponse d'Isaac .
Stephen Kitt
@StephenKitt Oui, j'ai voté pour la réponse très détaillée d'Isaac. J'ai pensé qu'un récapitulatif résumant certains de ses propos serait utile. L' ${1}utilisation des paramètres est unique à toutes les réponses.
WinEunuuchs2Unix
2
Je vous encourage à chercher les raisons pour lesquelles les autres réponses n'utilisent pas ${1};-)
Stephen Kitt