Differentiate between a number (of type double) with decimal places and one without - c++

I am trying to implement a simple decimation algorithm in c++. I have two arrays, say p & q, where the subscripts are related to each other by the following relation:

p[k] = q[0.5*k]. This means that the following sequence should hold valid:

p[0] = q[0]  
p[1] = 0  
p[2] = q[1]  
p[3] = 0  
p[4] = q[2]  

and so on...

Please note that p[k] takes on a value only and only when the result of (0.5*k) contains no decimal places (or has 0 in decimal) and does not use any rounding off etc.

My question is: Is there a way to distinguish between an integer (a number with no decimal places or only 0 in decimal, say 2.0) and a numbe开发者_StackOverflow中文版r with decimal places in C++, provided both are cast to double?

eg.) 2.0 is an integer cast to double. 2.1 is a number with decimal places.

eg. 2) * 0.9*2 should put 0 into array p while 0.9*10 should put q[9] into array p.*

If I use the statement, (int) (0.5*k), then I end up with an integer in every case, irrespective of the value of k.

Edit: The 0.5 in the above case is only illustrative. It could be any number, say 2, 2.5, 0.9, 0.95 etc.)

Any help is most welcome,

Thanks,

Sriram.

Assuming k is of an integer type, you could use if (k % 2 == 0) ... to check if kis divisible by two:

if (k % 2 == 0)
  p[k] = q[k / 2];
else
  p[k] = 0;

This can also be expressed using the ternary operator:

p[k] = (k % 2 == 0) ? q[k / 2] : 0;

Presuming that the coef can be anything else,

p[floor(coef*k)] = (fabs(coef*k-floor(coef*k))<1E-6)?q[k]:0;

The short syntax for what you want to do could be this:

p[k] = k % 2 ? 0 : q[k/2];

Is there a way to distinguish between a whole number and an integer in C++?

Define whole number, and define integer in this context. I'm confused!

Are you taking about the difference as explained here?

If you want to detect whether a number is integer or not, then probably this may help:

#include<cmath>

bool IsInteger(double d)
{  
    double intpart;
    return std::modf(double number, &intpart) == 0.0;
}

k % 2 is in a couple of answers in this thread.

However, this is not useful in answering the OP's question. Note the edit: "Edit: The 0.5 in the above case is only illustrative. It could be any number, say 2, 2.5, 0.9, 0.95 etc.)"

k % 2 only works because the value chosen was 0.5. It won't hold true for any other values.

Therefore, unless I'm missing something entirely, the simplest approach I can think of is the following:

Subtract the floor of the number from the number itself. If the result is > 0, it is not an integer.

Unless you have expressions that result in irrational numbers, you could use Boost.Rational to represent your indizes.

@Aix's suggestion of k%2 looks like it'd combine nicely with the ?: operator:

p[k] = (k%2) ? 0 : q[k/2];