numeric_limits epsilon explication

Version imprimable

16/04/2011, 22h29
guillaume07

numeric_limits epsilon explication

Salut,

je ne comprends pas cette fonction, qui est définie par Machine epsilon (the difference between 1 and the least value greater than 1 that is representable)

Preneur d'une explication

Merci
16/04/2011, 22h57
Joel F

http://en.wikipedia.org/wiki/Machine...nt_arithmetics
16/04/2011, 23h09
guillaume07

pourquoi la différence entre 1 et la prochaine valeur , et pas 10 et la prochaine valeur par exemple ?
16/04/2011, 23h45
Joel F

c'est le standard, et en general on essaye de le garder simple.
En outre, pour des valeurs > 1 , l'exposant decale la mantisse et tu perdrais des bits d'informations.
16/04/2011, 23h48
guillaume07

Je te suis pas sur ta deuxième phrase dsl, si tu pouvais préciser ?
Quand tu dis que l'exposant décale la mantisse, je pensais que l'exposant et la mantisse était tous les deux coder sur un nombre de bits fixe.
17/04/2011, 00h34
Joel F

plus l'exposant est gros plus le dernier bit de la mantisse est une grosse valeur.

on compare toutjours k avec k + k*epsilon. On parle alors d'Unit in the Last Place, qui est la mesure de l'erreur tenant compte des magnitudes relatives des valeurs.

1 ulp = |k - k+k*epsilon|/epsilon

Dans le lien il est indiqué que l'epsilon pour un double est pow (2, - 53)
avec ce programme pourtant quand j'utilise comme val pow(2,-53) et std::numeric_limits<double>::epsilon(), le dernier bit de l'exposant n'est pas le même :

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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
 
#include <iostream>
#include <vector>
#include <limits>
#include <math.h>
#include <iterator>
#include <boost/lexical_cast.hpp>
using namespace std;
 
template<class T> vector<string> toBinary(const T num) 
{
	vector<string> mybits( sizeof(T)*CHAR_BIT );
 
	const char * const p = reinterpret_cast<const char*>(&num);
 
	for (int i = sizeof(T)-1; i >= 0; i--)	
        for (int j = CHAR_BIT-1; j >= 0; j--)		
		{
			bool b = (p[i] & (1 << j));
            mybits[i*CHAR_BIT + j] = boost::lexical_cast<std::string>( b );		
		}
 
	mybits.insert(mybits.end()-1,".");
	mybits.insert(mybits.end()-13,".");
	return mybits;
}
 
template<class T> void printInfo(T val)
{
	auto v = toBinary(val);	
	copy(v.rbegin(),v.rend(),ostream_iterator<string>(cout,""));
	cout << "\n";
}
 
int main() 
{
	printInfo<double>(  std::numeric_limits<double>::epsilon() );
	//0.01111001011.0000000000000000000000000000000000000000000000000000
 
	double v = 2.;
	int	   e = -53;
	printInfo<double>( pow(v,e) );
	//0.01111001010.0000000000000000000000000000000000000000000000000000
 
	cin.get();
}

EDIT: ok car en faite std::numeric_limits<double>::epsilon() correspond à pow(2,-52) et non pow(2,-53) comme indiqué dans le lien wikipedia