Do multiples of Pi to the thousandths have a value that may change how a loop executes?

Question

Recently I decided to get into c++, and after going through the basics I decided to build a calculator using only iostream (just to challenge myself). After most of it was complete, I came across an issue with my loop for exponents. Whenever a multiple of Pi was used as the exponent, it looped way too many times. I fixed it in a somewhat redundant way and now I'm hoping someone might be able to tell me what happened. My unfixed code snippet is below. Ignore everything above and just look at the last bit of fully functioning code. All I was wondering was why values of pi would throw off the loop so much. Thanks.

bool TestForDecimal(double Num) /* Checks if the number given is whole or not */ { 
    if (Num > -INT_MAX && Num < INT_MAX && Num == (int)Num) {
        return 0;
    }
    else {
        return 1;
    }
}

And then heres where it all goes wrong (Denominator is set to a value of 1)

if (TestForDecimal(Power) == 1) /* Checks if its decimal or not */ {
    while (TestForDecimal(Power) == 1) {
        Power = Power * 10;
        Denominator = Denominator * 10;
    }
}

If anyone could give me an explanation that would be great!

To clarify further, the while loop kept looping even after Power became a whole number (This only happened when Power was equal to a multiple of pi such as 3.1415 or 6.2830 etc.)

Heres a complete code you can try:

#include <iostream>

bool TestForDecimal(double Num) /* Checks if the number given is whole or not */ {
if (Num > -INT_MAX && Num < INT_MAX && Num == (int)Num) {
    return 0;
}
else {
    return 1;
}
}

void foo(double Power) {
double x = Power;
if (TestForDecimal(x) == 1) /* Checks if its decimal or not */ {
    while (TestForDecimal(x) == 1) {
        x = x * 10;
        std::cout << x << std::endl; 
    }
}
}

int main() {
foo(3.145); // Substitute this with 3.1415 and it doesn't work (this was my problem)
system("Pause");
return 0;
}

Answer 1

What's wrong with doing something like this?

#include <cmath> // abs and round
#include <cfloat> // DBL_EPSILON

bool TestForDecimal(double Num) {
  double diff = abs(round(Num) - Num);
  // true if not a whole number
  return diff > DBL_EPSILON;
}

Answer 2

The look is quite inefficient...what if Num is large...

A faster way could be something like

if (Num == static_cast<int>(Num))

or

 if (Num == (int)Num)

if you prefer a C-style syntax.

Then a range check may be useful... it oes not make sense to ask if Num is an intger when is larger than 2^32 (about 4 billions)

Finally do not think od these numers as decimals. They are stored as binary numbers, instead of multiplying Power and Denominator by 2 you are better of multiplying them by 2.

Answer 3

After studying your "unfixed" function, from what I can tell, here's your basic algorithm:

1. double TestForDecimal(double Num) { ...

A function that accepts a double and returns a double. This would make sense if the returned value was the decimal value, but since that's not the case, perhaps you meant to use bool?

2. while (Num > 1) { make it less }

While there is nothing inherently wrong with this, it doesn't really address negative numbers with large magnitudes, so you'll run into problems there.

3. if (Num > -INT_MAX && Num < INT_MAX && Num == (int)Num) { return 0; }

This means that if Num is within the signed integer range and its integer typecast is equal to itself, return a 0 typecasted to a double. This means you don't care whether numbers outside the integer range are whole numbers or not. To fix this, change the condition to if (Num == (long)Num) since sizeof(long) == sizeof(double).

Perhaps the algorithm your function follows that I've just explained might shed some light on your problem.

Answer 4

Beware. A double is (generally but I think you use a standard architecture) represented in IEE-754 format, that is mantissa * 2^exponent. For a double, you have 53 bits for the mantissa part, one for the sign and 10 for the exponent. When you multiply it by 10 it will grow, and will get an integer value as soon as exponent will be greater than 53.

Unfortunately, unless you have a 64 bits system, an 53 bits integer cannot be represented as a 32 bits int, and your test will fail again.

So if you have a 32 bits system, you will never reach an integer value. You will more likely reach an infinity representation and stay there ...

The only use case where it could work, would be if you started with a number that can be represented with a small number of negative power of 2, for example 0.5 (1/2), 0.25(1/4), 0.75(1/2 + 1/4), giving almost all digits of mantissa part being 0.

Answer 5

Most decimal fractions can't be represented exactly in a binary floating-point format, so what you're trying to do can't work in general. For example, with a standard 64-bit double format, the closest representable value to 3.1415 is more like 3.1415000000000001812.

If you need to represent decimal fractions exactly, then you'll need a non-standard type. Boost.Multiprecision has some decimal types, and there's a proposal to add decimal types to the standard library; some implementations may have experimental support for this.