double and %

Hi,

I have a very big number (up to 15 digits) which is stored as a double
I need to know if this number is integer or not
but % function doesn't exist for double

I wanted to do chaeck myDoubleNum%1 is not equal to 0

any suggestions?

thanks

Given that doubles cannot represent all values with absolute precision you might find that you assign (or enter) an integer (say 15.0) but that the double represents it as 14.999999999999.

What are you trying to do?

There is a possible solution, but it has a serious caveat.

The solution is to use the function modf

Quote:

---

modf
Splits a floating-point value into fractional and integer parts.

double modf( double x, double *intptr );

Return Value

This function returns the signed fractional portion of x. There is no error return.

---

The problem with this is that the fractional part may not be exactly zero, if you have worked with the number a bit. This is a standard problem when handling floating point numbers and the usual solution is to treat everything smaller than a given epsilon as zero.

So the code could look like this:

Code:

---

#include <math.h>

const double epsilon = 0.00001; // you should adjust this as needed

bool IsInteger(double d)
{
  double intpart;
  return fabs(modf(d, &intpart)) < epsilon;
}

---

well

I found an ugly soloution to my specific problem

I get my gig number as a string and I have to divide it by 100 before using it.

since the string doesn't contain . (that's one of the rules)

then I simply check its last 2 chars I need them both to be 00 inorder to get an Integer

something like that:

double dMyDouble = atof(sMyTmpString.c_str());
dMyDouble /= 100;

if((sMyTmpString[14]== '0') && (sMyTmpString[13]== '0'))
{
//an integer
}
else
//not an integer

note: sMyTmpString is maximum 15 chars long and does not '.'

What do you think?

Why don't you just use an integer in the first place ? Many compilers include 64 bit integers which would be enough to handle 15 decimal digits. On MS VC, the datatype in question is called __int64.

well I can't use int because the number may not be an Integer and then I need to treat it differently, but you gave ma another idea, check the difference between the double value to the __int64 value, meaning:

double dMyDouble = atof(sMyTmpString.c_str());
dMyDouble /= 100;

double dDiff = dMyDouble - (__int64)dMyDouble;
if(dDiff)
printf("Not an integer");
else
printf("An integer");

What do you think?
Is it better than my privious one?

There may be problems with both approaches. The first one will not work correctly if the string doesn't contain exactly 14 digits. What if the string is only "12" ? The second approach suffers from the same rounding problems that Dave and myself have pointed out above.

If you really need doubles then just use my IsInteger function.

what about:

double d = 5.1;
if( double(int(d)) == d ) // is a integer

Quote:

---

Originally posted by mwilliamson
what about:

double d = 5.1;
if( double(int(d)) == d ) // is a integer

---

Same representation problem. Floating point numbers may not exactly correspond with what you assign them. You cant safely do an == with a double, its not a precise representation.

avi123,

Since you already captured the int/double value in the form of string, why not scan for the decimal point or '.'. If there exists non-zero value character(s) after the decimal point, the string presentation must be a double.

Quote:

---

Originally posted by avi123
Hi,

I have a very big number (up to 15 digits) which is stored as a double
I need to know if this number is integer or not
but % function doesn't exist for double

I wanted to do chaeck myDoubleNum%1 is not equal to 0

any suggestions?

thanks

---

May I ask why it has to be 15 digits ? :(

Thanks a lot...

Regards,

-Nina

Quote:

---

Originally posted by hometown
May I ask why it has to be 15 digits ? :(

Thanks a lot...

Regards,

-Nina

---

different program have differ specifications and requirements..In what he is doin he needs to manipulate a 15 didgit number...
or he simply wants to learn how to manipulate in case of a 15 digit no...
<edit>BTW : he said UPTO 15..</edit>

Instead of modf, use floor() instead. Do use the "epsilon" approach suggested by Yves. I like using "FLT_MIN" for that purpose.

Code:

---

#include <math.h>
#include <float.h>

int function(double dbl)
{

/* ... */

  if (  ( dbl - floor(dbl) ) < FLT_MIN )
  {
    /* treat as integer. */
  }
  else
  {
    /* not integer. */
  }


/* ... */

}

---

-rick

If my memory serves me right, this doesn't work for negative numbers.

Yup, I forgot the fabs().
-rick

Not only that. The thing is that floor(-1.000001) is -2.0, so even if your FLT_MIN is only 0.0001 then it will fail.

Quote:

---

Originally posted by Kheun
avi123,

Since you already captured the int/double value in the form of string, why not scan for the decimal point or '.'. If there exists non-zero value character(s) after the decimal point, the string presentation must be a double.

---

As said before, the string will not contain the '.' character. From what I understand, the captured number is kind of a monetary number, captured without the '.', but it still include 2 decimals (cents).

Checking the last 2 digits might be the more accurate solution, easy enough to implement.

Yves - depends on where/how you use fabs() !

double abs = fabs(dbl);
if ( ( abs - floor(abs) ) < FLT_MIN ) ...

(but you've made good point either way)

-rick

Yeek. There has been some dodgy code posted here.

Firstly, you cannot use a simple floor() or modf() function. If you do, then 14.99999999999 will be rounded to 14, not 15.

On VC++ 6.0, FLT_MIN is 1.175494351e-38F, which is way too small for your epsilon value.

You might use FLT_EPS, which is 1.192092896e-07F, however you would be better looking at the data and deciding on a suitable epsilon value. You need to consider where the data came from, and how accurate it truely is. If it is only recorded to the nearest 0.1, then an epsilon value of 1.0e-7 is silly.

You might get something like this:

Code:

---

#include <cmath>

const double epsilon = 0.000001;  // choose an appropriate value for this.

double Round(double val)
{
    return floor(val+0.5);
}

bool IsInt(double val)
{
    return epsilon > fabs(val-Round(val));
}

---