Discussion :

[M77ATTAR]

bonjours;

comment approximer un nombre de type float ?
exemple : 1/3=0.333.....
je veux avoir comme r&sultat ceci : 1/3=0.3334

cordialement

[darkwall_37]

Salut,

Me concernant, je ne connais pas de fonction standard pour faire cela.

Si tu cherches à faire un arrondis,
l'arrondis d'1/3 au 10000 ieme n'est pas 0.3334 mais 0.3333

Si je devais faire une fonction d'arrondis je ferais comme ca :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#include <stdio.h>
#include <stdio.h>
#include <string.h>
 
float arrondis( float x, int precision )
{
    int a=((int)(10.*precision*x));
    if ((a%10)>5)
        a+=1;
    float b = a/(10.*precision);
    return b;
}
 
int main()
{
    float a=1./3.;
    float b=3./7.;
    int p2 = 100;
    int p4 = 10000;
    printf("\n %.15f => arrondis au %d-ieme a %.4f", a, p4, arrondis(a,p4));
    printf("\n %.15f => arrondis au %d-ieme a %.2f", b, p2, arrondis(b,p2));
    return 0;
}

Ce qui donne à l'affichage :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
 0.333333343267441 => arrondis au 10000-ieme a 0.3333
 0.428571432828903 => arrondis au 100-ieme a 0.43

Faut penser, à formater l'affichage du float dans le printf à la précision souhaitée car à cause de l'imprécision des float, il peut trainer des trucs louches derrière.

Au 10 ieme => %.1f
Au 20 ieme => %.2f etc...

Remarque, quand tu vois la valeur de 1/3 affichée, tu vois rapidement que la précision ce n'est pas trop ça. A partir d'une certaine précision, les résultats ne seront pas très probants je suppose.
On peut comprendre pourquoi il n'y ait pas de fonctions standards pour faire la chose ?

Cdt.

[Neckara]

Bonjour,

Si tu cherches à faire un arrondis,
l'arrondis d'1/3 au 10000 ieme n'est pas 0.3334 mais 0.3333

Il y a plusieurs façon d'arrondir.

Cf Wikipedia

[ternel]

Par ailleurs, je rappelle que les nombres flottants ne sont pas des réels, mais une notation binaire permettant d'avoir une approximation assez bonne.

Voyez le nombre flottant par wikipedia.

le double atténue fortement ce problème, mais ne le résoud pas.

[M77ATTAR]

la fonction proposé dans la réponse 1 me fait la tâche !
donc merci à tous

[diogene]

Faut penser, à formater l'affichage du float dans le printf à la précision souhaitée car à cause de l'imprécision des float, il peut trainer des trucs louches derrière.

Oui, mais alors tout le travail est fait par le printf() (qui fait également un arrondi à sa convenance):

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
    //  a=2./3. p4 = 10000
    printf("\n %.15f => arrondis au %d-ieme a %.4f", a, p4, arrondis(a,p4));
    // Résultat : 0.666666686534882 => arrondis au 10000-ieme a 0.6667
    printf("\n %.15f => arrondis au %d-ieme a %.4f", a, p4,a);
    // donne aussi :0.666666686534882 => arrondis au 10000-ieme a 0.6667

Et le test n'est absolument pas significatif.

Il faut admettre qu'il y aura des trucs "louches" derrière, c'est inhérent au codage des flottants, et les cacher n'est pas une solution. On manipulera ensuite les vrais nombres obtenus par l'arrondi, pas leur représentation par le printf()
Si on veut voir la réalité, on constatera une anomalie dans ton code :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
    //  a=2./3. p4 = 10000
    printf("\n %.15f => arrondis au %d-ieme a %.4f", a, p4, arrondis(a,p4));
    // Résultat : 0.666666686534882 => arrondis au 10000-ieme a 0.6667
    printf("\n %.15f => arrondis au %d-ieme a %.15f", a, p4, arrondis(a,p4));
    // Résultat : 0.666666686534882 => arrondis au 10000-ieme a 0.666670024394989
    //  a=-2./3. p4 = 10000
    printf("\n %.15f => arrondis au %d-ieme a %.4f", a, p4, arrondis(a,p4));
    // Résultat : -0.666666686534882 => arrondis au 10000-ieme a -0.6667
    printf("\n %.15f => arrondis au %d-ieme a %.15f", a, p4, arrondis(a,p4));
    // Résultat :  -0.666666686534882 => arrondis au 10000-ieme a -0.666660010814667

En fait, l'arrondi tel qu'il est fait par la fonction a un comportement différent pour les nombres positifs et négatifs (arrondis(-x,...) != -arrondis(x,...)).