mixing signed and unsigned

[John Harrison]

I have a problem. I want to compare an integral value, n, against three
half open ranges as follows

[-A, 0) // range 1
[0, B) // range 2
[B, C} // range 3

Each range corresponds to a different outcome and if the integral value
isn't within any of the ranges, that's a fourth outcome. So far so easy,
the problem is that n is a signed quantity and A, B, C are unsigned
quantities. Apart from this obscure corner of my code this makes perfect
sense, so I don't want to change the signedness of anything.

How to I write these tests so that my code is reasonably understandable,
rather than a horrible mess of casts and compiler warnings?

One more point, of the unsigned quantity, only B is guaranteed small
enough that it could be safely cast to a signed integer.

john

[Ian Collins]

John Harrison wrote:

I have a problem. I want to compare an integral value, n, against three
half open ranges as follows

[-A, 0) // range 1
[0, B) // range 2
[B, C} // range 3

Each range corresponds to a different outcome and if the integral value
isn't within any of the ranges, that's a fourth outcome. So far so easy,
the problem is that n is a signed quantity and A, B, C are unsigned
quantities. Apart from this obscure corner of my code this makes perfect
sense, so I don't want to change the signedness of anything.

How to I write these tests so that my code is reasonably understandable,
rather than a horrible mess of casts and compiler warnings?

One more point, of the unsigned quantity, only B is guaranteed small
enough that it could be safely cast to a signed integer.

Use the next size up, int64_t?

--
Ian Collins.

[John Harrison]

Ian Collins wrote:

John Harrison wrote:

>>I have a problem. I want to compare an integral value, n, against three
half open ranges as follows

[-A, 0) // range 1
[0, B) // range 2
[B, C} // range 3

Each range corresponds to a different outcome and if the integral value
isn't within any of the ranges, that's a fourth outcome. So far so easy,
the problem is that n is a signed quantity and A, B, C are unsigned
quantities. Apart from this obscure corner of my code this makes perfect
sense, so I don't want to change the signedness of anything.

How to I write these tests so that my code is reasonably understandable,
rather than a horrible mess of casts and compiler warnings?

One more point, of the unsigned quantity, only B is guaranteed small
enough that it could be safely cast to a signed integer.

Use the next size up, int64_t?

Well a further problem is that the signed type is ptrdiff_t and the
unsigned type is size_t. So I can't say what the next size up is, or
even if it exists.

In the past I've ranted against the very existance of unsigned types on
this group. I promise I'll repent if someone can show me an elegant way
to do this.

john

[John Harrison]

>

In the past I've ranted against the very existance of unsigned types on
this group. I promise I'll repent if someone can show me an elegant way
to do this.

john

Answering my own question here, but this is the best I've come up with

if (A <= std::numeric_li mits<ptrdiff_t> ::max() &&
n < -static_cast<ptr diff_t>(A))
{
// out of range
}
else if (n < 0)
{
// range 1
}
else if (n < static_cast<ptr diff_t><(B))
{
// range 2
}
else if (C <= std::numeric_li mits<ptrdiff_t> ::max() &&
n < static_cast<ptr diff_t>(C))
{
// range 3
}
else
{
// out of range
}

Not quite a bad as I feared but still pretty ugly.

john

[John Harrison]

John Harrison wrote:

>>
In the past I've ranted against the very existance of unsigned types
on this group. I promise I'll repent if someone can show me an elegant
way to do this.

john

Answering my own question here, but this is the best I've come up with

if (A <= std::numeric_li mits<ptrdiff_t> ::max() &&
n < -static_cast<ptr diff_t>(A))
{
// out of range
}
else if (n < 0)
{
// range 1
}
else if (n < static_cast<ptr diff_t><(B))
{
// range 2
}
else if (C <= std::numeric_li mits<ptrdiff_t> ::max() &&
n < static_cast<ptr diff_t>(C))
{
// range 3
}
else
{
// out of range
}

Not quite a bad as I feared but still pretty ugly.

john

Spoke too soon, here's the corrected version with a couple more casts

if (A <= static_cast<siz e_t>(std::numer ic_limits<ptrdi ff_t>::max())
&& n < -static_cast<ptr diff_t>(A))
{
// out of range
}
else if (n < 0)
{
// range 1
}
else if (n < static_cast<ptr diff_t>(B))
{
// range 2
}
else if (C <= static_cast<siz e_t>(std::numer ic_limits<ptrdi ff_t>::max())
&& n < static_cast<ptr diff_t>(C))
{
// range 3
}
else
{
// out of range
}

john

[John Harrison]

John Harrison wrote:

John Harrison wrote:

>>>

if (A <= static_cast<siz e_t>(std::numer ic_limits<ptrdi ff_t>::max())
&& n < -static_cast<ptr diff_t>(A))
{
// out of range
}
else if (n < 0)
{
// range 1
}
else if (n < static_cast<ptr diff_t>(B))
{
// range 2
}
else if (C <= static_cast<siz e_t>(std::numer ic_limits<ptrdi ff_t>::max())
&& n < static_cast<ptr diff_t>(C))
{
// range 3
}
else
{
// out of range
}

john

Yet another correction. Just proves how horrible this signed/unsigned
stuff is, or am I missing a trick?

else if (C static_cast<siz e_t>(std::numer ic_limits<ptrdi ff_t>::max())
|| n < static_cast<ptr diff_t>(C))

john

[Kai-Uwe Bux]

John Harrison wrote:

I have a problem. I want to compare an integral value, n, against three
half open ranges as follows

[-A, 0) // range 1
[0, B) // range 2
[B, C} // range 3

Each range corresponds to a different outcome and if the integral value
isn't within any of the ranges, that's a fourth outcome. So far so easy,
the problem is that n is a signed quantity and A, B, C are unsigned
quantities. Apart from this obscure corner of my code this makes perfect
sense, so I don't want to change the signedness of anything.

How to I write these tests so that my code is reasonably understandable,
rather than a horrible mess of casts and compiler warnings?

One more point, of the unsigned quantity, only B is guaranteed small
enough that it could be safely cast to a signed integer.

What about:

#include <iostream>

int main ( void ) {
unsigned long A = 30;
unsigned long B = 20;
unsigned long C = 100;
long x = 0;
while ( std::cin >x ) {
if ( x >= 0 ) {
if ( x < B ) {
std::cout << "range 2";
} else if ( x < C ) {
std::cout << "range 3";
} else {
std::cout << "above all ranges";
}
} else {
if ( ( -x ) <= A ) {
std::cout << "range 1";
} else {
std::cout << "below all ranges";
}
}
std::cout << '\n';
}
}

This only compares positive values. As long as the unsigned type is large
enough to represent the absolute values of the signed type, you will be
fine.
Best

Kai-Uwe Bux

[Pete Becker]

John Harrison wrote:

I have a problem. I want to compare an integral value, n, against three
half open ranges as follows

[-A, 0) // range 1
[0, B) // range 2
[B, C} // range 3

Each range corresponds to a different outcome and if the integral value
isn't within any of the ranges, that's a fourth outcome. So far so easy,
the problem is that n is a signed quantity and A, B, C are unsigned
quantities. Apart from this obscure corner of my code this makes perfect
sense, so I don't want to change the signedness of anything.

How to I write these tests so that my code is reasonably understandable,
rather than a horrible mess of casts and compiler warnings?

One more point, of the unsigned quantity, only B is guaranteed small
enough that it could be safely cast to a signed integer.

In that case, the values of the range limits need to be adjusted. If A
is greater than INT_MAX, replace it with INT_MAX. Same for C. Then do
everything signed.

--

-- Pete
Roundhouse Consulting, Ltd. (www.versatilecoding.com)
Author of "The Standard C++ Library Extensions: a Tutorial and
Reference." (www.petebecker.com/tr1book)

[Jerry Coffin]

In article <3w************ ******@newsfe2-gui.ntli.net>,
jo************* @hotmail.com says...

I have a problem. I want to compare an integral value, n, against three
half open ranges as follows

[-A, 0) // range 1
[0, B) // range 2
[B, C} // range 3

Each range corresponds to a different outcome and if the integral value
isn't within any of the ranges, that's a fourth outcome. So far so easy,
the problem is that n is a signed quantity and A, B, C are unsigned
quantities. Apart from this obscure corner of my code this makes perfect
sense, so I don't want to change the signedness of anything.

How to I write these tests so that my code is reasonably understandable,
rather than a horrible mess of casts and compiler warnings?

One more point, of the unsigned quantity, only B is guaranteed small
enough that it could be safely cast to a signed integer.

If you can't count on having a type with a large enough range to hold
all the possible values, you probably need to work primarily with
unsigned values:

bool in_range_u(ptrd iff_t value, size_t min, size_t max) {
if (value < 0)
return false;
return (static_cast<si ze_t>(value) >= min) &&
(static_cast<si ze_t>(value) < max);
}

if (in_range_u(x, 0, B))
first_range();
else if (in_range_u(-x, 0, A+1)
second_range();
else if (in_range_u(x, B, C)
third_range();
else
fourth_range();

The two casts aren't really necessary, but I'd prefer them over a
warning, which would be normal for a mixed signed/unsigned comparsison.

Although I believe the code should work, it is _quite_ fragile. For
example in_range_u(-x, 0, A+1) does NOT really work correctly. We get
around that by testing the second range first, and only testing the
first range if we've determined that x!=0.

To be pedantically correct, you might need to add special case code for
a couple of possibilities: one is for magnitude(A) == magnitude
(INT_MIN), and the other is for A==std::numeric _limits<size_t> ::max. It
isn't hard to do these without warnings or casts, but it does make the
code a bit ugly.

--
Later,
Jerry.

The universe is a figment of its own imagination.

[John Harrison]

Kai-Uwe Bux wrote:

John Harrison wrote:

>>I have a problem. I want to compare an integral value, n, against three
half open ranges as follows

[-A, 0) // range 1
[0, B) // range 2
[B, C} // range 3

Each range corresponds to a different outcome and if the integral value
isn't within any of the ranges, that's a fourth outcome. So far so easy,
the problem is that n is a signed quantity and A, B, C are unsigned
quantities. Apart from this obscure corner of my code this makes perfect
sense, so I don't want to change the signedness of anything.

How to I write these tests so that my code is reasonably understandable,
rather than a horrible mess of casts and compiler warnings?

One more point, of the unsigned quantity, only B is guaranteed small
enough that it could be safely cast to a signed integer.

What about:

#include <iostream>

int main ( void ) {
unsigned long A = 30;
unsigned long B = 20;
unsigned long C = 100;
long x = 0;
while ( std::cin >x ) {
if ( x >= 0 ) {
if ( x < B ) {
std::cout << "range 2";
} else if ( x < C ) {
std::cout << "range 3";
} else {
std::cout << "above all ranges";
}
} else {
if ( ( -x ) <= A ) {
std::cout << "range 1";
} else {
std::cout << "below all ranges";
}
}
std::cout << '\n';
}
}

This only compares positive values. As long as the unsigned type is large
enough to represent the absolute values of the signed type, you will be
fine.

I thought of something like that, but two problems.

-x would overflow if x == std::numeric_li mits<ptrdiff_t> ::min()

"above all" and "below all" are the same outcome and I'd prefer not to
write the same code twice

john