Opérations de type double en C

s’il te plaît explique-toi comment ça marche ? Le programme me donne le résultat correct uniquement lorsque j’ajoute des entiers, mais dans ma tâche je préférerais utiliser le type double.

option de travail :
`

C++

for (int i = -10000; i < 10000; i++) {
    formula = s1 / (v1 + k) + s2;
    if (formula == 0) {
        break;
}
    k += 1;
}

Résultat : 3 000 000
`

ça ne fonctionne pas correctement :
`

C++

for (int i = -10000; i < 10000; i++) {
    formula = s1 / (v1 + k) + s2;
    if (formula == 0) {
        break;
}
    k += 0.00001;
}

Résultat :0,200000
`

Ce que j’ai essayé :

dans mon programme j’ai besoin d’un résultat plus précis donc je ne peux pas utiliser le type int.

Solution 2
Solution 1

Solution 2

Il y a plusieurs choses à noter ici. Il semble que seule la variable k soit modifiée à chaque boucle.

for (int i = -10000; i < 10000; i++) {
  formula = s1 / (v1 + k) + s2;
  if (formula == 0) {
	break;
  }
  k += 0.00001;
}

Malheureusement, la valeur k += 0,00001 ne peut pas être stockée exactement sous forme de flottant (ou de double), le compilateur utilise donc généralement la valeur la plus proche. Si vous additionnez maintenant ces nombres doubles qui ne correspondent pas exactement, l’erreur dans la somme augmente à chaque boucle.

Il existe désormais plusieurs façons de résoudre le problème.
1. Au lieu d’ajouter constamment, il est préférable de multiplier une fois par l’indice de tranche, ce qui augmente considérablement la précision.
2. au lieu de comparer directement deux flotteurs entre eux, il serait préférable de vérifier la différence, la différence ne devenant souvent pas 0, mais devant tomber en dessous d’une valeur spécifiée.

Utiliser double au lieu de float pour une meilleure précision ne ferait que déplacer le problème, sans le résoudre.

Solution 1

La première étape consiste à s’assurer que les variables formula, s1, s2, v1et k sont tous de type double. En fait, vous n’avez pas besoin qu’ils soient tous doubles, mais vous voulez vous assurer du résultat (formula) est un double et la division doit se faire en double. Un résultat entier sera presque garanti de donner des résultats erronés.

La deuxième étape consiste à se méfier des comparaisons égales avec des valeurs doubles, c’est-à-dire tester si formula est zéro. La technique habituelle pour cela consiste à définir une valeur epsilon qui signifie « assez proche » et à la comparer. Voici un exemple :

C++

const double epsilon = 1.0E-9;

// do calculations here

double delta = fabs( formula );
if( delta < epsilon )
    break;

Cela sortira de la boucle for si formula est compris entre -1E-9 et +1E-9. Vous pouvez utiliser 1.0E-6 ou d’autres valeurs pour epsilon tant qu’elles respectent la tolérance de calcul souhaitée.