Comment faire des calculs entiers et flottants, dans Bash ou d'autres langages/frameworks ?

Utilisation de echo "20+5" produit littéralement le texte "20+5 ".

Quelle commande puis-je utiliser pour obtenir la somme numérique, 25 dans ce cas ?

De plus, quel est le moyen le plus simple de le faire en utilisant simplement bash pour le point flottant ? Par exemple, echo $((3224/3807.0)) imprime :(.

Je cherche des réponses en utilisant soit le shell de commande de base ("ligne de commande
") lui-même, soit en utilisant des langages disponibles à partir de la
ligne de commande.

Réponse acceptée :

Il y a beaucoup d'options !!!

Résumé

$ printf %.10f\n "$((10**9 * 20/7))e-9"   # many shells. Not mksh.
$ echo "$((20.0/7))"                       # (ksh93/zsh/yash, some 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
$ gs -q  <<< "5 2 div 20 add  ="

Détails

Coquillages

Vous pouvez utiliser l'expansion arithmétique POSIX pour entier arithmétique echo "$((...))" :

$ echo "$((20+5))"
25
$ echo "$((20+5/2))"
22

Assez portable (ash dash yash bash ksh93 lksh zsh ):
En utilisant la capacité de printf à imprimer des flottants, nous pouvons étendre la plupart des shells pour faire des calculs en virgule flottante, mais avec une plage limitée (pas plus de 10 chiffres) :

$ printf %.10f\n "$((1000000000 *   20/7  ))e-9"
2.8571428570

ksh93 , yash et zsh supportez les flottants ici :

$ echo "$((1.2 / 3))"
0.4

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

Interactif 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 le rc famille de coquillages, akanga est celui avec le développement arithmétique :

; echo $:25/3
8

Boîte à outils POSIX

bc (voir ci-dessous pour le mode interactif), manuel ici

Mnémonique :b est c calculateur (bien que le b est en fait pour de base ).

$ echo 20+5/2 | bc
22
$ echo 'scale=4;20+5/2' | bc
22.5000

(prend en charge les 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 de l'Arcege, dc (mode interactif :dc ):

Ce qui est d'autant plus amusant que cela fonctionne en 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 que vous ne travailliez beaucoup avec la notation polonaise inversée.

Connexe:Enfermer ou ne pas enfermer la valeur d'une variable entre guillemets en bash?

calc de DQdims (nécessaire sudo apt-get install apcalc) :

$ calc 2 + 4
6

Interprètes de langue à usage général :

la 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 arbitraire :

$ 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

Rubis (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

Ruse (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 coques :

$ 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 stoppent l'image "ascii art" !

Langues spécialisées axées sur les mathématiques :

R en mode simple - permet de générer 1000 nombres aléatoires normaux et d'obtenir l'écart type et de l'imprimer

$ R -q -e 'print(sd(rnorm(1000)))'
> print(sd(rnorm(1000)))
[1] 1.031997

R en utilisant le plus petit script – 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 d'algèbre informatique complet 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 (un 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

Julie , langage et interpréteur performant pour le calcul scientifique et numérique.

Option non interactive :

$ julia -E '2.5+3.7'
6.2

GhostScript GhostScript est un interpréteur PostScript, très couramment installé même dans les très anciennes distributions.
Consultez la documentation PostScript pour une liste des commandes mathématiques prises en charge.

Exemple interactif :

$ GS_DEVICE=display gs
GPL Ghostscript 9.07 (2013-02-14)
Copyright (C) 2012 Artifex Software, Inc.  All rights reserved.
This software comes with NO WARRANTY: see the file PUBLIC for details.
GS>5 2 div 20 add  =
22.5
GS>