y >> (8 * (sizeof(int) -1))

[aarklon]

Is y >(8 * (sizeof(int) -1)) portable expression to find The MSB of
an unsigned integer y ??

will this work in all the cases, all three of the representations C
allows:

1) two's complement
2) ones'complement
3) signed magnitude.

[Joachim Schmitz]

aa*****@gmail.com wrote:

Is y >(8 * (sizeof(int) -1)) portable expression to find The MSB of
an unsigned integer y ??

Probably better and more portable:
#include <limits.h>
....
y >(CHAR_BIT * (sizeof y -1))

will this work in all the cases, all three of the representations C
allows:

1) two's complement
2) ones'complement
3) signed magnitude.

Bye, Jojo

[Harald van =?UTF-8?b?RMSzaw==?=]

On Tue, 15 Apr 2008 09:47:15 -0700, aarklon wrote:

Is y >(8 * (sizeof(int) -1)) portable expression to find The MSB of
an unsigned integer y ??

No, it isn't.

will this work in all the cases, all three of the representations C
allows:

1) two's complement
2) ones'complement
3) signed magnitude.

These differ in how negative values are represented. Why do you think
negative values matter, given that you've got an unsigned integer?

[Peter Nilsson]

[e-mail] wrote:

Is y >(8 * (sizeof(int) -1)) portable expression to find The MSB of
an unsigned integer y ??

Define MSB in the following case...

CHAR_BIT = 8
UINT_MAX = 262143

If you want the top CHAR_BIT bits from an unsigned int y, use...

y / ((UINT_MAX >(CHAR_BIT - 1) >1) + 1)

will this work in all the cases, all three of the representations C
allows:

1) two's complement
2) ones'complement
3) signed magnitude.

Unsigned integers use pure binary representation.

--
Peter

[Jack Klein]

On Tue, 15 Apr 2008 09:47:15 -0700 (PDT), aa*****@gmail.com wrote in
comp.lang.c:

>
Is y >(8 * (sizeof(int) -1)) portable expression to find The MSB of
an unsigned integer y ??

It is absolutely not portable, even if you change 8 to CHAR_BIT.

I do a lot of work on a DSP where sizeof(char), sizeof(short), and
sizeof(int) are all 1. CHAR_BIT happens to be 16, of course, and
sizeof(long) is 2, sizeof(long long) is 4.

So on this implementation, either of the expressions:

(8 * (1 - 1))

....or:

(16 * (1 - 1))

....will not tell you anything about the MSB.

will this work in all the cases, all three of the representations C
allows:

1) two's complement
2) ones'complement
3) signed magnitude.

As others have stated, the representation of the signed int types in a
C implementation has nothing to do with the unsigned types.

Try this:

#include <limits.h>

#define UINT_MSB_MASK (UINT_MAX - (UINT_MAX >1))

if (some_unsigned_int & UINT_MSB_MASK)
/* do stuff because it is set */
else
/* do stuff because it is not set */

--
Jack Klein
Home: http://JK-Technology.Com
FAQs for
comp.lang.c http://c-faq.com/
comp.lang.c++ http://www.parashift.com/c++-faq-lite/
alt.comp.lang.learn.c-c++
http://www.club.cc.cmu.edu/~ajo/docs/FAQ-acllc.html

[aarklon]

On Apr 15, 9:56 pm, Harald van D©¦k <[e-mail]:

On Tue, 15 Apr 2008 09:47:15 -0700,aarklonwrote:

Is y >(8 * (sizeof(int) -1)) portable expression to find The MSB of
an unsigned integer y ??

No, it isn't.

will this work in all the cases, all three of the representations C
allows:

1) two's complement
2) ones'complement
3) signed magnitude.

These differ in how negative values are represented. Why do you think
negative values matter, given that you've got an unsigned integer?

what about finding the MSB of a signed integer ?

[Flash Gordon]

aa*****@gmail.com wrote, On 16/04/08 18:00:

<snip>

what about finding the MSB of a signed integer ?

You cannot find that by shifting since right shifting a negative value
gives an implementation defined result and left shifting a 1 in to the
MSB invokes undefined behaviour. If you want to know the sign and don't
care about negative zero then just use either <0 or >=0 as appropriate.
--
Flash Gordon

[Spiros Bousbouras]

On 16 Apr, 03:08, Jack Klein <[e-mail]:

On Tue, 15 Apr 2008 09:47:15 -0700 (PDT), [e-mail] wrote in
comp.lang.c:

Is *y >(8 * (sizeof(int) -1)) portable expression to find TheMSBof
an unsigned integer y ??

It is absolutely notportable, even if you change 8 to CHAR_BIT.
<S N I P>
Try this:

#include <limits.h>

#define UINT_MSB_MASK * (UINT_MAX - (UINT_MAX >1))

if (some_unsigned_int & UINT_MSB_MASK)
* */* do stuff because it is set */
else
* */* do stuff because it is not set */

I think he got the parentheses wrong.
y >(CHAR_BIT * sizeof(int) - 1)
where the expression will be 1 if and only
if the MSB of y is set , seems fine to me.

But your solution looks neater and is likely
faster.

[Spiros Bousbouras]

On 16 Apr, 20:18, Flash Gordon <[e-mail]:

[e-mail] wrote, On 16/04/08 18:00:

<snip>

what about finding the MSB of a signed integer ?

You cannot find that by shifting since right shifting a negative value
gives an implementation defined result and left shifting a 1 in to the
MSB invokes undefined behaviour. If you want to know the sign and don't
care about negative zero then just use either <0 or >=0 as appropriate.

I think that by "MSB of a signed integer" he means
the bit which contributes the most to the magnitude
of the value rather than the sign bit.

I believe that a variation of Jack Klein's solution
for unsigned integers will also work in this case:

#include <limits.h>

#define INT_MSB_MASK (INT_MAX - (INT_MAX >1))

if (#include <limits.h>
#define UINT_MSB_MASK (UINT_MAX - (UINT_MAX >1))

if (some_unsigned_int == 0)
/* do stuff because it is not set */
else if (some_signed_int & INT_MSB_MASK)
/* do stuff because it is set */
else
/* do stuff because it is not set */

[=?ISO-8859-1?Q?Tom=E1s_=D3_h=C9ilidhe?=]

On a minority of systems, there's padding bits within integer types,
and so sizeof(integer type) won't give you the amount of value
representational bits.

[Spiros Bousbouras]

On 19 Apr, 15:49, Spiros Bousbouras <[e-mail]:

On 16 Apr, 20:18, Flash Gordon <[e-mail]:

[e-mail] wrote, On 16/04/08 18:00:

<snip>

what about finding the MSB of a signed integer ?

You cannot find that by shifting since right shifting a negative value
gives an implementation defined result and left shifting a 1 in to the
MSB invokes undefined behaviour. If you want to know the sign and don't
care about negative zero then just use either <0 or >=0 as appropriate..

I think that by "MSB of a signed integer" he means
the bit which contributes the most to the magnitude
of the value rather than the sign bit.

I believe that a variation of Jack Klein's solution
for unsigned integers will also work in this case:

#include <limits.h>

#define INT_MSB_MASK * (INT_MAX - (INT_MAX >1))

if (#include <limits.h>

#define UINT_MSB_MASK * (UINT_MAX - (UINT_MAX >1))

if (some_unsigned_int == 0)
* */* do stuff because it is not set */
else if (some_signed_int & INT_MSB_MASK)
* */* do stuff because it is set */
else
* */* do stuff because it is not set */

I bungled up my post above. The correct version is

#include <limits.h>

#define INT_MSB_MASK (INT_MAX - (INT_MAX >1))

if (some_signed_int == 0)
/* do stuff because it is not set */
else if (some_signed_int & INT_MSB_MASK)
/* do stuff because it is set */
else
/* do stuff because it is not set */

The above treats specially the value 0 in that even if it is
negative zero in an one's complement representation it still
considers the bit not to be set.

[Spiros Bousbouras]

On 19 Apr, 17:14, Tomás Ó hÉilidhe <[e-mail]:

On a minority of systems, there's padding bits within integer types,
and so sizeof(integer type) won't give you the amount of value
representational bits.

Therefore the expression y >(CHAR_BIT * sizeof(int) - 1) is not
a portable way to check if the MSB is set after all. If there is
even one padding bit the expression will always yield 0 regardless
of whether the MSB is set or not.

[Harald van =?UTF-8?b?RMSzaw==?=]

On Tue, 22 Apr 2008 10:45:41 -0700, Spiros Bousbouras wrote:

On 19 Apr, 17:14, Tomás Ó hÉilidhe <[e-mail]:

>On a minority of systems, there's padding bits within integer types,
and so sizeof(integer type) won't give you the amount of value
representational bits.

Therefore the expression y >(CHAR_BIT * sizeof(int) - 1) is not a
portable way to check if the MSB is set after all. If there is even one
padding bit the expression will always yield 0 regardless of whether the
MSB is set or not.

If there is any padding, (CHAR_BIT * sizeof(int) - 1) will be greater
than or equal to the width of unsigned int, meaning the behaviour is
undefined if you right-shift by that amount. The expression won't
necessarily evaluate to 0.