How to check if a double is near an int?

[xz]

In a program, if a double is within 0.0001 from an int, then I treat
it as int. For example, 10.00005 will be treated as int, while 10.001
is not.

I am looking for an algorithm to implement this checking. Anybody
gives an idea?

Thanks.

[Christopher]

On Apr 23, 4:56 pm, xz <[e-mail]:

In a program, if a double is within 0.0001 from an int, then I treat
it as int. For example, 10.00005 will be treated as int, while 10.001
is not.

I am looking for an algorithm to implement this checking. Anybody
gives an idea?

Thanks.

Depends what you mean by "treat it as"

Surely the math is simple enough to grab to decimal portion of the
double and compare it to .0001 or any variable amount you wish.
Getting the quotient and remainder after dividing by 1 comes to mind.
I doubt I'd even call it an algorithm...

[xz]

On Apr 23, 5:05 pm, Christopher <[e-mail]:

On Apr 23, 4:56 pm, xz <[e-mail]:

In a program, if a double is within 0.0001 from an int, then I treat
it as int. For example, 10.00005 will be treated as int, while 10.001
is not.

I am looking for an algorithm to implement this checking. Anybody
gives an idea?

Thanks.

Depends what you mean by "treat it as"

Surely the math is simple enough to grab to decimal portion of the
double and compare it to .0001 or any variable amount you wish.
Getting the quotient and remainder after dividing by 1 comes to mind.
I doubt I'd even call it an algorithm...

By "treat it as" I mean I will do different things for the doubles
near int and for the doubles not near int.

Your trick (if you don't wanna call it algorithm) does not really work
for my case because I wanna 9.99999 to be "near int" however its
decimal portion is 0.99999.

[Christopher]

On Apr 23, 5:15 pm, xz <[e-mail]:

On Apr 23, 5:05 pm, Christopher <[e-mail]:

On Apr 23, 4:56 pm, xz <[e-mail]:

In a program, if a double is within 0.0001 from an int, then I treat
it as int. For example, 10.00005 will be treated as int, while 10.001
is not.

I am looking for an algorithm to implement this checking. Anybody
gives an idea?

Thanks.

Depends what you mean by "treat it as"

Surely the math is simple enough to grab to decimal portion of the
double and compare it to .0001 or any variable amount you wish.
Getting the quotient and remainder after dividing by 1 comes to mind.
I doubt I'd even call it an algorithm...

By "treat it as" I mean I will do different things for the doubles
near int and for the doubles not near int.

Well, that certainly sheds some light on things. "treat it as" means
"do different things"....hmmm
Pretty hard to help you when you won't describe what you are trying to
do.

Your trick (if you don't wanna call it algorithm) does not really work
for my case because I wanna 9.99999 to be "near int" however its
decimal portion is 0.99999.

Still the same principle:

if( remainder - tolerance < 0.0 )
{
// Do whatever you mean by treat as int and round down if you wish
}
else if( remainder + tolerance 1.0 )
{
// Do whatever you mean by treat as int and round up if you wish
}

[Thomas Austad]

Are you looking for a "algorithm" like this then?

bool isNearInt( double value )
{
const double epsilon = 0.0001;
const double diff = value - floor( value );
return ( diff <= epsilon || diff >= (1.0 - epsilon) );
}

which should at least answer the within epsilon of an integer value.
xz wrote:

On Apr 23, 5:05 pm, Christopher <[e-mail]:

>On Apr 23, 4:56 pm, xz <[e-mail]:

>>In a program, if a double is within 0.0001 from an int, then I treat
it as int. For example, 10.00005 will be treated as int, while 10.001
is not.
I am looking for an algorithm to implement this checking. Anybody
gives an idea?
Thanks.

Depends what you mean by "treat it as"

Surely the math is simple enough to grab to decimal portion of the
double and compare it to .0001 or any variable amount you wish.
Getting the quotient and remainder after dividing by 1 comes to mind.
I doubt I'd even call it an algorithm...

By "treat it as" I mean I will do different things for the doubles
near int and for the doubles not near int.

Your trick (if you don't wanna call it algorithm) does not really work
for my case because I wanna 9.99999 to be "near int" however its
decimal portion is 0.99999.

[xz]

On Apr 23, 5:35 pm, Christopher <[e-mail]:

On Apr 23, 5:15 pm, xz <[e-mail]:

On Apr 23, 5:05 pm, Christopher <[e-mail]:

On Apr 23, 4:56 pm, xz <[e-mail]:

In a program, if a double is within 0.0001 from an int, then I treat
it as int. For example, 10.00005 will be treated as int, while 10.001
is not.

I am looking for an algorithm to implement this checking. Anybody
gives an idea?

Thanks.

Depends what you mean by "treat it as"

Surely the math is simple enough to grab to decimal portion of the
double and compare it to .0001 or any variable amount you wish.
Getting the quotient and remainder after dividing by 1 comes to mind.
I doubt I'd even call it an algorithm...

By "treat it as" I mean I will do different things for the doubles
near int and for the doubles not near int.

Well, that certainly sheds some light on things. "treat it as" means
"do different things"....hmmm
Pretty hard to help you when you won't describe what you are trying to
do.

Sorry about not having expressed it clearly and thanks for your help.

>

Your trick (if you don't wanna call it algorithm) does not really work
for my case because I wanna 9.99999 to be "near int" however its
decimal portion is 0.99999.

Still the same principle:

if( remainder - tolerance < 0.0 )
{
// Do whatever you mean by treat as int and round down if you wish}

else if( remainder + tolerance 1.0 )
{
// Do whatever you mean by treat as int and round up if you wish

}

However, this is like a brutal force way that I actually thought
about.
I am wondering if there is any smarter way to do that? Like finishing
the job in a relatively simple expression?
Still appreciate a lot for your help.

[dp1978x]

On Apr 23, 5:56 pm, xz <[e-mail]:

In a program, if a double is within 0.0001 from an int, then I treat
it as int. For example, 10.00005 will be treated as int, while 10.001
is not.

I am looking for an algorithm to implement this checking. Anybody
gives an idea?

Thanks.

Something like this? but see also http://www.parashift.com/c++-faq-lit...html#faq-29.17

bool close_to_int (double d, double tolerance) {
double cdiff = std::fabs (std::ceil (d) - d);
double fdiff = std::fabs (std::floor (d) - d);
if (cdiff < fdiff)
return cdiff <= tolerance;
return fdiff <= tolerance;
}

[Thomas J. Gritzan]

xz wrote:

On Apr 23, 5:05 pm, Christopher <[e-mail]:

>On Apr 23, 4:56 pm, xz <[e-mail]:

>>In a program, if a double is within 0.0001 from an int, then I treat
it as int. For example, 10.00005 will be treated as int, while 10.001
is not.
I am looking for an algorithm to implement this checking. Anybody
gives an idea?
Thanks.

Depends what you mean by "treat it as"

Surely the math is simple enough to grab to decimal portion of the
double and compare it to .0001 or any variable amount you wish.
Getting the quotient and remainder after dividing by 1 comes to mind.
I doubt I'd even call it an algorithm...

By "treat it as" I mean I will do different things for the doubles
near int and for the doubles not near int.

Your trick (if you don't wanna call it algorithm) does not really work
for my case because I wanna 9.99999 to be "near int" however its
decimal portion is 0.99999.

Given:
#include <cmath>
const double eps = 0.0001; // your treshold
double d = 10.00005; // your number

The algorithm would be:
1. Round d to nearest integer.
2. Check if nearest integer is within treshold.

double near = std::floor(d+0.5);
if (std::abs(d - near) < eps) {
int i = near;
// use i or near
}
else
{
// use d
}

--
Thomas

[xz]

On Apr 23, 5:48 pm, "Thomas J. Gritzan" <[e-mail]>
wrote:

xz wrote:

On Apr 23, 5:05 pm, Christopher <[e-mail]:

On Apr 23, 4:56 pm, xz <[e-mail]:

>In a program, if a double is within 0.0001 from an int, then I treat
it as int. For example, 10.00005 will be treated as int, while 10.001
is not.
I am looking for an algorithm to implement this checking. Anybody
gives an idea?
Thanks.
Depends what you mean by "treat it as"

Surely the math is simple enough to grab to decimal portion of the
double and compare it to .0001 or any variable amount you wish.
Getting the quotient and remainder after dividing by 1 comes to mind.
I doubt I'd even call it an algorithm...

By "treat it as" I mean I will do different things for the doubles
near int and for the doubles not near int.

Your trick (if you don't wanna call it algorithm) does not really work
for my case because I wanna 9.99999 to be "near int" however its
decimal portion is 0.99999.

Given:
#include <cmath>
const double eps = 0.0001; // your treshold
double d = 10.00005; // your number

The algorithm would be:
1. Round d to nearest integer.
2. Check if nearest integer is within treshold.

double near = std::floor(d+0.5);
if (std::abs(d - near) < eps) {
int i = near;
// use i or near}

else
{
// use d

}

--
Thomas

+0.5!

That's smart! Exactly what I wanted!

Thanks a lot!

[xz]

On Apr 23, 5:48 pm, "Thomas J. Gritzan" <[e-mail]>
wrote:

xz wrote:

On Apr 23, 5:05 pm, Christopher <[e-mail]:

On Apr 23, 4:56 pm, xz <[e-mail]:

>In a program, if a double is within 0.0001 from an int, then I treat
it as int. For example, 10.00005 will be treated as int, while 10.001
is not.
I am looking for an algorithm to implement this checking. Anybody
gives an idea?
Thanks.
Depends what you mean by "treat it as"

Surely the math is simple enough to grab to decimal portion of the
double and compare it to .0001 or any variable amount you wish.
Getting the quotient and remainder after dividing by 1 comes to mind.
I doubt I'd even call it an algorithm...

By "treat it as" I mean I will do different things for the doubles
near int and for the doubles not near int.

Your trick (if you don't wanna call it algorithm) does not really work
for my case because I wanna 9.99999 to be "near int" however its
decimal portion is 0.99999.

Given:
#include <cmath>
const double eps = 0.0001; // your treshold
double d = 10.00005; // your number

The algorithm would be:
1. Round d to nearest integer.
2. Check if nearest integer is within treshold.

double near = std::floor(d+0.5);
if (std::abs(d - near) < eps) {

I guess you meant fabs(...), right?

int i = near;
// use i or near}

else
{
// use d

}

--
Thomas

[Thomas J. Gritzan]

xz wrote:

>Given:
#include <cmath>
const double eps = 0.0001; // your treshold
double d = 10.00005; // your number

The algorithm would be:
1. Round d to nearest integer.
2. Check if nearest integer is within treshold.

double near = std::floor(d+0.5);
if (std::abs(d - near) < eps) {

I guess you meant fabs(...), right?

No. std::abs is overloaded for built-in types. fabs() has the signature:
double fabs(double);

So in this case you can use both.

--
Thomas

[xz]

On Apr 23, 9:59*pm, "Thomas J. Gritzan" <[e-mail]>
wrote:

xz wrote:

Given:
#include <cmath>
const double eps = 0.0001; // your treshold
double d = 10.00005; // your number

The algorithm would be:
* *1. Round d to nearest integer.
* *2. Check if nearest integer is within treshold.

double near = std::floor(d+0.5);
if (std::abs(d - near) < eps) {

I guess you meant fabs(...), right?

No. std::abs is overloaded for built-in types. fabs() has the signature:
* *double fabs(double);

So in this case you can use both.

Thanks!

>
--
Thomas