Explication des opérations mathématiques bash (arithmétique bash)

Présentation

Les opérations mathématiques et arithmétiques sont essentielles dans les scripts Bash. Diverses tâches d'automatisation nécessitent des opérations arithmétiques de base, telles que la conversion de la température du processeur en Fahrenheit. L'implémentation d'opérations mathématiques dans Bash est simple et très facile à apprendre.

Ce guide vous apprend à faire des calculs de base dans Bash de différentes manières.

Prérequis

• Accès à la ligne de commande/au terminal.
• Un éditeur de texte pour coder des exemples, tels que nano ou Vi/Vim.
• Connaissance de base des scripts Bash.

Pourquoi avez-vous besoin de mathématiques dans les scripts Bash ?

Bien que les mathématiques ne soient pas l'objectif principal des scripts Bash, savoir comment effectuer des calculs essentiels est utile pour divers cas d'utilisation.

Les cas d'utilisation courants incluent :

• Addition/soustraction/multiplication/division de nombres.
• Arrondir les nombres.
• Incrémenter et décrémenter des nombres.
• Convertir des unités.
• Calculs en virgule flottante.
• Rechercher des pourcentages.
• Travailler avec différentes bases numériques (binaire, octale ou hexadécimale).

Selon la tâche d'automatisation, les mathématiques et l'arithmétique de base dans les scripts Bash permettent d'effectuer un calcul rapide, donnant des résultats immédiats dans le format souhaité.

Commandes et méthodes mathématiques bash

Certaines commandes Linux permettent d'effectuer immédiatement des calculs de base et avancés. Cette section montre des exemples mathématiques de base avec chaque méthode.

Développement arithmétique

La meilleure façon de faire des calculs dans Bash est d'utiliser l'expansion arithmétique du shell. La fonctionnalité intégrée évalue les expressions mathématiques et renvoie le résultat. La syntaxe des développements arithmétiques est :

$((expression))

La syntaxe consiste en :

• Notation composée (()) qui évalue l'expression.
• L'opérateur variable $ pour stocker le résultat.

Par exemple, additionnez deux nombres et affichez le résultat :

echo $((2+3))

La notation d'expansion arithmétique est la méthode préférée lorsque vous travaillez avec des scripts Bash. La notation est souvent vue avec if instructions et boucles for dans Bash.

Commande awk

La commande awk agit comme un sélecteur pour les expressions de modèle. Par exemple, pour effectuer un ajout à l'aide de awk commande, utilisez l'exemple d'instruction suivant :

awk 'BEGIN { x = 2; y = 3; print "x + y = "(x+y) }'

Pour les variables x = 2 et y = 3 , la sortie imprime x + y = 5 à la console.

Commande bc

Le bc commande (abréviation de b asique c alculator) est un utilitaire de ligne de commande qui affiche le langage bc. Le programme s'exécute comme un programme interactif ou accepte une entrée standard pour effectuer une arithmétique de précision arbitraire.

Pipe une équation de l'entrée standard dans la commande pour récupérer les résultats. Par exemple :

echo "2+3" | bc

La sortie imprime le résultat du calcul.

Commande dc

Le dc commande (abréviation de d esk c alculator) est un utilitaire de calcul qui prend en charge la notation polonaise inversée. Le programme prend une entrée standard et prend en charge l'arithmétique de précision illimitée.

Pipe une équation d'entrée standard dans la commande pour récupérer le résultat. Par exemple :

echo "2 3 + p" | dc

Le p dans l'équation envoie le signal d'impression au dc commande.

déclarer la commande

La commande Bash declare permet des calculs d'entiers. Pour utiliser declare pour les calculs, ajoutez le -i option. Par exemple :

declare -i x=2 y=3 z=x+y

Echo chaque variable pour voir les résultats :

echo $x + $y = $z

La sortie imprime chaque variable sur la console.

Commande expr

L'expr command est un utilitaire de ligne de commande hérité pour évaluer l'arithmétique des nombres entiers. Un exemple expr commande ressemble à ceci :

expr 2 + 3

Séparez les nombres et le signe d'opération par des espaces et exécutez la commande pour voir le résultat du calcul.

Commande de facteur

Le factor command est un utilitaire de ligne de commande qui imprime les facteurs pour tout entier positif, et le résultat est factorisé en nombres premiers.

Par exemple, pour imprimer les facteurs du nombre 100, exécutez :

factor 100

La sortie imprime le nombre factorisé.

let Command

La commande Bash let effectue diverses opérations arithmétiques, binaires et logiques. La commande intégrée ne fonctionne qu'avec des nombres entiers. L'exemple suivant illustre le let syntaxe de commande :

let x=2+3 | echo $x

La sortie imprime les résultats.

tester la commande

Le test La commande sous Linux évalue les expressions conditionnelles et s'associe souvent à l'instruction Bash if. Il existe deux variantes pour la syntaxe de test :

test 2 -gt 3; echo $?

Ou alternativement :

[ 2 -gt 3 ]; echo $?

Le test la commande évalue si deux est supérieur à (-gt ) Trois. Si l'expression est vraie, la sortie est zéro (0 ), ou un (1 ) si faux.

Opérateurs arithmétiques bash

Bash propose une large gamme d'opérateurs arithmétiques pour divers calculs et évaluations. Les opérateurs travaillent avec le let , declare , et développement arithmétique.

Vous trouverez ci-dessous un tableau de référence rapide qui décrit les opérateurs arithmétiques Bash et leurs fonctionnalités.

Syntaxe	Description
++x , x++	Pré et post-incrément.
--x , x--	Pré et post-décrémentation.
+ , - , * , /	Addition, soustraction, multiplication, division.
% , ** (ou ^ )	Modulo (reste) et exponentiation.
&& , || , !	ET logique, OU et négation.
& , | , ^ , ~	ET au niveau du bit, OU, XOR et négation.
<= , < , > , =>	Inférieur ou égal à, inférieur à, supérieur à et supérieur ou égal à des opérateurs de comparaison.
== , !=	Opérateurs de comparaison d'égalité et d'inégalité.
=	Opérateur d'affectation. Se combine avec d'autres opérateurs arithmétiques.

Comment faire des maths dans Bash

Bash propose différentes manières d'effectuer des calculs mathématiques en fonction du type de problème.

Vous trouverez ci-dessous des exemples de problèmes courants qui utilisent les fonctionnalités ou les commandes mathématiques de Bash comme solution. La plupart des exemples utilisent la notation d'expansion arithmétique Bash. La section couvre également les erreurs mathématiques courantes de Bash et comment les résoudre.

Mathématiques avec des entiers

La notation d'expansion arithmétique est la plus simple à utiliser et à manipuler lorsque vous travaillez avec des nombres entiers. Par exemple, créez une expression avec des variables et calculez immédiatement le résultat :

echo $((x=2, y=3, x+y))

Pour évaluer plusieurs expressions, utilisez la notation composée, stockez chaque calcul dans une variable et affichez le résultat. Par exemple :

((x=2, y=3, a=x+y, b=x*y, c=x**y)); echo $a, $b, $c

Lorsque vous essayez de diviser, gardez à l'esprit ce qui suit :

1. La division par zéro (0) est impossible et génère une erreur.

2. L'expansion arithmétique bash ne prend pas en charge l'arithmétique à virgule flottante. Lors d'une tentative de division dans ce cas, la sortie affiche zéro (0).

Le résultat de la division entière doit être un entier.

Incrémentation et décrémentation

L'expansion arithmétique de Bash utilise l'incrémentation et la décrémentation d'entiers de style C. L'opérateur d'incrémentation ou de décrémentation se trouve avant ou après la variable, ce qui donne un comportement différent.

Si l'opérateur est avant la variable (++x ou --x ), l'incrémentation ou la décrémentation se produit avant l'affectation de la valeur. Pour voir comment fonctionne la pré-incrémentation, exécutez les lignes suivantes :

number=1

echo $((++number))

La variable s'incrémente et la nouvelle valeur est immédiatement disponible.

Si l'opérateur est après la variable (x++ ou x-- ), l'incrémentation ou la décrémentation se produit après l'affectation de la valeur. Pour voir comment fonctionne la post-incrémentation, exécutez ce qui suit :

number=1

echo $((number++))

echo $number

La variable reste la même et s'incrémente dans l'utilisation suivante.

Arithmétique à virgule flottante

Bien que l'expansion arithmétique de Bash ne prenne pas en charge l'arithmétique à virgule flottante, il existe d'autres façons d'effectuer de tels calculs. Vous trouverez ci-dessous quatre exemples utilisant des commandes ou des langages de programmation disponibles sur la plupart des systèmes Linux.

1. Utilisation de awk jusqu'à 6 décimales :

awk 'BEGIN { x = 2.3; y = 3.2; print "x * y = "(x * y) }'

2. Utilisation de bc avec le -l indicateur jusqu'à 20 décimales :

echo "2.3 * 3.2" | bc -l

3. Utilisation de Perl jusqu'à 20 décimales :

perl -e 'print 2.3*3.2'

Perl est souvent préinstallé sur les systèmes Linux.

4. Utiliser printf et l'expansion arithmétique pour convertir une fraction en nombre décimal :

printf %.<precision>f "$((10**<multiplier> * <fraction>))e-<multiplier>"

La précision dicte le nombre de décimales, alors que le multiplicateur est une puissance de dix. Le nombre doit être inférieur au multiplicateur. Sinon, la formule place des zéros à droite dans le résultat.

Par exemple, convertissez 1/3 en nombre décimal avec précision deux :

printf %.2f "$((10**3 * 1/3))e-3"

Évitez cette méthode pour des calculs précis et utilisez-la uniquement pour un petit nombre de décimales.

Calculer un pourcentage et arrondir

Vous trouverez ci-dessous deux façons de calculer un pourcentage dans Bash.

1. Utilisez printf avec expansion arithmétique.

printf %.2f "$((10**4 * part/total))e-4"%

Par exemple, calculez quel pourcentage 40 est de 71 :

printf %.2f%% "$((10**4 * 40/71))e-4"%

La précision est limitée à deux décimales et la réponse est toujours arrondie à l'inférieur.

2. Utilisez awk avec printf pour une meilleure précision :

awk 'BEGIN { printf "%.2f%%", (part/total*100) }'

Par exemple, calculez combien de pourcentages sont 40 sur 71 avec :

awk 'BEGIN { printf "%.2f%%", (40/71*100) }'

La réponse est arrondie si la troisième décimale est supérieure à cinq, ce qui offre une meilleure précision.

Trouver une factorielle dans le shell

Pour calculer une factorielle pour n'importe quel nombre, utilisez une fonction Bash récursive.

Pour les petits nombres, l'expansion arithmétique de Bash fonctionne bien :

factorial () { 
    if (($1 > 1))
    then
        echo $(( $( factorial $(($1 - 1)) ) * $1 ))
    else

        echo 1
        return
    fi
}

Pour vérifier la factorielle d'un nombre, utilisez la syntaxe suivante :

factorial 5

La méthode est lente et a une précision limitée (jusqu'au factoriel 20).

Pour une plus grande précision, des résultats plus rapides et des nombres plus importants, utilisez le bc commande. Par exemple :

echo 'define factorial(x) {if (x>1){return x*factorial(x-1)};return 1}
 factorial(<number>)' | bc

Remplacer <number> avec le nombre factoriel à calculer. Par exemple, pour trouver la factorielle de 50, utilisez :

echo 'define factorial(x) {if (x>1){return x*factorial(x-1)};return 1} factorial(50)' | bc

La sortie imprime le résultat du calcul sur le terminal.

Création d'une fonction de calculatrice Bash

Créez une simple fonction de calculatrice Bash avec le code suivant :

calculate() { printf "%s\n" "[email protected]" | bc -l; }

La fonction prend l'entrée de l'utilisateur et dirige l'équation dans le bc commande.

Alternativement, pour éviter d'utiliser des programmes, utilisez l'expansion arithmétique Bash dans une fonction :

calculate() { echo $(("[email protected]")); }

Gardez à l'esprit les limites de l'expansion arithmétique. L'arithmétique à virgule flottante n'est pas disponible avec cette fonction.

Enregistrez la fonction dans le .bashrc fichier pour que la fonction soit toujours disponible dans le shell.

Utiliser différentes bases arithmétiques

Par défaut, l'expansion arithmétique de Bash utilise des nombres en base dix. Pour changer la base numérique, utilisez le format suivant :

base#number

Où base est un entier compris entre deux et 64.

Par exemple, pour faire un calcul binaire (base 2), utilisez :

echo $((2#1010+2#1010))

Les calculs octaux (base 8) utilisent un préfixe 0 comme alias. Par exemple :

echo $((010+010))

Les calculs hexadécimaux (base 16) permettent d'utiliser 0x comme préfixe de base. Par exemple :

echo $((0xA+0xA))

La sortie imprime le résultat en base dix pour tout calcul.

Convertir des unités

Créez un script Bash simple pour convertir les unités :

1. Ouvrez un éditeur de texte, tel que Vim, et créez un convert.sh scénario. Par exemple :

vim convert.sh

2. Collez le code suivant :

#!/bin/bash

## Program for feet and inches conversion

echo "Enter a number to be converted:"

read number

echo $number feet to inches:
echo "$number*12" | bc -l

echo $number inches to feet:
echo "$number/12" | bc -l

Le programme utilise la lecture Bash pour prendre les entrées de l'utilisateur et calculer la conversion des pieds en pouces et des pouces en pieds.

3. Enregistrez le script et fermez :

:wq

4. Exécutez le script Bash avec :

. convert.sh

Entrez un nombre et voyez le résultat. Pour différentes conversions, utilisez les formules de conversion appropriées.

Résoudre "l'erreur bash :la valeur est trop grande pour la base"

Lorsque vous travaillez avec différentes bases de nombres, respectez les limites des bases de nombres. Par exemple, les nombres binaires utilisent 0 et 1 pour définir des nombres :

echo $((2#2+2#2))

Tentative d'utilisation de 2#2 comme un nombre génère une erreur :

bash: 2#2: value too great for base (error token is "2#2")

Le nombre n'est pas au format correct pour une utilisation binaire. Pour résoudre l'erreur, convertissez le nombre en binaire pour effectuer le calcul correctement :

echo $((2#10+2#10))

Le nombre binaire 10 est 2 en base dix.

Résoudre "l'erreur de syntaxe :opérateur arithmétique invalide"

La notation d'expansion arithmétique Bash ne fonctionne que pour les calculs d'entiers. Essayez d'ajouter deux nombres à virgule flottante, par exemple :

echo $((2.1+2.1))

La commande affiche une erreur :

bash: 2.1+2.1: syntax error: invalid arithmetic operator (error token is ".1+2.1")

Pour résoudre l'erreur, utilisez l'arithmétique régulière des nombres entiers ou une autre méthode pour calculer l'équation.

Résoudre "l'erreur bash :expression entière attendue"

Lors de la comparaison de deux nombres, le test La commande nécessite des nombres entiers. Par exemple, essayez la commande suivante :

[ 1 -gt 1.5 ]

La sortie affiche une erreur :

bash: [: 1.5: integer expression expected

Résolvez l'erreur en comparant les valeurs entières.