Add, subtract and compare compressed integers - c++

Question

I need to do substantial simple algebras on equisized arrays of small integers. The operations consist of only three kinds: (i) add arrays and (ii) subtract arrays element-wisely, and (iii) compare if all elements in one array are no less / greater than their counterparts in another.
To boost cache locality and computing speed, I cram the small integers of every array bit-by-bit into a certain number of 64-bit integers. The number of 64-bit integers for use is determined by numbers of bits assigned to array elements. Let a[j] denote an array element. My design of bits for a[j] consists of (i) bits that can hold the largest absolute value a[j] could hit during computation, (ii) a sign bit, and (iii) a bit on the sign bit's left. The leftmost bit holds the possible carry from the right and gets zeroed after addition or subtraction.
Below is a toy example of adding, subtracting and comparing two 64-bit integers, each of which includes five small integers: the first 10 bits, the next 5 bits, the next 10 bits, the next 13 bits, and the next 20 bits. The rest bits are useless and set to 0.
// leftmostBitMask =
// 0b0111111111011110111111111011111111111101111111111111111111000000
// ^ ^ ^ ^ ^
// leftmost
std::size_t add(std::size_t x, std::size_t y, std::size_t leftmostBitMask)
{
return (x + y) & leftmostBitMask;
}
std::size_t minus(std::size_t x, std::size_t y, std::size_t leftmostBitMask)
{
return (x - y + ((~leftmostBitMask) << 1)) & leftmostBitMask;
}
bool notAllGreaterEqual(std::size_t x, std::size_t y, std::size_t leftmostBitMask)
{
// return (minus(x, y, leftmostBitMask) & (leftmostBitMask >> 1)) == 0;
return (x - y) & ((~leftmostBitMask) >> 1);
}
My algorithms seem complex, especially the comparison function. Are there any faster solutions?
Thanks!
BTW, SIMD is not what I am describing. My question is one lower level of optimization than SIMD.
More background: the idea serves a quite complex search algorithm in multidimensional space. We observed large differences between magnitudes of values in different dimensions. For instance, during computing an important 6-dimensional test case, one dimension could reach 50000 in absolute value yet all the others fall well below 1000. Without integer compression, each object requires a 32-bit array of size 6, while integer compression reduces the dimensionality to 1 (64-bit integer). Such reduction prompts me to think about cramming integers..

Answer 1

After careful thought and comprehensive simulations, algorithms listed in the question turn out largely over-engineered. The leftmost bit for receiving carry is unnecessary. The code below works:
// signBitMask =
// 0b1000000000100001000000000100000000000010000000000000000000000000
// ^ ^ ^ ^ ^
// sign bit
std::size_t add(std::size_t x, std::size_t y)
{
return x + y;
}
std::size_t subtract(std::size_t x, std::size_t y)
{
return x - y;
}
bool notAllGreaterEqual(std::size_t x, std::size_t y, std::size_t signBitMask)
{
return (x - y) & signBitMask != 0;
}
The key factor here is that every comparison made on two arrays is AND-based. We require notAllGreaterEqual() returns true as long as one elemental integer in x is below its counterpart in y. At first glance, the solution above could hardly be true: What happens when one negative elemental integer is added to a positive counterpart and the result stays positive? There must be a carry over the sign bit. In this case isn't the successive elemental integer contaminated? The answer is yes, but it does not matter. Collectively notAllGreaterEqual() would still fully serve its purpose. Instead of thinking in bits, one can easily prove notAllGreaterEqual() correct with elementary algebra. Problems could come only if we want to recover the integer array from those 64-bit buffers.
Creating the 64-bit buffer consists of (i) casting integers to std::size_t, (ii) shift the integer by pre-computed bits, and (iii) adding shifted integers. If an integer is negative being shifted to the right, 1 must be padded on its left.