Lexicographical comparison of integers - c++

Question

I want to compare two small (<=20) sets of integers (1..20) lexicographically.
The sets are represented by single integers, e.g.
1, 2, 4, 6
will be represented as
... 0 1 0 1 0 1 1
(... 7 6 5 4 3 2 1)
So where there's a 1 the number is present in the set.
Could someone verify if this code is correct?
bool less_than(unsigned a, unsigned b) {
unsigned tmp = a ^ b;
tmp = tmp & (~tmp + 1); //first difference isolated
return (tmp & a) && (__builtin_clz(b) < __builtin_clz(tmp));
}
The __builtin_clz part is for the case when b is a prefix of a.
The case of an empty set is handled elsewhere (__builtin_clz is undefined for 0).
EDIT:
bool less_than(unsigned a, unsigned b) {
unsigned tmp = a ^ b;
tmp &= -tmp; //first difference isolated
return ((tmp & a) && (__builtin_clz(b) < __builtin_clz(tmp)))
|| (__builtin_clz(a) > __builtin_clz(tmp));
}
and
bool less_than_better(unsigned a, unsigned b) {
unsigned tmp = a ^ b;
tmp &= -tmp; //first difference isolated
return ((tmp & a) && tmp < b) || tmp > a;
}
appear to be both correct.
(Tested versus a naive implementation using std::lexicographical_compare on tens of millions of randomized tests)
The second one is more portable though since it doesn't use __builtin_clz.
The difference in speed on my machine is negligible (the second one being ~2% faster), however on machines without __builtin_clz as one processor instruction (e.g. BSR on x86) the difference will probably be huge.

Answer 1

It's not correct in the case that a == 0. This should return true unless b == 0, but since tmp & a will be false regardless of the value of tmp (which will be the lowest-order 1-bit in b), the function will return false.
a should be "less than" b if:
1. `a` is a proper prefix of `b`, or
2. The lowest-order bit of `a^b` is in `a`.
The first condition also handles the case where a is the empty set and b is not. (This is slightly different from your formulation, which is "(The lowest-order bit of a^b is in a) and not (b is a proper prefix of a).)
A simple test of the case "a is a proper prefix of b", given the fact that we have the the lowest-order bit of a^b in tmp, is tmp > a. That avoids the use of __builtin_clz [Note 1].
Also, you could write
tmp = tmp & (~tmp + 1);
as
tmp &= -tmp;
but I think that most C compilers will find that optimization on their own. [Note 2].
Applying those optimizations, the result would be (untested):
bool less_than(unsigned a, unsigned b) {
unsigned tmp = a ^ b;
tmp &= -tmp; //first difference isolated
return tmp > a || tmp & a;
}
Notes
This is worth doing because (1) even though __builtin_clz is builtin, it is not necessarily super-fast; and (2) it may not be present if you're compiling with a compiler other than gcc or clang.
-tmp is guaranteed to be the 2s-complement negative of tmp if tmp is an unsigned type, even if the underlying implementation is not 2s-complement. See §6.2.6.2/1 (the range of an unsigned type is 0..2N-1 for some integer N) and &6.3.1.3/2 (a negative value is converted to an unsigned integer type by repeatedly adding 2N until the value is in range.

Answer 2

Here's a listing calculating all combinations for 2-bit inputs:
#include <stdio.h>
bool less_than(unsigned a, unsigned b) {
unsigned tmp = a ^ b;
tmp = tmp & (~tmp + 1); //first difference isolated
return (tmp & a) && (__builtin_clz(b) < __builtin_clz(tmp));
}
#define BITPATTERN "%d%d%d"
#define BYTETOBITS(byte) \
(byte & 0x04 ? 1 : 0), \
(byte & 0x02 ? 1 : 0), \
(byte & 0x01 ? 1 : 0)
int main(int argc, char** argv) {
for ( int a = 0; a < 4; a ++ )
for ( int b = 0; b < 4; b ++)
printf("a: "BITPATTERN" b: "BITPATTERN": %d\n",
BYTETOBITS(a), BYTETOBITS(b), less_than(a,b)
);
}
And here's the output:
a: 000 b: 000: 0
a: 000 b: 001: 0
a: 000 b: 010: 0
a: 000 b: 011: 0
a: 001 b: 000: 0
a: 001 b: 001: 0
a: 001 b: 010: 1
a: 001 b: 011: 0
a: 010 b: 000: 0
a: 010 b: 001: 0
a: 010 b: 010: 0
a: 010 b: 011: 0
a: 011 b: 000: 0
a: 011 b: 001: 0
a: 011 b: 010: 1
a: 011 b: 011: 0
It doesn't seem to look correct..