Discussion :

[la drogue c'est mal]

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 ???

[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.

[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.

[la drogue c'est mal]

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)

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 :

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

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

[matazz]

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

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
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...

[farscape]

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

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
 
#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

[matazz]

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 :

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
 
/*******************************************************************/
//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;}
}