How to mask ints using bitwise operators - bit-manipulation

Question

I was wondering if there is a way to mask a list of int values using bitwise operators, and using that mask to know if a int value is one of the values that are in the mask.
i.e. if I have the values 129 and 17, how can calculate a mask that tells me if a int value corresponds in the mask (if the int value is either 129 or 17).
I expect my problem to be better understand with the next pseudocode.
**EDIT:
I Want to pack, mask or "compress" an int array in only one value (mask), and then, only accept values that are in the list of values to mask (array).
Is it possible? Thanks in advance.
valuesToMask = [17, 129, ...]
mask = getmask(valuesToMask)
lstValues = [0,1, 10, ..., 17, 18, 19, ..., 129, ...]
foreach(int value, in lstValues) {
if(check(mask,value))
printf("\nValue %d is in the mask", value);
else
printf("\nValue %d is not in the mask", value);
}
Thanks in advance. I Really appreciate your help and your time.
(Sorry for my english)

Answer 1

You can do this for certain sets of values, but not necessarily in general. For example, if you want to determine whether a value is 4, 5, 6, or 7, then you can do:
if ((value & ~3) == 4) ...
This creates a mask with all bits 1 except the least significant two bits. The & operator effectively sets the least significant two bits to 0. The comparison then checks to see whether the pattern of bits matches the value you are looking for. In binary representation, this looks like the following (assume value is an 8-bit value):
value masked
00000011 00000000 = 0
00000100 00000100 = 4
00000101 00000100 = 4
00000110 00000100 = 4
00000111 00000100 = 4
00001000 00001000 = 8
This technique would not work if for example you wanted to check for just "4, 5, or 7".

Answer 2

You can partially solve your problem with Bloom Filters. The way this works is that in order to test for membership in an N-set of items, you define K hash functions to map each item to an M-bit key. For insertion of an element a, set the filter's bits at positions h1(a) ... hk(a) equal to 1. For lookup of an element b, if you detect a zero bit at any of the h1(b) ... hk(b), then b is guaranteed not to be in the set. Depending on the values for N, M and K, there is however a small probability that you get a false positive (i.e. you detect no zeros from the hash functions, but b was not previously stored in the filter).
In pseudo-code:
const int M = 256;
typedef std::bitset<M> Mask;
int listValues[N] = { v1, ... , vN };
typedef unsigned char (*)(int) HashFunction; // maps int to 0...255
HashFunction hash[K] = { h1, ..., hK };
Mask make_mask(int x)
{
Mask m(0):
for (int i = 0; i < K; ++i) {
m[(hash[i])(x)] = 1; // update mask with item's hash
}
return(m);
}
// initialize
Mask BloomFilter(0);
for (int i = 0; i < N; ++i) {
BloomFilter |= make_mask(listValues[i]);
}
// probe
bool is_not_in_filter(const Mask& F, int x)
{
// if a zero-bit in F matches a 1-bit in make_mask(x), then x is not in F
return ~F & make_mask(x) != 0;
}
// call
int x = ...;
bool in_set = is_not_in_filter(BloomFilter, x);
Effectively, this expands each item to an M-bit key, and the filter is the aggregate bitwise OR over all items. Testing for set-membership then becomes a simple (though probabilistic) bitwise AND between the NEGATED filter with the M-bit expanded item to be tested.
UPDATE:
The above code is pseudo-code to explain how it works. To get an actual library, see e.g. the experimental Boost.Bloomfilters or bloom

Answer 3

I think your asking how you can check if a number is 129 or 17.
int[] lstValues = [0,1, 10, 17, 18, 19, 129];
foreach(int value in lstValues) {
if(lstValues == 129 || lstValues == 17)
printf("\nValue is in the mask");
else
printf("\nValue is not in the mask");
}