Effectuer des opérations d'arrondi en C

Introduction

Dans ce laboratoire, vous apprendrez à effectuer des opérations d'arrondi en programmation C. Vous commencerez par déclarer des variables à virgule flottante, puis vous explorerez l'utilisation de différentes fonctions d'arrondi, telles que round(), floor(), et ceil(), pour manipuler les valeurs. Enfin, vous afficherez les résultats arrondis pour observer les différents comportements d'arrondi.

Ce laboratoire couvre les compétences fondamentales des opérations arithmétiques de base en C, fournissant une base solide pour travailler avec les nombres à virgule flottante et leurs techniques d'arrondi.

Déclaration de variables à virgule flottante

Dans cette étape, vous apprendrez à déclarer et initialiser des variables à virgule flottante en C, essentielles pour effectuer des opérations d'arrondi.

Commençons par créer un nouveau fichier C pour travailler avec des variables à virgule flottante :

cd ~/project
nano rounding.c

Ajoutez maintenant le code suivant au fichier :

#include <stdio.h>

int main() {
    // Déclaration de variables à virgule flottante
    float num1 = 3.7;
    double num2 = 4.2;

    // Affichage des valeurs originales
    printf("Valeur float originale : %.1f\n", num1);
    printf("Valeur double originale : %.1f\n", num2);

    return 0;
}

Compilez et exécutez le programme :

gcc rounding.c -o rounding
./rounding

Sortie exemple :

Valeur float originale : 3.7
Valeur double originale : 4.2

Décomposons le code :

• Nous utilisons float pour les nombres à virgule flottante simple précision.
• Nous utilisons double pour les nombres à virgule flottante double précision.
• Le spécificateur de format %.1f affiche le nombre avec une décimale.
• num1 et num2 sont initialisés avec des valeurs décimales.

Utilisation des fonctions d'arrondi (par exemple, round, floor, ceil)

Dans cette étape, vous apprendrez à utiliser les fonctions d'arrondi en C pour manipuler les nombres à virgule flottante. Nous allons modifier le fichier rounding.c précédent pour démontrer différentes techniques d'arrondi.

Ouvrez le fichier existant :

cd ~/project
nano rounding.c

Remplacez le contenu précédent par le code suivant :

#include <stdio.h>
#include <math.h>

int main() {
    // Déclaration de variables à virgule flottante
    float num1 = 3.7;
    double num2 = 4.2;

    // Arrondi des valeurs à l'aide de différentes fonctions
    printf("Valeurs originales :\n");
    printf("num1 : %.1f, num2 : %.1f\n\n", num1, num2);

    // Utilisation de la fonction round()
    printf("Fonction round :\n");
    printf("round(num1) : %.0f\n", round(num1));
    printf("round(num2) : %.0f\n\n", round(num2));

    // Utilisation de la fonction floor()
    printf("Fonction floor :\n");
    printf("floor(num1) : %.0f\n", floor(num1));
    printf("floor(num2) : %.0f\n\n", floor(num2));

    // Utilisation de la fonction ceil()
    printf("Fonction ceil :\n");
    printf("ceil(num1) : %.0f\n", ceil(num1));
    printf("ceil(num2) : %.0f\n", ceil(num2));

    return 0;
}

Compilez le programme avec la bibliothèque mathématique :

gcc rounding.c -o rounding -lm
./rounding

Sortie exemple :

Valeurs originales :
num1 : 3.7, num2 : 4.2

Fonction round :
round(num1) : 4
round(num2) : 4

Fonction floor :
floor(num1) : 3
floor(num2) : 4

Fonction ceil :
ceil(num1) : 4
ceil(num2) : 5

Points clés sur les fonctions d'arrondi :

• round(): Arrondi à l'entier le plus proche.
• floor(): Arrondi à l'entier inférieur ou égal le plus proche.
• ceil(): Arrondi à l'entier supérieur ou égal le plus proche.
• Le flag -lm est utilisé pour lier la bibliothèque mathématique lors de la compilation.
• Le spécificateur de format %.0f affiche les entiers sans décimales.

Affichage des résultats arrondis

Dans cette étape, vous apprendrez à formater et afficher les résultats arrondis avec différents niveaux de précision et options de formatage.

Ouvrez le fichier existant :

cd ~/project
nano rounding.c

Mettez à jour le code pour démontrer diverses techniques d'affichage :

#include <stdio.h>
#include <math.h>

int main() {
    // Déclaration de variables à virgule flottante
    float num1 = 3.7;
    double num2 = 4.2;

    // Démonstration d'arrondi avec différents formats d'affichage
    printf("Démonstration d'arrondi :\n");

    // Affichage des valeurs arrondies avec différentes précisions
    printf("1. Valeurs arrondies :\n");
    printf("   round(num1) = %.0f\n", round(num1));
    printf("   round(num2) = %.0f\n\n", round(num2));

    // Affichage avec largeur de champ et précision
    printf("2. Valeurs arrondies formatées :\n");
    printf("   Valeur arrondie de num1 avec largeur : %5.1f\n", round(num1));
    printf("   Valeur arrondie de num2 avec largeur : %5.1f\n\n", round(num2));

    // Affichage des représentations entières et à virgule flottante
    printf("3. Représentations entières et à virgule flottante :\n");
    printf("   num1 en entier : %d\n", (int)round(num1));
    printf("   num2 en entier : %d\n", (int)round(num2));

    return 0;
}

Compilez et exécutez le programme :

gcc rounding.c -o rounding -lm
./rounding

Sortie exemple :

Démonstration d'arrondi :
1. Valeurs arrondies :
   round(num1) = 4
   round(num2) = 4

2. Valeurs arrondies formatées :
   Valeur arrondie de num1 avec largeur :   4.0
   Valeur arrondie de num2 avec largeur :   4.0

3. Représentations entières et à virgule flottante :
   num1 en entier : 4
   num2 en entier : 4

Techniques d'affichage clés :

• %.0f supprime les décimales.
• %5.1f définit la largeur de champ et la précision.
• Le casting avec (int) convertit en entier.
• Différents spécificateurs de format contrôlent l'apparence de la sortie.

Résumé

Dans ce laboratoire, vous avez appris à déclarer des variables à virgule flottante, y compris float et double, et comment utiliser diverses fonctions d'arrondi telles que round(), floor(), et ceil() pour manipuler ces valeurs. Vous avez affiché les valeurs originales, puis utilisé les fonctions d'arrondi pour afficher les résultats arrondis. Cela vous a permis de comprendre les différents comportements de ces fonctions et comment elles peuvent être appliquées pour arrondir les nombres vers le haut, vers le bas ou à l'entier le plus proche.