Discussion :

[Tchetch]

Bonjour,

Je fais du PERL depuis peu et j'ai fais un petit programme qui effectuait des suites d'opérations très simples. En le faisant je me suis rendu compte d'une erreur d'arrondi et j'ai donc essayer le programme suivant (qui me semble très simple) :

Code :

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

1
2
3
4
5
6
7
8
9
10
#!/opt/perl/bin/perl
 
$a = -1;
$b = 0.1;
 
while($a <= 1)
{
        $a += $b;
        print $a . "\n";
}

Les résultats étant les suivants :

-0.9
-0.8
-0.7
-0.6
-0.5
-0.4
-0.3
-0.2
-0.1
-1.38777878078145e-16
0.0999999999999999
0.2
0.3
0.4
0.5
0.6
0.7
0.8
0.9
1
1.1

Il y a bien une erreur d'arrondi de la part de PERL. J'ai essayer ceci avec la version 5.8.3 et 5.8.6 (Linux SUSE 9.1), l'erreur est toujours la même. J'ai donc pris mon livre (PERL 5 de David Till (CampuPress)) et il m'indique qu'il existe une erreur d'arrondi sur les GRAND nombres à virgule flottante. Je ne pense pas qu'il s'agisse là de grand nombre.
Je vous demande donc si vous connaissez un solution à ce problème ?

Merci.

T.

[dmitry_ovsianko]

Il y a bien sûr une erreur d'arrondi quand tu divises 1 par 10, car le résultat est stocké en forme binaire (0.000101010101010...) -- il est coupé quelque part.

Pour opérer des fractions tu peux utiliser quelque modue pareil à Number::Fraction (http://search.cpan.org/~davecross/Nu...er/Fraction.pm), mais ça semble un peu trop dur.

Pour formater tes nombres tu peux utiliser printf/sprintf (http://www.icewalkers.com/Perl/5.8.0...c/sprintf.html):

Code :

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

1
2
3
4
while ($a <= 1) { 
        $a += $b; 
        printf ("%.1f\n", $a);
}

Mais le meilleur est d'utiliser des intègres:

Code :

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

1
2
3
4
5
6
7
$a = -10; 
$b = 0.1; 
 
while (0.1 * $a <= 1) { 
        $a += 1; 
        print $a * 0.1 . "\n"; 
}

[Tchetch]

Il y a bien sûr une erreur d'arrondi quand tu divises 1 par 10, car le résultat est stocké en forme binaire (0.000101010101010...) -- il est coupé quelque part.

Mais je ne pensais pas que pour des valeurs de ce type on avait déjà ce genre de problèmes.
Mais bon je suis assez content de Number::Fraction qui résoud mon problème.

Merci beaucoup.

T.

[Jedai]

Il ne s'agit pas "d'erreur d'arrondi", c'est juste inhérent à la façon dont sont stocké les float (et quelque soit leur taille, ce n'est pas le problème), et ce n'est pas spécifique à Perl, mais affecte tous les langages de programmation...

--
Jedaï

[2Eurocents]

C'est d'ailleurs une des raison pour lesquelles tout bon prof d'Analyse Numérique, en IUT ou en école d'Ingé, doit apprendre à ses élèves qu'il ne faut jamais faire de tests d'égalité entre deux valeurs.

Avec des flottants, on ne fait pas :

Code :

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

... if (a == b) ...

mais :

Code :

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

... if ((a - b) < epsilon) ...

ou (plus compliqué et plus risqué) :

Code :

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

... if ((b != 0) && (((a / b) -1) >= 0) && (((a / b) -1) < pourcentage_tolerance)) ...

[Tchetch]

Mais ce qui m'étonne quand même c'est que le même code en C ne fait pas ce genre d'erreur ... Je trouve vraiment bizzare une erreur pareil avec des chiffres aussi simple, j'ai essayer le code suivant :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
$a = -1;
$b = 0.1;
$c = 0;
$d = $a;
$n = 1;
 
while($a <= 1)
{
    $c = $n * $b;
    $a = $c + $d;
    print $a  . "\n";
    $n++;
}

Les résultats sont justes ! Je n'arrive pas à comprendre qu'une erreur pareil existe, je pensais qu'il y avait des algorithmes qui s'occupaient de gérer se genre d'erreur !
Je parle de nombre simple, là il s'agit de nombre entre -1 et 1, avec 1 chiffre après la virgule. Je ne pense pas qu'un autre langage de programmation fasse une erreur de ce genre avec ces chiffres là. D'ailleur si c'était le cas, le programme suivant en C, devrait donner des valeurs fausses, pourtant elles sont justes :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include <stdio.h>
 
int main(int argc, char **argv)
{
    float a = -1, b = 0.1;
 
    while(a < 1)
    {
        a += b;
        printf("%f\n", a);
    }
 
    return 0;
}

Enfin, il semblerait que ce soit normal !!!

T.

[dmitry_ovsianko]

Pas tout à fait justes, mais c'est printf qui cache l'erreur inévitable.

Le programme equivalent en Perl donne des chiffres aussi ronds:

Code :

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

1
2
3
4
5
6
7
$a = -1; 
$b = 0.1; 
 
while ($a <= 1) { 
        $a += $b; 
        printf ("%f\n", $a);
}

-0.900000
-0.800000
-0.700000
-0.600000
-0.500000
-0.400000
-0.300000
-0.200000
-0.100000
-0.000000
0.100000
0.200000
0.300000
0.400000
0.500000
0.600000
0.700000
0.800000
0.900000
1.000000
1.100000

[Jedai]

Oui, d'ailleurs on recommande toujours d'utiliser printf pour afficher des float en Perl, ça permet de cacher ces petits problèmes, mais ils sont présent en C aussi, tu n'a qu'à augmenter le nombre de chiffres après la virgule pour le vérifier. (et heureusement, il n'y a pas d'"algorithme" qui "corrige" ces erreurs, ça induirait un surcoût dangereux, vu qu'il faudrait pratiquement une IA ou des indications du programmeur pour savoir quand faire les corrections, les modules de calcul mathématique sont là pour ça : faire des calculs exacts à la demande)

--
Jedaï