Il y a beaucoup d'options !!!
Sommaire
$ printf %.10f\\n "$((10**9 * 20/7))e-9" # many shells. Not mksh.
$ echo "$((20.0/7))" # (ksh93/zsh/yash, not bash)
$ awk "BEGIN {print (20+5)/2}"
$ zcalc
$ bc <<< 20+5/2
$ bc <<< "scale=4; (20+5)/2"
$ dc <<< "4 k 20 5 + 2 / p"
$ expr 20 + 5
$ calc 2 + 4
$ node -pe 20+5/2 # Uses the power of JavaScript, e.g. : node -pe 20+5/Math.PI
$ echo 20 5 2 / + p | dc
$ echo 4 k 20 5 2 / + p | dc
$ perl -E "say 20+5/2"
$ python -c "print(20+5/2)"
$ python -c "print(20+5/2.0)"
$ clisp -x "(+ 2 2)"
$ lua -e "print(20+5/2)"
$ php -r 'echo 20+5/2;'
$ ruby -e 'p 20+5/2'
$ ruby -e 'p 20+5/2.0'
$ guile -c '(display (+ 20 (/ 5 2)))'
$ guile -c '(display (+ 20 (/ 5 2.0)))'
$ slsh -e 'printf("%f",20+5/2)'
$ slsh -e 'printf("%f",20+5/2.0)'
$ tclsh <<< 'puts [expr 20+5/2]'
$ tclsh <<< 'puts [expr 20+5/2.0]'
$ sqlite3 <<< 'select 20+5/2;'
$ sqlite3 <<< 'select 20+5/2.0;'
$ echo 'select 1 + 1;' | sqlite3
$ psql -tAc 'select 1+1'
$ R -q -e 'print(sd(rnorm(1000)))'
$ r -e 'cat(pi^2, "\n")'
$ r -e 'print(sum(1:100))'
$ smjs
$ jspl
Détails
Coquilles
Vous pouvez utiliser le développement arithmétique POSIX pour l' arithmétique entièreecho "$((...))"
:
$ echo "$((20+5))"
25
$ echo "$((20+5/2))"
22
Tout à fait portable ( ash dash yash bash ksh93 lksh zsh
):
En utilisant la capacité printf à imprimer des flottants, nous pouvons étendre la plupart des shells pour effectuer des calculs en virgule flottante, avec une plage limitée (10 chiffres au maximum):
$ printf %.10f\\n "$((1000000000 * 20/7 ))e-9"
2.8571428570
ksh93
, yash
et zsh
supporte les flotteurs ici:
$ echo "$((1.2 / 3))"
0.4
seulement ksh93
(directement) et zsh
chargement de la bibliothèque mathfunc ici:
$ echo "$((4*atan(1)))"
3.14159265358979324
( zsh
besoin de charger zmodload zsh/mathfunc
pour obtenir des fonctions comme atan
).
Interactivement avec zsh:
$ autoload zcalc
$ zcalc
1> PI/2
1.5708
2> cos($1)
6.12323e-17
3> :sci 12
6.12323399574e-17
Avec (t) csh (entier uniquement):
% @ a=25 / 3; echo $a
8
Dans la rc
famille shell, akanga
est celui avec expansion arithmétique:
; echo $:25/3
8
Boîte à outils POSIX
bc
(voir ci-dessous pour le mode interactif), manuel ici
Mnémonique: best ccalculateur (bien que le b
soit en fait pour base ).
$ echo 20+5/2 | bc
22
$ echo 'scale=4;20+5/2' | bc
22.5000
(supporte des nombres de précision arbitraires)
mode interactif bc:
$ 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'.
5+5
10
2.2+3.3
5.5
La solution de Rush , expr
(pas de mode interactif):
$ expr 20 + 5
25
$ expr 20 + 5 / 2
22
La solution de Joshua : awk
(pas de mode interactif):
$ calc() { awk "BEGIN{print $*}"; }
$ calc 1/3
0.333333
Autres outils plus ou moins portables
La solution Arcege , dc
(mode interactif :)dc
:
Ce qui est encore plus amusant car cela fonctionne par la notation polonaise inversée.
$ echo 20 5 2 / + p | dc
22
$ echo 4 k 20 5 2 / + p | dc
22.5000
Mais pas aussi pratique à moins de travailler beaucoup avec la notation polonaise inversée.
Notez que cette version dc
est antérieure à bc
et bc
historiquement implémentée comme encapsuleur dc
mais dc
n’a pas été normalisée par POSIX.
DQdims 's calc
(requis sudo apt-get install apcalc)
:
$ calc 2 + 4
6
Interprètes de langue à usage général:
solution de manatwork , node
(mode interactif :;node
fonction de sortie non nécessaire):
$ node -pe 20+5/2 # Uses the power of JavaScript, e.g. : node -pe 20+5/Math.PI
22.5
Perl (mode interactif:) perl -de 1
:
$ perl -E "say 20+5/2"
22.5
Python (mode interactif python
:; fonction de sortie non nécessaire):
$ python -c "print(20+5/2)"
22 # 22.5 with python3
$ python -c "print(20+5/2.0)"
22.5
Prend également en charge les nombres de précision arbitraires:
$ python -c 'print(2**1234)'
295811224608098629060044695716103590786339687135372992239556207050657350796238924261053837248378050186443647759070955993120820899330381760937027212482840944941362110665443775183495726811929203861182015218323892077355983393191208928867652655993602487903113708549402668624521100611794270340232766099317098048887493809023127398253860618772619035009883272941129544640111837184
Si vous avez clisp
installé, vous pouvez également utiliser la notation polonaise:
$ clisp -x "(+ 2 2)"
La solution de Marco , lua
(mode interactif:) lua
:
$ lua -e "print(20+5/2)"
22.5
PHP (mode interactif:) php -a
:
$ php -r 'echo 20+5/2;'
22.5
Ruby (mode interactif irb
:; fonction de sortie non nécessaire):
$ ruby -e 'p 20+5/2'
22
$ ruby -e 'p 20+5/2.0'
22.5
Guile (mode interactif:) guile
:
$ guile -c '(display (+ 20 (/ 5 2)))'
45/2
$ guile -c '(display (+ 20 (/ 5 2.0)))'
22.5
S-Lang (mode interactif slsh
:; fonction de sortie non nécessaire, juste un ;
terminateur):
$ slsh -e 'printf("%f",20+5/2)'
22.000000
$ slsh -e 'printf("%f",20+5/2.0)'
22.500000
Tcl (mode interactif tclsh
:; fonction de sortie non nécessaire, mais expr
est):
$ tclsh <<< 'puts [expr 20+5/2]'
22
$ tclsh <<< 'puts [expr 20+5/2.0]'
22.5
Javascript shell:
$ smjs
js> 25/3
8.333333333333334
js>
$ jspl
JSC: 25/3
RP: 8.33333333333333
RJS: [object Number]
JSC:
Good bye...
$ node
> 25/3
8.333333333333334
>
Divers SQL:
SQLite (mode interactif:) sqlite3
:
$ sqlite3 <<< 'select 20+5/2;'
22
$ sqlite3 <<< 'select 20+5/2.0;'
22.5
MySQL :
mysql -BNe 'select 1+1'
PostgreSQL :
psql -tAc 'select 1+1
_Les options sur mysql et postgres arrêtent l'image 'art ascii'!
Langages spécialisés en mathématiques:
R en mode brut - permet de générer 1 000 nombres aléatoires normaux, d'obtenir l'écart type et de l'imprimer
$ R -q -e 'print(sd(rnorm(1000)))'
> print(sd(rnorm(1000)))
[1] 1.031997
R utilisant le script littler - permet d’imprimer pi au carré
$ r -e 'cat(pi^2, "\n")'
9.869604
$ r -e 'print(sum(1:100))'
[1] 5050
PARI / GP , un système de calcul étendu pour la théorie des nombres, l'algèbre linéaire et bien d'autres choses
$ echo "prime(1000)"|gp -q
7919 // the 1000th prime
$ echo "factor(1000)" | gp -q
[2 3]
[5 3] // 2^3*5^3
$ echo "sum(x=1,5,x)" | gp -q
15 // 1+2+3+4+5
GNU Octave (langage interprété de haut niveau, principalement destiné aux calculs numériques)
Prend également en charge les nombres complexes:
$ octave
>> 1.2 / 7
ans = 0.17143
>> sqrt(-1)
ans = 0 + 1i
Julia , langage performant et interprète pour l'informatique scientifique et numérique.
Option non interactive:
$ julia -E '2.5+3.7'
6.2
bc
, cela vaut peut-être la peine de vous renseigner sur l'-l
option dans la page de manuel.