Thread: Dealing with bits

I'm not sure what it is you're trying to do here. If you pass it 5 and 3, are you trying to get:

00000000 00000000 00000000 00111000

IE: Everything from high to low is set to 1 and the rest zero? Or what?


Quzah.

I'm probably assuming too much again somehow or other, but you could try

Code:

unsigned long bitMask(unsigned long high, unsigned long low)
{
	unsigned long out, t = ~0;
	
	out = (t << high) << 1;
	out |= ~(t << low);
	
	return ~out;
}

where you essentially create the bit fields at the sides of the desired field, then invert the bits

So initialize your variable at start to zero, preform an if check...

Code:

int foo( int bar, int baz )
{
    int fbb = 0;
    if( baz < bar )
        ...play around with the bits...
    return fbb;
}

Quzah.

Well this would work on a compiler which pads negative signed ints with 1s when shifted to the right:

Code:

unsigned long getbitmask(unsigned long high, unsigned long low)
{
	unsigned long out, sign, t = ~0;
	
	sign = (signed long)(high + ~low + 1) >> ((sizeof(long) << 3) + t); //or 31 if this is going to be run on a system in which sizeof(long) = 4
	
	out = (t << high) << 1;
	out |= ~(t << low);
	
	return ~(out | sign); //equivelent to ~out & ~sign;
}

quzah:

Legal ops: ! ~ & ^ | + << >>

if is not an operator. It is a keyword. if you want to be picky, = is not in the list of allowed operators! You lose!


Quzah.

Well I was actually refering to your '<' operator...

And besides, you can still write the function without the assignment operator:

Code:

unsigned long getbitmask2(unsigned long high, unsigned long low)
{
	return ~(((~0 << high) << 1 | ~(~0 << low)) | ((signed long)(high + ~low + 1) >> 31));
}

Ah, well I suppose '<' is an operator after all then. Well good job on doing their homework anyway.


Quzah.

Another take:

Code:

#include <stdio.h>
#include "util.h" /* for bits_uint */

int bitMask_(int highbit, int lowbit);

/*******************************************************************************
 * bitMask - Generate a mask consisting of all 1's
 * lowbit and highbit
 * Examples: bitMask(5,3) = 0x38
 * Assume 0 <= lowbit <= 31, and 0 <= highbit <= 31
 * If lowbit > highbit, then mask should be all 0's
 * Legal ops: ! ~ & ^ | + << >>
 * Max ops: 16
 * Rating: 3
 */
int bitMask(int highbit, int lowbit)
{
    return (((~0 << lowbit) ^ ((~0 << highbit) << 1)) >> lowbit) << lowbit;
}

int main(void)
{
    int i = 5, j = 3;
    printf("bitmask(%d,%d) = %x\n", i, j, bitMask_(i,j));
    i = 3, j = 5;
    printf("bitmask(%d,%d) = %x\n", i, j, bitMask_(i,j));
    return 0;
}

/*******************************************************************************
 * Program Output
bitMask_(5,3) : a = 11111111111111111111111111111000
bitMask_(5,3) : b = 11111111111111111111111111000000
bitMask_(5,3) : c = 00000000000000000000000000111000
bitMask_(5,3) : d = 00000000000000000000000000000111
bitMask_(5,3) : e = 00000000000000000000000000111000
bitmask(5,3) = 38
bitMask_(3,5) : a = 11111111111111111111111111100000
bitMask_(3,5) : b = 11111111111111111111111111110000
bitMask_(3,5) : c = 00000000000000000000000000010000
bitMask_(3,5) : d = 00000000000000000000000000000000
bitMask_(3,5) : e = 00000000000000000000000000000000
bitmask(3,5) = 0
 */

/*******************************************************************************
 * Description:
 *    This function explains the other version "in slow motion".
 *    It uses the bits_uint function, implemented elsewhere, to show the bits.
 */
int bitMask_(int highbit, int lowbit)
{
    char binary[33];
    int a,b,c,d,e;

    a =  ~0 << lowbit;
    printf("bitMask_(%d,%d) : a = %s\n", highbit, lowbit, bits_uint(binary, a));

    b = (~0 << highbit) << 1;
    printf("bitMask_(%d,%d) : b = %s\n", highbit, lowbit, bits_uint(binary, b));

    c = a ^ b;
    printf("bitMask_(%d,%d) : c = %s\n", highbit, lowbit, bits_uint(binary, c));

    d = c >> lowbit;
    printf("bitMask_(%d,%d) : d = %s\n", highbit, lowbit, bits_uint(binary, d));

    e = d << lowbit;
    printf("bitMask_(%d,%d) : e = %s\n", highbit, lowbit, bits_uint(binary, e));

    return e;
}