arrondi avec type double

Version imprimable

08/04/2005, 11h23
la drogue c'est mal

arrondi avec type double

bonjour,

ca doit bien etre la permiere fois que je post une question dans ce forum mais j'ai une grosse fleme aujourd'hui :?

j'ai une variable de type "double" et je fais des calculs avec et que je me retrouve avec des problemes d'arrondis.

par exemple, au lieu d'avoir 0 je me retrouve avec -1.819999999999 * 10^-12 (soit -0.000000000001819999999)

comment faire pour avoir 0 Pile ???
08/04/2005, 11h44
chicorico

Salut,

C'est peut etre stupide mais essaye de caster en int, quand tu veux supprimer les décimales.

Ou alors tu peux utiliser la fonction ceil (pour arrondir par exces) ou alors floor(pour arrondir par defaut) ou alors si tu veux plus de precisions utilise le type long double.
08/04/2005, 11h49
Laurent Gomila

En général on prend le problème dans l'autre sens : on laisse l'imprécision dans nos flottants, et on gère celle-ci dans le reste du code (habituellement on introduit un espilon très petit, pour les comparaisons par exemple).

Le tout c'est de savoir pourquoi / dans quel contexte tu as besoin de te débarasser de cette imprécision.
08/04/2005, 12h07
la drogue c'est mal
Citation:

Salut,

C'est peut etre stupide mais essaye de caster en int, quand tu veux supprimer les décimales.

Ou alors tu peux utiliser la fonction ceil (pour arrondir par exces) ou alors floor(pour arrondir par defaut) ou alors si tu veux plus de precisions utilise le type long double.

caster avec un int ou utiliser ceil/floor me fait perdre la précision dont j'ai besoins (j'affiche des chiffre à virgule)

Citation:

Envoyé par Loulou24

En général on prend le problème dans l'autre sens : on laisse l'imprécision dans nos flottants, et on gère celle-ci dans le reste du code (habituellement on introduit un espilon très petit, pour les comparaisons par exemple).

Le tout c'est de savoir pourquoi / dans quel contexte tu as besoin de te débarasser de cette imprécision.

pour l'affichage: étant donnée que je manipule un nombre "floatant" je ne vais pas afficher 12 chiffres apres la virgule donc je n'affiche que 3 chiffres apres la virgule.

Le probleme se pose pour les chiffre négatif car à la fin je me retrouve avec -0.000000000000454546 et faire un format de ce truc la bah ca m'affiche à l'ecran : -0.000

moins zero à l'ecran, ca fait négligé....

pour l'instant je me suis fait ca vite fait "dans l'urgence":
Code:

1 2 3 4 5 6 7 8 9 void ArroundZero(double & value) { if( value <= 0.000001 && value > 0 ) value = 0; if( value >= -0.000001 && value < 0 ) value = 0; }
si quelqu'un à mieux, je suis preneur

ben moi je me suis fait une méthode d'arrondis, elle vaut ce qu'elle vaut ...

Code:

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
29
30
31
 
/*******************************************************************/
//Calcul de l'arrondi d'un double
/*******************************************************************/
__int64 COutils::GetRoundOf(double Value)
{
	return  (__int64)(Value+0.5);
}
 
/*******************************************************************/
//Calcul de l'arrondi d'un double
/*******************************************************************/
double COutils::GetRoundOf(double Value, int precision)
{
	double Round  = 0.0;
	double multiple = 0.0;
	switch (precision)
	{
		case 0 : multiple = 1.0;			break;
		case 1 : multiple = 10.0;			break;
		case 2 : multiple = 100.0;		break;
		case 3 : multiple = 1000.0;		break;
		case 4 : multiple = 10000.0;	break;
		case 5 : multiple = 100000.0;	break;
		default: multiple = 10000.0;	break;
	}
 
	Value = Value * multiple;
	__int64 temp = GetRoundOf(Value);
	return ((double)temp)/multiple;
}

Je travaille avec des __int64 parce que je manipule des gros chiffres...

salut ,
j'ai un peu le meme type de traitement :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
 
#include <math.h>
double Roundn(double dValue,int nDecimales)
{   
   double ad[6]={1.,10.,100.,1000.,10000.,100000.};
 
   if (nDecimales<0 || dValue==0.) return(dValue);      
   double dSeuil =(dValue<0.?-.5:.5);
   double dPrec=0.;
   if(nDecimales>=0 && nDecimales<=5) dPrec=ad[nDecimales];
   else
   {
        dPrec=ad[5];         
        for(int i=1;i<nDecimales-4;i++) dPrec*=10.;
        dPrec=floor(dPrec);
   }
   double dCalc = (((dValue*dPrec)+dSeuil));
 
   if(dValue<0.)
      return(ceil(dCalc)/dPrec);
   else      
      return(floor(dCalc)/dPrec);
} 
d=Roundn(1.1235,3); // donne 1.124

D'ailleurs, j'ai voulu simplifier pour le post et du coup j'ai introduis une erreur car ma première méthode marche que pour les nombres positifs...

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
/*******************************************************************/
//Calcul de l'arrondi d'un double
/*******************************************************************/
__int64 COutils::GetRoundOf(double Value)
{
	return  (__int64)(Value+(0.5*GetSignOf(Value, 0)));
}
 
 
 
//*******************************************************************
// retroune le signe de la valeur
//*******************************************************************
int COutils::GetSignOf(double Valeur,int ZeroSign)
{
	if (Valeur == 0)
		{return ZeroSign;}
	else if (Valeur < 0)
		{return -1;}
	else
		{return 1;}
}