Discussion :

[baragouine]

Bonjour,

J'étais entrain de coder la somme des inverses des carrés de n, n allant de 1 à +infini et à partir d'une certaines valeur mon programme m'afficher inf et je ne comprends pas pourquoi.
Est-ce que quelqu'un pourrait m'éclairer?
Voici le code:

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
#include <iostream>
 
using namespace std;
 
int main()
{
    double n = 0;
 
    for (int i = 1; i < 100000L; ++i)
        n += 1.0/(i * i);
 
    cout << n << endl;
 
    return 0;
}

[koala01]

Salut,

Tout simplement parce que tu finis, tôt ou tard, par atteindre le point où ton réel n'est plus capable de représenter la valeur avec "un minimum de précision".

Le nombre de bits utilisés par les différents types primitifs (char, short, int, long, long long, float, double et long double) est clairement défini, soit par la norme (pour les réels) soit par le système sur lesquels tu exécute ton programme.

Pour ce qui est des réels, on part sur une représentation "scientifique" avec une mantisse et un exposant. Si bien que, lorsque tu calcule la racine carrée inverse d'un nombre -- mettons 1 000 000 -- commence par multiplier ce nombre par lui même, ce qui fera dans mon exemple 1 000 000 000 000, puis tu crées un réel dont la valeur (temporaire, dans le cas présent) doit représenter la division de 1 par le résultat, à savoir 0.000 000 000 001, si je ne me suis pas trompé.

Cette valeur est valide, par rapport au résultat d'une division par 0. Seulement, ton réel ne dispose "tout simplement" pas de la capacité de représenter cette valeur, parce que l'exposant ne permet pas un décalage suffisant que pour le faire. Le langage transforme donc cette valeur en "quelque chose" qui représente l'infini : INF.

Et, le problème avec INF, c'est que, quel que soit l'opération que tu pourras faire avec cette valeur (addition, soustraction, division ou multiplication), le résultat ne pourra pas non plus être représenté par ton réel: ce sera toujours INF.

Du coup, même si tu as une valeur "correcte et cohérente", le résultat de l'addition de cette valeur avec INF ne pourra être que ... INF. Et c'est ce que l'affichage te donne comme réponse

NOTA: ce n'est qu'un détail, mais il y a de très bonnes raisons pour éviter l'utilisation de la directive using namespace std;. Je les ai exposées ==>ICI<==

[dalfab]

Le moment où on obtient l'infini, c'est pour i=65536.
i*i est un entier sa valeur vaut : 65536*65536 et sur 32bits ça fait donc 0.
Pour ne pas avoir ce cas, il faut effectuer un calcul flottant:

Code :

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

     n += 1 / ((double)i * i);

[Guesset]

Bonjour,

En outre le calcul est faux bien avant, par exemple pour (2¹⁶-1)² = 2³² - 2¹⁷ + 1 < 0 en 32 bits signé (int).

A partir de 46341 le résultat est négatif car 46341 est le premier nombre entier supérieur à 2¹⁵*2^1/2 qui au carré est donc supérieur à 2³¹ soit négatif en 32 bit signé.

La solution des flottants est un peu meilleure mais pas de beaucoup. L'exposant ne sert pas ici à grand chose sinon manger quelque bits. Un 64 bits non signé considéré comme N sur 2⁶³ permettrait un peu plus de possibilités (en fait c'est un une représentation fixée pouvant aller jusqu'à 2.

Salutations

[baragouine]

J'avais pas pensé à ça, merci de vos réponse.