Discussion :

[Far_Away]

Bonjour,

j'ai posté hier pensant avoir un pb dans mon programme et en fait cela ne vient pas de moi.
Voilà j'ai codé une appli C/C++ sur snowleopard avec Xcode et tout marchait pour le mieux.
En recondant le tout sous visual C++, bizarre, résultats aberrants.
En affinant mes recherches, j'ai finalement vu l'endroit ou cela coinçait mais aucune idée pour résoudre le problème.

Alors voila, j'ai une fonction simple, appelons la f définie comme suit dans mo programme sous Xcode

Code :

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

1
2
3
double f(double x){
return 0.5*(1-erf(x/sqrt(2)))
}

Les fonction C99 et donc 'erf' n'étant pas prises en charge sous VC++, je fais appel à boost, et la fonction reste la même à part que j'appelle boost::math::erf

Passons ensuite au résultats.
La fonction erf est une fonction définie sur tout R comme le montre
http://fr.wikipedia.org/wiki/Fichier:Erf_plot.svg

Déclarons
double a = -37.1326;
double b = -8.26506;
double ra = f(a);
double rb = f(b);

f(a) et f(b) sont donc très proches de 1

Si je fais des printf("%e", ra) et printf("%e",rb)
je vais voir s'afficher sur la console 1.000000e+00 sous Xcode et VC++

Maintenant, faisons la différence
double dif = f(a)-f(b);
et printf("%e",dif);

Sous Xcode on obtient 1.11022e-16, sous VC++ on obtient 0.000000e+000


VC++ m'enlève donc toute précision en faisant la différence. Mais d'un autre côté, pourquoi Xcode m'enlève-t-il également la précision sur l'affichage séparé de f(a) et f(b) et m'affiche quelquechose de correct pour la différence.

Toujours est-il que je dois avoir cette précision et que je n'ai pas la solution à ce pb

Merci a celui qui m'apportera une aide

[Emmanuel Deloget]

DIfférentes librairies C == différentes manière de gérer la précision du FPU. Sous Visual C++, tu peux utiliser la fonction _controlfp() pour gérer ce point par toi même.

Ensuite, la question de l'affichage est du domaine du "chacun fait ce qu'il veut". Aucune norme ne précise comment afficher un float ou un double.

[Far_Away]

Ok, donc il existe une solution au problème.. je me doutais que c'était les libs et je me doutais qu'il y avait une solution vu que matlab sous win fait cela sans soucis.
Merci

[Far_Away]

Bon j'ai tenté, et je n'y parviens pas.

Voici le petit bout de 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
16
17
18
19
20
21
22
23
24
25
26
27
28
// PrecisionCalcul.cpp*: définit le point d'entrée pour l'application console.
//
 
#include "stdafx.h"
#include <C:\Program Files (x86)\boost\boost_1_44\boost\math\special_functions\erf.hpp>
#include <float.h>
#pragma fenv_access (on)
 
 
int _tmain(int argc, _TCHAR* argv[])
{
 
	unsigned int control_word_x87;
	control_word_x87 = __control87_2(_PC_24, MCW_PC,&control_word_x87, 0);
 
	double a = -37.1326;
	double b = -8.26506;
	double d = 2;
	double dd = 0.5;
	double ra = dd*(1-boost::math::erf(a/sqrt(d)));
	double rb = dd*(1-boost::math::erf(b/sqrt(d)));
	double dif = ra- rb;
 
	printf("ra=%e\n",ra);
	printf("rb=%e\n",rb);
	printf("dif=%e\n",dif);
 
}

La sortie est toujours la même
ra=1.000000e+000
rb=1.000000e+000
dif=0.000000e+000

Conclusion je ne sais pas comment utiliser ce que tu viens de me donner...

[stardeath]

Sous Xcode on obtient 1.11022e-16, sous VC++ on obtient 0.000000e+000

techniquement ces 2 valeurs sont identiques, à DBL_EPSILON près bien sur, mais vu qu'on ne compare jamais 2 valeurs flottantes directement entre elles...

pourquoi as tu besoin de cette "précision"?

[Far_Away]

J'ai besoin de cette précision car les résultats que je calcule sont des probabilités, en gros une multiplication de 2 différences semblables à celle présentée dans le post plus haut, donc si on m'arrondi mon 0.1e-16 a 0..
mon 1.1e-16 multiplié par mon 3.48e+15 devient 0.. pas très cool tu l'admettras.
Ce n'était pas un chipotage pour grignoter quelques chiffres... Cela est indispensable au bon fonctionnement de ce que j'ai fait
Mais j'ai installé MPIR et MPFR et tout va bien maintenant
Problème solved.
Merci

[stardeath]

j'avais lu un article il y a longtemps qui montrait l'aggravation de l'imprécision des flottants sur les opérations simples.

bonne chance pour tes probas.