Forum du club des d�veloppeurs et IT Pro - Algorithmes et structures de donn�es

Repr�sentation des nombres en machine : pr�cision, limites et pi�ges

User — Mon, 27 Apr 2026 18:49:35 GMT

Bonjour,

Je vous propose un nouvel article : � Repr�sentation des nombres en machine : pr�cision, limites et pi�ges �.

L'objectif est d�expliquer les diff�rences entre les nombres en math�matiques et leur repr�sentation en machine, en mettant l�accent sur les nombres � virgule flottante, la norme IEEE 754 et les erreurs num�riques associ�es.

Il s�adresse � des d�veloppeurs ayant des bases en programmation et vise � rendre accessibles des notions souvent sources de confusion (par exemple : pourquoi 0.1 + 0.2 ≠ 0.3).

Le contenu couvre :

les bases de la repr�sentation binaire ;
le fonctionnement des nombres flottants ;
la structure IEEE 754 ;
les erreurs d�arrondi et leurs cons�quences ;
ainsi que quelques notions plus avanc�es (cancellation catastrophique, perte de pr�cision, somme de Kahan).

Tous les exemples sont r�alis�s en Python, mais les concepts pr�sent�s sont transposables � la plupart des langages.

Bonne lecture ;)

Images attach�es

Math�matiques ensemble Q les quotients

GraineDeDev — Thu, 12 Feb 2026 12:43:10 GMT

Bonjour !
Je suis peut-etre en train de r�inventer la roue...
Deux petits bouts de code pour utiliser, modeliser des quotients...
C'est gratuit et libre... Vous pouvez utiliser, modifier � votre guise :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
 
#ifndef QTT
#define QTT
 
    class quotient
    {
        private:
            int numerateur;
            int denominateur;
 
        public:
            quotient(){numerateur = 1; denominateur = 1;}
            quotient(int, int);
            quotient(int n){numerateur = n; denominateur = 1;}
            void reduire();
            void addition(quotient, quotient);
            void soustraction(quotient, quotient);
            void multiplication(quotient, quotient);
            void division(quotient, quotient);
            void saisie();
            void affichage();
    };

et :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
 
 
#include "quotient.hpp"
#include 
 
quotient::quotient(int n, int d)
{
    if (d == 0)
    {
        std::cout << "erreur !\ndivision par zero !\n";
    }
    else
    {
        numerateur = n;
        denominateur = d;
        reduire();
    }
}
 
void quotient::saisie()
{
    int n, d;
    std::cout << "numerateur : ";
    std::cin >> n;
    std::cout << "denominateur : ";
    std::cin >> d;
    if (d == 0)
    {
        std::cout << "erreur !\ndivision par zero !\n";
    }
    else
    {
        numerateur = n;
        denominateur = d;
        reduire();
    }
}
 
void quotient::affichage()
{
    if (numerateur == 0){std::cout << "0\n"; return;}
    if (denominateur == 1){std::cout << numerateur << '\n';}
    else
    {std::cout << numerateur << '/' << denominateur << '\n';}
}
 
void quotient::addition(quotient a, quotient b)
{
    numerateur = a.numerateur*b.denominateur + b.numerateur*a.denominateur;
    denominateur = a.denominateur*b.denominateur;
    reduire();
}
void quotient::soustraction(quotient a, quotient b)
{
    numerateur = a.numerateur*b.denominateur - b.numerateur*a.denominateur;
    denominateur = a.denominateur*b.denominateur;
    reduire();
}
 
void quotient::multiplication(quotient a, quotient b)
{
    numerateur = a.numerateur*b.numerateur;
    denominateur = a.denominateur*b.denominateur;
    reduire();
}
void quotient::division(quotient a, quotient b)
{
    numerateur = a.numerateur*b.denominateur;
    denominateur = a.denominateur*b.numerateur;
    reduire();
}
 
void quotient::reduire()
{
    if (numerateur <= denominateur)
    {
        int m = 2;
        while (m <= numerateur)
        {
            if (numerateur%m == 0 && denominateur%m == 0)
            {numerateur = numerateur/m; denominateur = denominateur/m;}
            else
            {m++;}
        }
    }
    else
    {
        int m = 2;
        while (m <= denominateur)
        {
            if (numerateur%m == 0 && denominateur%m == 0)
            {numerateur = numerateur/m; denominateur = denominateur/m;}
            else
            {m++;}
        }
    }
}

Ca m�riterait d'etre am�lior�.
Je suis plutot fier de mon algorithme de reduction de la fraction.

Algorithmes pseudo code Algobox

chlock62 — Fri, 12 Sep 2025 14:41:14 GMT

Bonjour, j'utilise Algo box afin de r�aliser mes instructions algorithmiques, cependant j'essaie d'utiliser l'appel de fonction ci-dessous :

Ma fonction est la suivante :

Code:

1
2
3
4
5
6
7
8
9
10
FONCTIONS_UTILISEES
  FONCTION rendreTableau(tab)
    VARIABLES_FONCTION
      u EST_DU_TYPE NOMBRE
    DEBUT_FONCTION
    POUR u ALLANT_DE u A 7
      DEBUT_POUR
      AFFICHER* tab[u]
      FIN_POUR
    FIN_FONCTION

Mon appel de fonction ci-dessous :

Code:

APPELER_FONCTION rendreTableau(T)

H�las l'algorithme ci-dessous ne fonctionne pas a cause de la fonction, celle-ci l'arr�te !!, celle-ci et t'elle bien d�clar� et app�l� avec ses diff�rents passage de param�tres ?

L'algorithme au complet ci-dessous:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
 
FONCTIONS_UTILISEES
  FONCTION rendreTableau(tab)
    VARIABLES_FONCTION
      u EST_DU_TYPE NOMBRE
      tab EST_DU_TYPE LISTE
    DEBUT_FONCTION
    //tableau PREND_LA_VALEUR tab
    POUR u ALLANT_DE u A 7
      DEBUT_POUR
      AFFICHER* tab[u]
      FIN_POUR
    FIN_FONCTION
VARIABLES
  i EST_DU_TYPE NOMBRE
  j EST_DU_TYPE NOMBRE
  T EST_DU_TYPE LISTE
  temp EST_DU_TYPE NOMBRE
  posmin EST_DU_TYPE NOMBRE
DEBUT_ALGORITHME
  T[0] PREND_LA_VALEUR 25
  T[1] PREND_LA_VALEUR 10
  T[2] PREND_LA_VALEUR 13
  T[3] PREND_LA_VALEUR 31
  T[4] PREND_LA_VALEUR 22
  T[5] PREND_LA_VALEUR 4
  T[6] PREND_LA_VALEUR 2
  T[7] PREND_LA_VALEUR 18
  i PREND_LA_VALEUR 0
  j PREND_LA_VALEUR 0
  temp PREND_LA_VALEUR 0
  POUR i ALLANT_DE i A 6
    DEBUT_POUR
    posmin PREND_LA_VALEUR i
    AFFICHER " Passage "
    AFFICHER* i
    POUR j ALLANT_DE i + 1 A 7
      DEBUT_POUR
      AFFICHER "J ="
      AFFICHER j
      SI (T[j] < T[posmin]) ALORS
        DEBUT_SI
        AFFICHER "la condition est verifié "
        AFFICHER T[j]
        AFFICHER " inférieur à "
        AFFICHER T[posmin]
        AFFICHER " , position min "
        AFFICHER posmin
        AFFICHER ", la position minimum est maintenant "
        posmin PREND_LA_VALEUR j
        AFFICHER posmin
        AFFICHER " sa valeur est "
        AFFICHER T[j]
        AFFICHER " , la valeur à être comparé est maintenant "
        AFFICHER* T[j]
        FIN_SI
        SINON
          DEBUT_SINON
          AFFICHER "la condition est pas verifié "
          AFFICHER T[j]
          AFFICHER " "
          AFFICHER* T[posmin]
          FIN_SINON
      FIN_POUR
    temp PREND_LA_VALEUR T[posmin]
    T[posmin] PREND_LA_VALEUR T[i]
    T[i] PREND_LA_VALEUR temp
    APPELER_FONCTION rendreTableau(T)
    FIN_POUR
FIN_ALGORITHME

Merci de m'�clairer de vos lumi�res les amis