Compute arithmetic-geometric mean without using an epsilon in C++ [closed] - c++

Question

Closed. This question needs details or clarity. It is not currently accepting answers.
Want to improve this question? Add details and clarify the problem by editing this post.
Closed 5 years ago.
Improve this question
Is it possible to compute arithmetic-geometric mean without using an epsilon in C++?
Here is my code:
double agm(double a, double b)
{
if(a > b)
{
a = a + b;
b = a - b;
a = a - b;
}
double aCurrent(a), bCurrent(b),
aNext(a), bNext(b);
while(aCurrent - bCurrent != 0)
{
aNext = sqrt(aCurrent*bCurrent);
bNext = (aCurrent+bCurrent)*0.5;
aCurrent = aNext;
bCurrent = bNext;
}
return aCurrent;
}
double sqrt(double x)
{
double res(x * 0.5);
do
{
res = (res + x/res) * 0.5;
} while(abs(res*res - x) > 1.0e-9);
return res;
}
And it runs forever.
Actually it is very clear what I was asking. It is just that you never met the problem and maybe lazy to think about it and are saying at once that there is nothing to talk about.
So, here is the solution I was looking for:
Instead of eps we can just add the following condition
if(aCurrent <= aPrev || bPrev <= bCurrent || bCurrent <= aCurrent )
And if the condition is true, then it means that we have computed the arithmetic-geometric mean with the most precision possible on our machine. As you can see there is no eps.
Using an eps in the question and answer means comparing that we say that two double numbers are equal when the difference between them is less than eps.
Please, reconsider opening the question.

Answer 1

Of course you can. It suffices to limit the number of iterations to the maximum required for convergence in any case, which should be close to the logarithm of the number of significant bits in the floating-point representation.
The same reasoning holds for the square root. (With a good starting approximation based on the floating-point exponent, i.e. at most a factor 2 away from the exact root, 5 iterations always suffice for doubles).
As a side note, avoid using absolute tolerances. Floating-point values can vary in a very wide range. They can be so large that the tolerance is 0 in comparison, or so tiny that they are below the tolerance itself. Prefer relative tolerances, with the extra difficulty that there is no relative tolerance to 0.

Answer 2

No, it's not possible without using an epsilon. Floating point arithmetic is an approximation of real arithmetic, and usually generates roundoff errors. As a result, it's unlikely the two calculation sequences used to compute the AGM will ever converge to exactly the same floating point numbers. So rather than test whether two floating point numbers are equal, you need to test whether they're close enough to each other to consider them effectively equal. And that's done by calculating the difference and testing whether it's really small.
You can either use a hard-coded epsilon value, or calculate it relative to the size of the numbers. The latter tends to be better, because it allows you to work with different number scales. E.g. you shouldn't use the same epsilon to try to calculate the square root of 12345 and 0.000012345; 0.01 might be adequate for the large number, but you'd need something like 0.000001 for the small number.
See What every programmer should know about floating point