Travailler avec l'arithmétique à virgule flottante en C

Introduction

Dans ce labo (laboratoire), vous allez apprendre à travailler avec l'arithmétique à virgule flottante en C. Vous commencerez par déclarer des variables de type float et double, puis effectuerez diverses opérations arithmétiques sur elles, et enfin, afficherez les résultats avec une précision appropriée. Ce labo couvre les compétences essentielles pour travailler avec des nombres décimaux et effectuer des calculs mathématiques précis en programmation C.

La première étape montre comment déclarer des variables à virgule flottante en utilisant les types de données float et double, et comment afficher les valeurs avec la précision souhaitée. La deuxième étape se concentre sur l'exécution d'opérations arithmétiques, telles que l'addition, la soustraction, la multiplication et la division, sur des nombres à virgule flottante.

Déclarer des variables de type float ou double

Dans cette étape, vous allez apprendre à déclarer des variables à virgule flottante en C en utilisant les types de données float et double. Les variables à virgule flottante sont essentielles pour stocker des nombres décimaux et effectuer des calculs mathématiques précis.

Tout d'abord, créons un nouveau fichier C pour démontrer les déclarations de variables :

cd ~/project
nano floating_variables.c

Maintenant, ajoutez le code suivant au fichier :

#include <stdio.h>

int main() {
    // Declaring float variables
    float temperature = 98.6;
    float price = 19.99;

    // Declaring double variables
    double pi = 3.14159265359;
    double large_number = 1234567890.123456789;

    // Printing the variables
    printf("Temperature (float): %.2f\n", temperature);
    printf("Price (float): %.2f\n", price);
    printf("Pi (double): %.5f\n", pi);
    printf("Large Number (double): %.9f\n", large_number);

    return 0;
}

Compilez et exécutez le programme :

gcc floating_variables.c -o floating_variables
./floating_variables

Exemple de sortie :

Temperature (float): 98.60
Price (float): 19.99
Pi (double): 3.14159
Large Number (double): 1234567890.123456789

Analysons le code :

• float est utilisé pour les nombres à virgule flottante à précision simple (généralement 4 octets)
• double est utilisé pour les nombres à virgule flottante à précision double (généralement 8 octets)
• Les spécificateurs de format %.2f et %.5f contrôlent la précision des décimales lors de l'affichage

Effectuer des opérations arithmétiques sur des valeurs à virgule flottante

Dans cette étape, vous allez apprendre à effectuer diverses opérations arithmétiques sur des nombres à virgule flottante en C, y compris l'addition, la soustraction, la multiplication et la division.

Modifions le fichier précédent pour démontrer l'arithmétique à virgule flottante :

cd ~/project
nano floating_arithmetic.c

Ajoutez le code suivant au fichier :

#include <stdio.h>

int main() {
    // Declare floating-point variables
    float a = 10.5;
    float b = 3.2;

    // Addition
    float sum = a + b;
    printf("Addition: %.2f + %.2f = %.2f\n", a, b, sum);

    // Subtraction
    float difference = a - b;
    printf("Subtraction: %.2f - %.2f = %.2f\n", a, b, difference);

    // Multiplication
    float product = a * b;
    printf("Multiplication: %.2f * %.2f = %.2f\n", a, b, product);

    // Division
    float quotient = a / b;
    printf("Division: %.2f / %.2f = %.2f\n", a, b, quotient);

    // Mixed arithmetic operations
    float mixed_calc = (a + b) * (a - b) / b;
    printf("Mixed Calculation: (%.2f + %.2f) * (%.2f - %.2f) / %.2f = %.2f\n",
           a, b, a, b, b, mixed_calc);

    return 0;
}

Compilez et exécutez le programme :

gcc floating_arithmetic.c -o floating_arithmetic
./floating_arithmetic

Exemple de sortie :

Addition: 10.50 + 3.20 = 13.70
Subtraction: 10.50 - 3.20 = 7.30
Multiplication: 10.50 * 3.20 = 33.60
Division: 10.50 / 3.20 = 3.28
Mixed Calculation: (10.50 + 3.20) * (10.50 - 3.20) / 3.20 = 24.41

Points clés concernant l'arithmétique à virgule flottante :

• Utilisez le spécificateur de format %.2f pour contrôler la précision décimale
• Les opérations à virgule flottante suivent les règles mathématiques standard
• Soyez conscient des limitations potentielles de précision lors des calculs à virgule flottante

Afficher les résultats avec une précision appropriée

Dans cette étape, vous allez apprendre à contrôler la précision de la sortie des nombres à virgule flottante en utilisant des spécificateurs de format en C.

Créez un nouveau fichier pour explorer différents formats de précision :

cd ~/project
nano floating_precision.c

Ajoutez le code suivant au fichier :

#include <stdio.h>

int main() {
    // Declare floating-point variables
    double pi = 3.14159265358979323846;
    double large_number = 1234567.89012345;

    // Default printing (limited precision)
    printf("Default printing:\n");
    printf("Pi: %f\n", pi);
    printf("Large Number: %f\n\n", large_number);

    // Controlling decimal places
    printf("Controlled Precision:\n");
    printf("Pi with 2 decimal places: %.2f\n", pi);
    printf("Pi with 5 decimal places: %.5f\n", pi);
    printf("Pi with 10 decimal places: %.10f\n\n", pi);

    // Scientific notation
    printf("Scientific Notation:\n");
    printf("Large Number (default): %e\n", large_number);
    printf("Large Number (3 decimal places): %.3e\n\n", large_number);

    // Width and precision combined
    printf("Width and Precision:\n");
    printf("Pi (width 10, 4 decimal places): %10.4f\n", pi);
    printf("Large Number (width 15, 2 decimal places): %15.2f\n", large_number);

    return 0;
}

Compilez et exécutez le programme :

gcc floating_precision.c -o floating_precision
./floating_precision

Exemple de sortie :

Default printing:
Pi: 3.141593
Large Number: 1234567.890123

Controlled Precision:
Pi with 2 decimal places: 3.14
Pi with 5 decimal places: 3.14159
Pi with 10 decimal places: 3.1415926536

Scientific Notation:
Large Number (default): 1.234568e+06
Large Number (3 decimal places): 1.235e+06

Width and Precision:
Pi (width 10, 4 decimal places):      3.1416
Large Number (width 15, 2 decimal places):     1234567.89

Points clés concernant le formatage de précision :

• %f est le spécificateur de format par défaut pour les nombres à virgule flottante
• .2f signifie 2 décimales, .5f signifie 5 décimales
• %e ou %E affiche la notation scientifique
• Les spécificateurs de largeur aident à aligner et à formater la sortie

Résumé

Dans ce labo (laboratoire), vous avez appris à déclarer des variables à virgule flottante en utilisant les types de données float et double, ainsi qu'à effectuer des opérations arithmétiques sur ces valeurs, y compris l'addition, la soustraction, la multiplication et la division. Vous avez également appris à contrôler la précision des décimales lors de l'affichage de nombres à virgule flottante en utilisant des spécificateurs de format. Ces compétences sont essentielles pour travailler avec des données décimales et effectuer des calculs mathématiques précis en programmation C.