Next largest integer with some middle bits matching a pattern? - c++

Question

My input is:
a bit mask mask of width n and some offset k >=0
a bit pattern pattern with 1s in some (but not necessarily all) the positions where the bit mask has 1s.
an integer val
I want to find the next largest integer result such that:
result > val
result & mask == pattern
For example, suppose mask = 0xFF00 and pattern = 0x0100. Then we expect the following result:
NextLargest(mask, pattern, 0x00000) => 0x00100
NextLargest(mask, pattern, 0x000FF) => 0x00100
NextLargest(mask, pattern, 0x010FE) => 0x001FF
NextLargest(mask, pattern, 0x010FF) => 0x10100
Another example -- say mask = 0xF and pattern = 0xF. Then we expect:
NextLargest(mask, pattern, 0x20) => 0x2F.
I've tried something like "strip out the bits that mask cares about, increment it, OR back in pattern and return" but I keep hitting edge cases. The problem is something like a generalization of finding the next largest multiple of some integer.
Here's my attempt so far (runnable link: https://ideone.com/AhXG5M):
#include <iostream>
using namespace std;
using uint32 = unsigned long;
uint32 NextLargest(int width, int offset, uint32 mask, uint32 pattern, uint32 val) {
unsigned long long ret = (val + 1) & ~mask;
if ((ret & ((1 << (offset + 1)) - 1)) == 0) {
// "carry" across the mask
ret += 1 << (offset + width);
}
return ret | pattern;
}
int main() {
// your code goes here
int width = 12;
int offset = 4;
uint32 significant_bits = (1 << (width + 1) - 1) << offset;
uint32 wanted_bits = 0xFFF << offset;
cout << hex;
// want 0xFFF1 -- correct
cout << NextLargest(width, offset, significant_bits, wanted_bits, 0) << endl;
// want 0xFFF2 -- correct
cout << NextLargest(width, offset, significant_bits, wanted_bits, 1) << endl;
// want 0x1FFFF0 -- incorrect, get 0xFFF0
cout << NextLargest(width, offset, significant_bits, wanted_bits, 0xF) << endl;
return 0;
}

Answer 1

I didn't test this, but the following algorithm should work (pseudocode):
let mask, pattern, and val be inputs
let fls be function that finds last bit set in word
let ffs be function that finds first bit set in a word
let applied be (val & ~mask) | pattern
if applied is greater than val then
return applied
let low_order_mask be (1 << ffs(mask)) - 1
if applied == val then
let flipped_low be (~value & low_order_mask)
if not flipped_low then
return applied + 1 // no need to carry
// need to carry
let set_low_zero be applied & ~low_order_mask
let carry be 1 << (fls(mask) + 1)
return set_low_zero + carry
fls and ffs are provided by POSIX, but other systems might not do so. There are answers on SO for how to implement these if you need to.

Answer 2

Think of the value broken into 3.
The bits above the mask, in the mask and below the mask.
H(value), M(value), L(value).
We know M(result)==pattern.
We have three candidates.
C1 is H(value)+pattern+0.
C2 is H(value)+pattern+L(value)+1
C3 is H(value)+pattern+X
X==(mask<<1)&~mask. That is the lowest bit above the mask.
If pattern>M(value) we can use C1.
Reducing the high-bits will get a number <value and setting any low bits will increase the number.
If pattern==M(value) then we can try C2 which is actually value+1.
That fails if adding one overflows to the pattern bits.
That means all the low bits are set and the next lowest place to add is the first bit above the mask.
unsigned next_masked(unsigned mask,unsigned pattern,unsigned value){
unsigned reduced_pattern=(mask&pattern);//May not be required...
unsigned over_add=(mask<<1)&~mask;
unsigned upper_mask=~(over_add-1);
unsigned cand=(value&upper_mask)|reduced_pattern;
if(cand>value){
return cand;
}
if((value&mask)==reduced_pattern){
unsigned scand=value+1;
if((scand&mask)==reduced_pattern){
return scand;
}
}
return cand + over_add;
}
Here it is again with some unit tests:
#include <iostream>
unsigned next_masked(unsigned mask,unsigned pattern,unsigned value){
unsigned reduced_pattern=(mask&pattern);//May not be required...
unsigned over_add=(mask<<1)&~mask;
unsigned upper_mask=~(over_add-1);
unsigned cand=(value&upper_mask)|reduced_pattern;
if(cand>value){
return cand;
}
if((value&mask)==reduced_pattern){
unsigned scand=value+1;
if((scand&mask)==reduced_pattern){
return scand;
}
}
return cand + over_add;
}
bool invariant_next_masked(unsigned mask,unsigned pattern,unsigned value,unsigned result){
if((result&mask)!=(pattern&mask)){
return false;
}
if(result<=value){
return false;
}
for(unsigned test=result-1;test>value;--test){
if((test&mask)==(pattern&mask)){
return false;
}
}
return true;
}
int check_next_masked(unsigned mask,unsigned pattern,unsigned value,unsigned expect){
unsigned result=next_masked(mask,pattern,value);
if(result!=expect){
std::cout << std::hex << mask << ' ' << std::hex << pattern << ' ' << std::hex <<value << "==" << std::hex <<result << "!=" << std::hex <<expect <<'\n';
return 1;
}
if(!invariant_next_masked(mask,pattern,value,result)){
return 1;
}
return 0;
}
int main() {
int errors=0;
errors+=check_next_masked(0xFF00,0x0100,0x0000,0x00100);
errors+=check_next_masked(0xFF00,0x0100,0x00FF,0x00100);
errors+=check_next_masked(0xFF00,0x0100,0x10FE,0x10100);
errors+=check_next_masked(0xFF00,0x0100,0x1067,0x10100);
errors+=check_next_masked(0xFF00,0x0100,0x10123,0x10124);
errors+=check_next_masked(0xFF00,0x0100,0x110FF,0x20100);
errors+=check_next_masked(0xFF00,0x0100,0x102FF,0x20100);
errors+=check_next_masked(0xFF00,0x0100,0x101FF,0x20100);
errors+=check_next_masked(0x000F,0x0007,0x10123,0x10127);
errors+=check_next_masked(0x000F,0x0007,0x10128,0x10137);
errors+=check_next_masked(0x0FF0,0x0230,0x10128,0x10230);
errors+=check_next_masked(0x0FFF0,0x01230,0x01231,0x01232);
errors+=check_next_masked(0x0FFF0,0x01230,0x41237,0x41238);
errors+=check_next_masked(0x0FFF0,0x01230,0x4123F,0x51230);
if(errors>0){
std::cout << "Errors "<< errors << '\n';
return 1;
}
std::cout << "Success\n";
return 0;
}

Answer 3

is the problem to calculate the LARGEST or SMALLEST next value?? the largest value seems odd to be. if the requirement is to calculate the smallest value, I think this code should work: (tested on gcc 7.1, assuming a 64 bit target, sizeof(void *) == sizeof(size_t) == sizeof(uint64_t))
size_t next_smallest_value (size_t mask, size_t pattern, size_t x) {
assert(pattern & mask == pattern);
// only change bits within mask range to meet the requirement
auto y = x & ~mask | pattern;
if (y > x) {
// if the operation increased the value
// mask off all the lower bits
auto lsb_mask = __builtin_ctzll(mask);
return y & ~ones(lsb_mask);
} else {
// otherwise, the operation decreased or didn't change the value
// need to increase the fraction higher than the mask
auto msb_mask = 63 - __builtin_clzll(mask);
// higher part cannot be empty if the masked part decrease
assert(msb_mask < 63);
auto higher = ((y >> msb_mask) + 1) << msb_mask;
// also higher part cannot overflow
assert(higher != 0);
return y & mask | higher;
}
}
the idea is very simple: divide the bits into 3 parts: higher part, masked part, lower part. the masked part can be derived directly from and is determined by the mask and pattern, it cannot be other values.
after calculating the masked bits, if the value increase, just mask off all bits in the lower part. otherwise, increase the higher part by 1 (and also mask off all the lower bits).
the above code doesn't deal with ill-formed input, it will trigger the assertions, but the checks are not exhausted.

Answer 4

Here is two functions for this little bit confusing question
First function gives the largest next integer that fulfills the requirements for the result.
Second one gives SMALLEST next value.
1: Get the LARGEST integer which satisfies result & mask == pattern and result > val:
unsigned NextLargest (unsigned mask, unsigned pattern, unsigned val) {
// zero "mask" bits and set "pattern" bits in largest (unsigned) int
unsigned const x = ~mask | pattern;
// if result is not greater than val, we can't satisfy requirements
if (x <= val) {
... report error, return error code or throw something
}
return x;
}
Obviously this just returns highest (unsigned) integer value that meets the requirements result & mask == pattern and result > val. The if-clause checks if result will not be greater than val, and the function will fail.
2: Get the SMALLEST next value after val that meets the requirements:
unsigned NextSmallest (unsigned mask, unsigned pattern, unsigned val) {
unsigned const x = (val + mask + 1) & ~mask | pattern;
if (x <= val) {
... increment wrapped, can't give greater value
}
return x;
}
edit: Changed (val|mask) to val+mask because the result must be still greater than val.
This function calculates val + 1 and carrying overflowing bits over mask'd bits.
Here are few examples what the function does, if mask = 0x0ff00 and pattern = 0x00500:
val +mask +1 &~mask |pattern == result
0x00000 0x0ff00 0x0ff01 0x00001 0x00501
0x00001 0x0ff01 0x0ff02 0x00002 0x00502
0x000fe 0x0fffe 0x0ffff 0x000ff 0x005ff
0x000ff 0x0ffff 0x10000 0x10000 0x10500
0x00100 0x10000 0x10001 0x10001 0x10501
0x0f000 0x1ef00 0x1ef01 0x10001 0x10501
0x0ff00 0x1fe00 0x1fe01 0x10001 0x10501
0x0ffff 0x1feff 0x1ff00 0x10000 0x10500
0x10000 0x1ff00 0x1ff01 0x10001 0x10501
0x10001 0x1ff01 0x1ff02 0x10002 0x10502
0x100ff 0x1ffff 0x20000 0x20000 0x20500
After long editing and rewriting I still can't give good enough answer for the question. Its examples has weird results. I still leave this here, if someone finds these functions or parts of them useful. Also I did not actually tested the functions on the computer.