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

Utiliser echo "20+5"littéralement le texte " 20+5".

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

Aussi, quel est le moyen le plus simple de le faire en utilisant simplement bash pour virgule flottante? Par exemple, echo $((3224/3807.0))empreintes 0:(.

Je cherche des réponses à l'aide du shell de commande de base ("ligne de commande") ou des langues disponibles à partir de la ligne de commande.

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, yashet zshsupporte les flotteurs ici:

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

seulement ksh93(directement) et zshchargement de la bibliothèque mathfunc ici:

$ echo "$((4*atan(1)))"
3.14159265358979324

( zshbesoin de charger zmodload zsh/mathfuncpour 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 rcfamille shell, akangaest 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 bsoit 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 dcest antérieure à bcet bchistoriquement implémentée comme encapsuleur dcmais dcn’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 clispinstallé, 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 exprest):

$ 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

Il y a plusieurs façons de calculer. Pour les expressions simples, vous pouvez utiliser bashlui-même:

echo $((20+5))

ou expr:

expr 20 + 5

Et pour les cas complexes, il existe un excellent outil bc:

echo "20+5" | bc

Btw, bc peut calculer même une expression très complexe avec des racines, des logarithmes, cos, sin, etc.

Les solutions mentionnées conviennent pour des calculs très simples, mais très sujettes aux erreurs. Exemples:

# without spaces expr 20+5 produces literally 20+5
expr 20+5
→ 20+5

# bc's result doesn't give the fractional part by default
bc <<< 9.0/2.0
→ 4

# expr does only integer
expr 9 / 2
→ 4

# same for POSIX arithmetic expansion
echo $((9/2))
→ 4

# bash arithmetic expansion chokes on floats
echo $((9.0/2.0))
→ bash: 9/2.0: syntax error: invalid arithmetic operator (error token is ".0")

# Most `expr` implementations also have problems with floats
expr 9.0 / 2.0
→ expr: non-integer argument

Vous remarquerez facilement une erreur de syntaxe comme les dernières, mais les réponses entières avec une partie flottante ignorée peuvent facilement passer inaperçues et conduire à des résultats erronés.

C'est pourquoi j'utilise toujours un langage de script comme Lua pour cela. Mais vous pouvez choisir n’importe quel langage de script avec lequel vous êtes familier. Je viens d'utiliser Lua comme exemple. Les avantages sont

• une syntaxe familière
• fonctions familières
• mises en garde familières
• entrée flexible
• les espaces ne comptent généralement pas
• sortie en virgule flottante

Exemples:

lua -e "print(9/2)"
→ 4.5

lua -e "print(9 / 2)"
→ 4.5

lua -e "print(9.0/2)"
→ 4.5

lua -e "print (9 /2.)"
→ 4.5

lua -e "print(math.sqrt(9))"
→ 3

Personne n'a encore mentionné awk?

En utilisant les fonctions du shell POSIX et la puissance mathématique awk, définissez simplement cette fonction (une ligne):

calc(){ awk "BEGIN { print $*}"; }

Ensuite, exécutez des choses comme calc 1+1oucalc 5/2

Remarque: pour que la fonction soit toujours disponible, ajoutez-la à ~ / .bashrc (ou au fichier de démarrage de votre shell correspondant).

Bien sûr, un petit script nommé "calc" avec le contenu suivant:

#!/bin/sh -
awk "BEGIN { print $* }"

pourrait aussi travailler.

Vous pourriez utiliser bc. Par exemple,

$ echo "25 + 5" | bc
30

Alternativement bc <<< 25+5va aussi travailler.

Ou interactivement, si vous voulez faire plus qu'un simple calcul:

$ 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'. 
25 + 5
30

L’implémentation GNU de l’ bcimpression de cet en-tête / des informations de copyright au démarrage lorsque stdin et stdout sont envoyés à un terminal. Vous pouvez le supprimer avec l' -qoption (spécifique à GNU) . Pour plus d'informations, voir la page de manuel de bc

Vous pouvez utiliser calc:

Si vous entrez simplement calcsans autres arguments, vous entrez dans un mode interactif où vous pouvez continuer à faire des calculs. Vous quittez ceci en tapant exit:

C-style arbitrary precision calculator (version 2.12.3.3)
Calc is open software. For license details type:  help copyright
[Type "exit" to exit, or "help" for help.]

; 2+4
6
; 3+5
8
; 3.4+5
8.4
; 2^4
16
; exit

Ou vous l’utilisez avec l’expression en tant qu’argument et vous obtiendrez la réponse, puis vous quitterez.

$calc 2 + 4
    6
$

calcest similaire à bc, j'aime juste la façon dont il se comporte mieux par défaut

J'aime lancer Python et l'utiliser comme calculatrice interactive (mais encore une fois, je suis un programmeur Python).

Puisque personne n’en a parlé, et bien que ce ne soit pas strictement une calculatrice (mais tous ces langages de script à usage général ne le sont pas non plus), je voudrais mentionner units:

$ units "1 + 1"
        Definition: 2
$ units "1 lb" "kg"
        * 0.45359237
         / 2.2046226

Ou, pour moins de sortie afin que vous puissiez obtenir juste le nombre à utiliser $()pour assigner à quelque chose:

$ units -t "1 + 1"
2
$ units -t "1 lb" "kg"
0.4539237

Et il fait même des conversions de température

$ units -t "tempC(20)" "tempF"
68

Pour obtenir la conversion de température dans une expression pour un calcul ultérieur, procédez comme suit:

$ units -t "~tempF(tempC(20))+1"
68.1

$> ghc -e '20 + 5'
25
it :: Integer

De plus ghci, le compilateur Glasgow-Haskell en mode interactif ( ghc --interactivecontrairement à l'évaluation d'une expression avec -e), constitue un "calculateur" fascinant:

$>ghci
GHCi, version 7.8.3: http://www.haskell.org/ghc/  :? for help
Loading package ghc-prim ... linking ... done.
Loading package integer-gmp ... linking ... done.
Loading package base ... linking ... done.
Prelude> pi
3.141592653589793
Prelude> ceiling pi
4
Prelude> compare 1 2
LT

Je n'arrive pas à croire de lire "le pouvoir de JavaScript" (mais je devais relire la réponse pour les autres parties, sauf en perl bien sûr.

Pratiquement, pour les cas simples où l'arithmétique entière est suffisante, j'utilise le buildin $ ((...)) et le recommande. Sinon, dans presque tous les cas, l'écho "..." | bc est suffisant.

Pour certaines opérations arithmétiques telles que les statistiques, les opérations matricielles et autres, Rle meilleur outil est le suivant:

echo 25 + 5 | R --vanilla

et pour les petits ensembles de données et les résultats graphiques à jeter, oocalcest un bon utilitaire.

J'utilise un petit script python qui évalue une expression python et affiche le résultat, puis je peux exécuter quelque chose comme:

$ pc '[i ** 2 for i in range(10)]'
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

le script est:

#!/usr/local/bin/python3

import sys
import traceback
from codeop import CommandCompiler

compile = CommandCompiler()
filename = "<input>"
source = ' '.join(sys.argv[1:]) + '\n'

try:
    code = compile(source, filename) 
except (OverflowError, SyntaxError, ValueError):
    type, value, sys.last_traceback = sys.exc_info()
    sys.last_type = type
    sys.last_value = value
    if filename and type is SyntaxError:
        # Work hard to stuff the correct filename in the exception
        try:
            msg, (dummy_filename, lineno, offset, line) = value.args
        except ValueError:
            # Not the format we expect; leave it alone
            pass
        else:
            # Stuff in the right filename
            value = SyntaxError(msg, (filename, lineno, offset, line))
            sys.last_value = value
    lines = traceback.format_exception_only(type, value)
    print(''.join(lines))
else:
    if code:
        exec(code)
    else:
        print('incomplete')

Malheureusement, je ne me souviens pas d'où j'ai emprunté la majeure partie du code, je ne peux donc pas le citer.

Gnuplot

gnuplot - un programme de traçage interactif
Suivez le lien ci-dessus ou tapezgnuplotl'invite puishelpà l'intérieur de l'interpréteur gnuplot .
Gnuplot est un programme conçu pour tracer des données, mais peut également être utilisé pour le calcul. Il offre l’avantage que vous pouvez définir des fonctions et / ou utiliser les fonctions intégrées.

echo  "pr 20+5/2"  |  gnuplot          #  Lazy-note `pr` instead of print
22                                     #  Integer calculation & result
echo  "pr 20.+5/2"  |  gnuplot         #  Lazy-note `pr` instead of print
22.0                                   #  Floating point result
echo  "pr sin(2*pi/3.)"  |  gnuplot    #  Some functions ...
0.866025403784439

Racine (ou un autre interprète en C )

Le système ROOT fournit un ensemble de frameworks OO avec toutes les fonctionnalités nécessaires pour traiter et analyser de grandes quantités de données de manière très efficace ...

Vous pouvez l' utiliser comme interprète C , CINT , ou vous pouvez utiliser l' un des nombreux autres interprètes beaucoup C . IMHO, c'est énorme, complexe, puissant et pas toujours amical mais peut donner une grande satisfaction aussi.

Si vous ne voulez vraiment pas écouter la petite voix en vous qui cite Confucio et que vous êtes prêt à casser une mouche au beurre, vous pouvez utiliser root . Dans ce cas, il -lest obligatoire d'éviter d'afficher l'écran de démarrage ...

echo  "20+5/2"   | root -l
(const int)22
echo  "20+5/2."  | root -l
(const double)2.25000000000000000e+01

echo  "cout<< 20+5/2 << endl;"   | root -l
22

Pour l'arithmétique de nombre entier (où 3/2 = 1)

• bash echo $(( 1+1 ))
• fish math 1+1
• zsh* echo $((1+1))

*: et ksh93, yash

Pour l'arithmétique en virgule flottante (où 3/2 = 1,5)

• bash awk "BEGIN {print 10/3}" (faible précision)
• bash echo "10/3"|bc -l (haute précision)
• fish math -s4 10/3
• zsh* echo $((10./3))

*: et ksh93, yash

Vous pouvez bien sûr configurer votre shell pour utiliser awk avec un minimum de frappe comme calc 10/3(voir les notes sur la façon de le faire pour bash ¹ et fish ² ).

La raison principale de suggérer awk pour bash est qu'il est préinstallé sur presque tous les systèmes d'exploitation de type Unix et qu'il est relativement léger (il y a bien sûr le coût de démarrage d'un processus) avec une sortie moins précise mais plus conviviale que celle bc -lqui imprime 20 décimales. chiffres (bien que vous puissiez certainement modifier awk pour obtenir plus de chiffres décimaux ).

Remarques

(1) Comment utiliser la syntaxe simplifiée dans bash

Ajoutez cette fonction bash à votre ~/.bashrc:

calc(){ awk "BEGIN { print $*}"; }

(2) Comment utiliser la syntaxe simplifiée chez les poissons

Créez une calcfonction poisson (c'est-à-dire un fichier texte nommé /home/ndemou/.config/fish/functions/calc.fish):

function calc
    awk "BEGIN{ print $argv }" ;
end

Pour les calculs sur console, j'utilise concalc. ( sudo aptitude install concalc)

Après cela, tapez concalc et appuyez sur Entrée. Il ne fournira pas d'invite, mais il vous suffira de taper votre calcul (sans espace) et d'appuyer sur Entrée. La ligne suivante vous donnera la valeur numérique.

SQLite :

echo 'select 1 + 1;' | sqlite3 

MySQL :

mysql -e 'select 1 + 1 from dual;'

PostgreSQL :

psql -c 'select 1 + 1 as sum;'

Utilisez la bibliothèque arithmétique à précision multiple GNU via le run-exprprogramme fourni :

• Téléchargez et extrayez (vous aurez besoin de lzip): tar -xvf gmp-5.1.3.tar.lz
• Dans le répertoire principal ./configureet make(pas besoin d'installer)
• En démos / expr, make run-expr
• J'aime créer un lien symbolique vers celui-ci dans mon ~/binrépertoire:ln -s /path/to/gmp/demos/expr/run-expr ~/bin/run-expr
• Ajoutez un alias pour une utilisation facile. par exemple alias calcf='run-expr -f'pour l'évaluation en virgule flottante

Sortie:

# calcf '2/3'
"2/3" base 0: result 0.666666666666666666667e0

Du run-expr.cdossier:

Usage: ./run-expr [-z] [-q] [-f] [-p prec] [-b base] expression...

   Evaluate each argument as a simple expression.  By default this is in mpz
   integers, but -q selects mpq or -f selects mpf.  For mpf the float
   precision can be set with -p.  In all cases the input base can be set
   with -b, or the default is "0" meaning decimal with "0x" allowed.

Voir le manuel pour les différences et les détails des classes de fonctions.