Problème compteur incrémentale et reste division euclidienne Fermé

Question

Bonjour, 

Avec le code suivant :

using System;
using System.Threading;

namespace ConsoleApp2
{
    class Program
    {
        static void Main(string[] args)
        {
            double a = 0;
            int b = 0;
            for(int i=0; i<=33;i++)
            { 
                Console.WriteLine("double : "+a);
                a = (a + 0.1) % 1.1;
                Console.WriteLine("entier : "+b);
                b = (b + 1) % 11;
                Console.WriteLine(Environment.NewLine);
                Thread.Sleep(200);
            }
            Console.ReadLine();

}
    }
}


Nous sommes bien d'accord que les résultat on un coefficient 10 d'écart mais voilà la sortie n'est pas ça.

Voici ce que j'ai :
double : 0entier : 0double : 0,1entier : 1double : 0,2entier : 2double : 0,3entier : 3double : 0,4entier : 4double : 0,5entier : 5double : 0,6entier : 6double : 0,7entier : 7double : 0,8entier : 8double : 0,9entier : 9double : 1entier : 10double : 1,1entier : 0double : 0,0999999999999999entier : 1double : 0,2entier : 2double : 0,3entier : 3double : 0,4entier : 4double : 0,5entier : 5double : 0,6entier : 6double : 0,7entier : 7double : 0,8entier : 8double : 0,9entier : 9double : 1entier : 10double : 1,1entier : 0double : 0,0999999999999999entier : 1double : 0,2entier : 2double : 0,3entier : 3double : 0,4entier : 4double : 0,5entier : 5double : 0,6entier : 6double : 0,7entier : 7double : 0,8entier : 8double : 0,9entier : 9double : 1entier : 10double : 1,1entier : 0

Si vous avez une idée de où cela peut venir.

Bon courage

Configuration: Windows / Firefox 74.0 / Visual Studio Community 2019
16.4.2

yg_be · Answer

bonjour, ce serait plus clair si tu montrait le résultat que tu attends, qui est probablement différent du résultat que tu obtiens.

Utilisateur anonyme · Answer

Bonjour

et merci à Chris94 d'avoir corrigé ta coloration syntaxique, tu as essayé de t'en servir et c'est bien, mais dans ce petit tuto il est décrit comme bien l'utiliser  https://codes-sources.commentcamarche.net/faq/11288-les-balises-de-code

Venons à ta question Nous sommes bien d'accord que les résultat on un coefficient 10 d'écart mais voilà la sortie n'est pas ça.
Sauf erreur de ma part, si....

double : 0
entier : 0 //0 * 10 est bien égal à zéro

double : 0,1
entier : 1 //0,1 * 10 est bien égal à 1

double : 0,2
entier : 2 //0,2 * 10 est bien égal à 2

double : 0,3
entier : 3 //0,3 * 10 est bien égal à 3

//etc...




Il n'y a que pour le dernier

double : 1,1 // ce résultat est incohérent, puisqu'on divise par 1.1, il ne devrait pas pouvoir y avoir un reste de 1.1
entier : 0

C'est ça ton problème?

Utilisateur anonyme · Answer

L'informatique, n'est jamais juste.
C'est toujours un choix au plus proche possible.

Dans la vraie vie, on peut écrire une infinité de nombres parce « qu’il suffit d’ajouter un chiffre » pour qu’il se concrétise.

L’informatique vient de l’électronique et là ça se complique, un nombre à une taille définit de bits qui est directement lié à la technologie.
Et on fait avec.

Du coup, les nombres à virgule flottantes sont utilisés pour représenter un nombre décimal
Ici https://forums.commentcamarche.net/forum/affich-35846831-erreur-de-calcul#3
J’ai proposé une explication un peu généraliste.
DalFab et Reiverax ont par la suite donné des precisions.

Tu peux aussi lire le paragraphe « l’éternel problème de la virgule qui part en couille » http://sametmax.com/les-nombres-en-python/

Le 0.0999999999 est directement une manifestation de cela.
Il y a fort à parier que le 1.1 aussi, je vais faire quelques tests de mon coté

Utilisateur anonyme · Answer

Bon alors en décomposant le calcul, je n'arrive pas à voir à quel moment le petit epsilon qui nous embête se glisse. double a = 0; int b = 0; for (int i = 0; i <= 33; i++) { Console.Write("'a': {0} ",a); a += 0.1; Console.Write("'a' + 0.1: {0} ",a); a %= 1.1; Console.WriteLine("'a' % 1.1: {0}",a); Console.WriteLine("entier : " + b); b = (b + 1) % 11; Console.WriteLine(Environment.NewLine); } Console.ReadLine(); Par contre, si j'applique un simple arrondi à a += 0.1, il n'y a plus d'erreur. double a = 0; int b = 0; for (int i = 0; i <= 33; i++) { Console.Write("'a': {0} ",a); a = Math.Round(a + 0.1, 1); Console.Write("'a' + 0.1: {0} ",a); a %= 1.1; Console.WriteLine("'a' % 1.1: {0}",a); Console.WriteLine("entier : " + b); b = (b + 1) % 11; Console.WriteLine(Environment.NewLine); } Console.ReadLine(); Je ne sais pas exactement comment est codé l'arrondi sur un double, mais il à un effet de "remise à zéro" de la mantisse et de l'exposant quand une multitude d'opérations finit par la mettre un peu à mal. Attention cependant, l'arrondi informatique n'est pas l'arrondi mathématique Français. C'est l'arrondi monétaire international. Console.WriteLine("Arrondi de 1.5: {0}", Math.Round(1.5)); Console.WriteLine("Arrondi de 2.5: {0}", Math.Round(2.5)); Ces 2 arrondis donnent 2. Dans le cas de 1.5, l'acheteur va payer 2, il perd donc 0.5. Dans le cas de 2.5, il payera 2, c'est le vendeur qui perd 0.5. Cette règle permet statistiquement de répartir gain et perte équitablement entre acheteur et vendeur. Elle s'applique quelque soit le nombre de décimales, 1.111111111111115 => 1.11111111111112 1.111111111111125 => 1.11111111111112 On l'appelle aussi l'arrondi au pair le plus proche. Normalement dans le calcul actuel, il n'y a pas de raison de tomber sur un cas comme cela mais, mieux va le savoir.

anonyme · Answer

Hé bien, je ne pensais pas que ce post déchaînerait autant de passion. Je précise que le programme est juste un exemple simple pour bien montrer le problème. Et venant de l'informatique embarquée je n'avais jamais eu ce problème mais là visual studio ne voulait pas que j'utilise un float avec la division euclidienne et ma proposé le double. Mais je vais regarder le décimal qui peut être intéressant. Merci à tous pour vos réponses. Et n'hésitez pas à en donner d'autres, les problèmes ont toujours de multiples solutions.

P.S : C'est toujours anonymous mais le correcteur orthographique en a décidé autrement.

Utilisateur anonyme · Answer

Avec le float, c'est pire, y'a moins de bits, donc moins de précision.
Faire le calcul avec un entier et diviser le résultat par 10 pour l'affichage (ou la fourniture) reste le meilleur moyen de ne jamais avoir d'erreur de virgule flottante.

Utilisateur anonyme · Answer

La nuit portant conseil, et hier je planchais sur une autre question en même temps.
J'ai négligé un point important de ton symptôme, Console.Write(line) applique un arrondi.

Pour voir la valeur vraie des variables, pas le choix, il faut espionner en pas à pas.
En repartant de ce code

for (int i = 0; i <= 33; i++)
            {
                Console.Write("'a': {0}		", a);
                a = a + 0.1;
                Console.Write("'a' + 0.1: {0}		", a);
                a %= 1.1;
                Console.WriteLine("'a' % 1.1: {0}", a);

Console.WriteLine("entier : " + b);
                b = (b + 1) % 11;
                Console.WriteLine(Environment.NewLine);
            } 
J'ai mis un point d'arrêt et 2 espions (il est possible que cet espion arrondissent aussi, mais on y voit quand même plus de choses

Je t'ai pris 3 captures d'écran

3 ème itération (i == 2) ça commence à se voir


10 ème itérations, y' un 8 à l'avant dernière décimale


11 ème itération, bien que très proche de 1.1 est bien strictement inférieur, le reste est donc proche de 1.1, et arrondi à 1.1 par Console.Write(line)

Problème compteur incrémentale et reste division euclidienne

7 réponses

Discussions similaires