inquam, problemet ligger inte i svårigheten att hantera stora eller små tal. Enligt IEEE specifikationen för floats (se t.ex. http://steve.hollasch.net/cgindex/coding/ieeefloat.html) så räcker en vanligt 32bits float till för tal mellan +-10^-44.85 till 10^38.53
Det problemet grundar sig i är den mappning man gör från klassen av reella tal (R) till en samling av bitar (Z^32). Man kan kalla det för en diskretisering som gör att man tappar information.
Om man jämför informationsinnehållet i en float som är 32 bitar med t.ex. en 32 bitars heltal Om man ser en float som är 32 bitar som håller tal mellan 0 och 2^32 - 1 = 4294967295 så inser vi att det bara finns ~4.3 miljarder unika flyttal.
Därför kommer den "diskretisering" man gör klassa flera olika tal (inom R) till samma flyttal (i Z^32). t.ex. med följande kod:
#include <stdio.h>
int main(int argc, char **argv)
{
int iv, i;
float *fp, fv;
fv = 100.0f;
iv = *((int*)&fv);
fp = &iv;
printf("Size of; int: %d, float: %d\n", sizeof(int), sizeof(float));
for(i=0; i<100; ++i)
{
printf("int: %d ==> float: %20.20f\n", iv, *fp);
iv+=1;
}
return 0;
}
så finner man följande:
int: 1120403456 ==> float: 100.00000000000000000000
int: 1120403457 ==> float: 100.00000762939453125000
int: 1120403458 ==> float: 100.00001525878906250000
int: 1120403459 ==> float: 100.00002288818359375000
Upplösningen eller steget mellan varje flyttal kring 100 är 0.00000762939453125
Alltså kommer det inte gå att skilja på tal mellan 100 och 100.00000762939453125
Vidare så blir det problem redan då man försöker återskapa talet 0.1 som inte kan representeras exakt men blir: 0.1000000014901161193847656250000000000000
int: 1036831949 ==> float: 0,1000000014901161193847656250000000000000
int: 1036831950 ==> float: 0,1000000089406967163085937500000000000000
kring detta område runt 0.1 så är upplösningen: 0.000000007450580596923828125
och till sist talet
10^-33 = 0.000000000000000000000000000000001
int: 145106764 ==> float: 0.00000000000000000000000000000000100000002374222799
int: 145106765 ==> float: 0.00000000000000000000000000000000100000011557772415
int: 145106766 ==> float: 0.00000000000000000000000000000000100000020741322031
Ursäkta det långa inlägget men frågan är en sådan som kan få ett enkelt svar av karaktären ja/nej men jag anser att det kan vara god idé att försöka belysa problemet för att bygga förståelse.
För mer utförlig läsning hänvisar jag till följande sidor:
http://docs.oracle.com/cd/E19957-01/806-3568/ncg_goldberg.htm...
http://www.cygnus-software.com/papers/comparingfloats/compari...
Och så till det korta svaret du redan fått: .NET hanterar inte float-jämförelser så det gör livet enkelt för dig. Det bästa är om du vet applikationens syfte och själv kan sätta trösklar för att jämföra om abs( a-b) < epsilon. Alternativt att du jämför hur många ULPs (Units in last place) som skiljer. Kika t.ex. på svaret du får här:
http://stackoverflow.com/questions/3874627/floating-point-com...
(det svaret Andrew Wang ger)
