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

295

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.

Michael Durrant
la source
1
Si vous y allez bc, cela vaut peut-être la peine de vous renseigner sur l' -loption dans la page de manuel.
Glenn Jackman
Je suppose que l'auteur demande une ligne de commande bash, alors que toutes les réponses ont tendance à se diversifier pour tous les types de langages de script.
Zinking
2
homme bash → / expression
ДМИТРИЙ МАЛИКОВ
1
@zinking Eh bien, bash est conçu pour pouvoir facilement invoquer les interprètes pour un grand nombre d'autres langages de script.
Random832
Enseignez la division entière bash avec les résultats en virgule flottante: stackoverflow.com/a/24431665/3776858
Cyrus

Réponses:

399

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
Stéphane Chazelas
la source
3
et bc est intéressant: whatis bc-> An arbitrary precision calculator language Intéressant! Merci!
Michael Durrant
@ MichaelDurrant pourriez-vous réviser vos modifications, j'ai dû rejeter par erreur?
lgarzo
4
Il y a aussi dc, ce qui est encore plus amusant car cela fonctionne par la notation polonaise inversée. echo 20 5 + p | dc Mais pas aussi pratique à moins de travailler beaucoup avec la notation polonaise inversée.
Arcege
2
En variante de l'approche bc, j'ai ajouté la fonction suivante (que j'ai trouvée quelque part sur stackexchange) dans mon fichier .bashrc. Je peux juste entrer calc 2 + 3 et obtenir 5. ## Command line calculator calc () { bc -l <<< "$@" }
Joe
1
@ Chris, le poisson est une cible mouvante. Ils travaillent sur leur nouvelle mathstructure (ou ce que l'on appelle maintenant) en ce moment même. N'hésitez pas à éditer. Ce n'est pas ma réponse et c'est un wiki de communauté.
Stéphane Chazelas
35

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.

se ruer
la source
J'ai ajouté votre exproption à la réponse acceptée. J'ai dû en choisir un pour l'accepter et le centraliser.
Michael Durrant
3
Vous essayez d'exécuter expr 20+5. Vous devez saisir les espaces entre les nombres et plus pour le faire fonctionner: expr 20 + 5. C'est important.
précipiter
24

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
Marco
la source
2
bcLe résultat de n'est pas entier, mais arrondi à scalela valeur par défaut qui est 0. Donc, bc <<< 'scale=4;9.0/2.0'si vous voulez la partie décimale.
Manatwork
Merci pour la correction. Mais encore, c'est sujette aux erreurs. Est-ce que je vais me rappeler d'ajouter scalesi je l'utilise bcdans quelques semaines? Probablement pas. Et même s'il existe un moyen de le changer de façon permanente, il vous mordra si vous êtes sur un système avec les paramètres par défaut.
Marco
3
Personnellement, je m'en souviens scaledepuis ma bcpremière rencontre il y a des années. Mais j'ai toujours oublié si la fonction de sortie luaest putou puts. ;)
manatwork
Comptez simplement bc comme l’un des langages de script. Je sais toujours si j'ai besoin de résultats entiers ou non - si l'entier est correct, je reste en bash, sinon j'ai rarement des raisons d'utiliser bc. Pour Lua, vous devez vous rappeler -e, print et parenthesis.
utilisateur inconnu
7
Toujours utiliser bc -lplutôt que simple bc, alors ne vous inquiétez pas scale.
Dalker
23

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.

Josué
la source
2
Wow c'est le meilleur, même supporte les flotteurs. Cela fonctionne sans rien installer!
CMCDragonkai
1
Très bien, je voulais avoir une comparaison flottante, voici comment je l’ai fait avec votre aide:a=0; b=0.0; if echo "$a" "$b" | awk '{ exit ($1 == $2) ? 0 : 1 }'; then echo 'equals'; else echo 'not equals'; fi
Paul Tobias
18

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

Levon
la source
1
+1 pour les options de mode canal ("|") et interactif pour bs. Est-ce qu'on ctrl-dsort?
Michael Durrant
1
@MichaelDurrant Oui, ^ D fera l'affaire comme il le voudraquit
Levon
c () { bc -l <<< "$@" } définira une fonction c pour une utilisation rapide et facile. par exemple c 3/2va vous donner 1.50000000000000000000. Le lien ci-dessus décrivant la marche à suivre est mort.
ijoseph
1
@ Levon, le lien vers la page de manuel fonctionne toujours. Toutefois, le lien: paweng.com/2008/08/15/unix-command-line-calculator , que vous spécifiez comme cible de "This" dans la phrase "Cette page explique également comment configurer un alias ..." apparaît. mort.
ijoseph
1
@ijoseph Merci .. J'ai supprimé la référence à ce lien âgé de 6 ans (j'aimerais que les liens ressortent plus clairement sur mon navigateur - je ne l'ai même pas vu quand j'ai regardé hier)
Levon
16

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

KennyPeanuts
la source
1
Vous n'avez pas besoin d'entrer en mode interactif, sauf si vous le souhaitez particulièrement, par exemple: calc -e '2+4; 3+5; 3.4+5; 2^4imprime 4 lignes de sortie, ou tout simplement calc -e 33+(3^3).. +1 J'aime l'idée d'utiliser quelque chose appelé 'calc' pour une calculatrice :)
Peter.O
1
Je viens de me rendre compte que l' -eoption n'est pas nécessaire lorsqu'il n'y a qu'une seule expression ... soignée! ..
Peter.O
10

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

Asmeurer
la source
moi aussi! Python est mon couteau suisse
Levon
J'ai toujours une fenêtre en screencours d'exécution uniquement en Python.
Arcege
1
pythonpy ( github.com/russell91/pythonpy ) est une bonne façon de faire ceci et d'autres choses en syntaxe python sans avoir à lancer un shell interactif: py '3.2 * 5' => 16
RussellStewart le
J'aime le python, mais le temps de démarrage devient important si vous souhaitez simplement ajouter deux nombres à quelques endroits de votre script bash
ndemou
@ndemou j'ai dit calculatrice "interactive". Bien qu’il soit également intéressant de noter qu’à un moment donné, si vous faites assez de choses complexes dans un script, la raison en est que vous utilisez autre chose que bash (comme Python).
Asmeurer
10

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
Au hasard832
la source
Il y a tellement d'options qui n'exigent pas l'installation d'un programme supplémentaire que je ne vois pas pourquoi on voudrait procéder de cette façon.
ndemou
@ndemou Il est installé par défaut sur certaines distributions ... et beaucoup d'autres réponses ne le sont pas. Et aviez-vous vraiment besoin de commenter une réponse datant de cinq ans?
Random832
1
Je pense qu'il est bon de commenter lorsque je vote par sous. C'est une pratique également encouragée par SE. Je ne vois pas pourquoi une période de cinq ans est pertinente. Le même commentaire s'applique à toutes les réponses similaires - rien de personnel. (BTW, même le programme le plus obscur peut être installé par défaut sur certaines distributions. Dans ce cas, j'ai testé les installations récentes de Debian, Ubuntu, CentOS et RedHat et les unités ne sont pas)
ndemou
6
$> 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
ДМИТРИЙ МАЛИКОВ
la source
3
Est- ghcce que cela signifie Glasgow Haskell Compiler?
Manatwork
prendre une passe sur les programmes que je dois installer, mais merci.
Michael Durrant
4

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.

Utilisateur inconnu
la source
4

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.

cobbal
la source
ne ferait pas print(eval(' '.join(sys.argv[1:])))la même chose?
g.rocket
Vous utilisez un marteau pour frapper une mouche ici.
ndemou
4

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
Hastur
la source
4

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 1 et fish 2 ).

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
Ndemou
la source
awkutilisera le type de doublevirgule flottante de votre système , donc sera aussi précis que la plupart des autres outils qui ne font pas de précision arbitraire (notez que gawk peut faire une précision arbitraire). awkutilise la OFMTvariable pour convertir nombre en représentation sous forme de chaîne pour la sortie ( %.6gpar défaut, vous souhaiterez peut-être modifier cette valeur si %.17gvous souhaitez une précision supérieure ).
Stéphane Chazelas
Notez que fishl » mathest juste une fonction qui appelle bc(si c'est à changer )
Stéphane Chazelas
1
Eh bien, c'était une fonction qui appelle bc. Ce n'est plus dans les nouvelles versions où des choses comme math "scale=4; 10/3"ne fonctionneront plus (à la math -s4 10/3place maintenant)
Stéphane Chazelas
Merci Stéphane Chazelas - J'ai mis à jour ma réponse (cela math -s4semble également être supporté par les anciennes versions)
ndemou
3

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.

Killermist
la source
3

SQLite :

echo 'select 1 + 1;' | sqlite3 

MySQL :

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

PostgreSQL :

psql -c 'select 1 + 1 as sum;'
Vidul
la source
3
Quelques détails mineurs qui méritent d’être mentionnés: 1) from dualest nécessaire pour Oracle, MySQL peut le faire selectsans fromclause. 2) PostgreSQL ne nécessite pas l’alias. 3) Le ;n'est requis que par SQLite. 4) MySQL et PostgreSQL ne fonctionneront que s’ils peuvent se connecter à un serveur de base de données. 5) MySQL et PostgreSQL vont dessiner un tableau d’art ASCII autour des résultats. Pour obtenir uniquement la valeur: mysql -BNe 'select 1+1'et psql -tAc 'select 1+1.
manatwork
2

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.


la source