О плавающей точке

unsigned short v=59259;
float a=0.0f;
double b=0.0;
float averfa=0.0f;
double averdb=0.0;
char ahtung=' ';
for(int i=0;i<1089;i++)
{
if(i){ averfa=(v+averfa)/2.0;} else {averfa+=v;}
if(i){ averdb=(v+averdb)/2.0;} else {averdb+=v;}
a+=v;
b+=v;

if (a!=b) ahtung='!';
cout << i << " " << a << " " << b << " " << ahtung << " " << averfa << " " << averdb << "\n";
}

1087 6.44746e+007 6.44738e+007 ! 59259 59259
1088 6.45339e+007 6.45331e+007 ! 59259 59259
0.73921a = 6.45339e+007b = 6.45331e+007

Хмм? В один проход?

В смысле, не настоящий?

А, то есть основная идея, что постпроцессинг должен делать уже человек в своём приложении?

Хех, люблю я хитрые задачки)
Делаем вот что:

float v = ((unsigned short)59259);
printf("v=%0.023f\n",v);
float a=0.0f;
double b=0.0;
bool bl=false;
for(int i=0;i<33*33;i++){
a+=v;
b+=v;
if (283==i) printf("a=%0.023f, b=%0.023f, i=%d\n",a,b,i);
if (a!=b && !bl){
bl=true;
printf("a=%0.023f, b=%0.023f, i=%d\n",a,b,i);
}
}
printf("%g\n",(a-b)/(33*33));

И получаем вывод такой:

v=59259.00000000000000000000000
a=16829556.00000000000000000000000, b=16829556.00000000000000000000000, i=283
a=16888816.00000000000000000000000, b=16888815.00000000000000000000000, i=284
0.73921

Т.е. прибавление фиксированного числа на 284 итерации прибавляет неправильно. Присмотревшись к диапазону чисел замечаем, что это однако близко к 0x1000000, то бишь 2^24, а мантисса у флоата как раз такая же. Далее дорогой гугл приводит нас на не менее дорогой StackOverflow, так же не менее дорого Джоэла Спольски, а уже там нам старшие товарищи подсказывают вот что:

In single precision floating point there are only 24 bits of precision available, and 2^24 is 16777216. There is no way to encode 16777217 in 24 bits, so it simply stays at 16777216, on the reasoning that it's close enough to the real answer. The real problem arises when you add lots of very small numbers to a big number, where the sum of the small numbers is signifiant relative to the big one, but individually they are not.

Note that 16777216.0f is not the largest number that can be represented in float, but just represents the limit of precision. For example, 16777216.0f x 2^4 + 2^4 => 16777216.0f x 2^4

double has 53 bits of precision, so can encode up to 2^53, or 9007199254740992.0 before hitting the point where adding 1.0d fails.

Ну, в общем, я тоже не допёр сам, хотя мог бы... Получается это как раз тот случай, когда "лучше сладко проспать утро понедельника и выспаться, чем провести всю неделю отлаживая код, написанный в понедельник утром" ;)))

Спасибо за полезную задачку, мне с флоатингом тоже дел много иметь приходится, и я тоже немного знаю теорию, но вот практика - да, практика всё, а пока с такими вещами похоже не сталкивался)