All combinations of a binary number where only certain bits can change - c++

Question

I was wondering if there is an algorithm to generate all the possible combinations of a binary number where only bits in certain positions can change, for example, we have the following bitstream, but only bits marked in the position x can change(this example has 8 places that can change to make different combinations, a total of 2^8):
x00x0000x000000x00x00x000x000x
one solution is to look at the number as an 8-bit number in the first place and just calculate all the combinations for xxxxxxxx.
However, this doesn't quite satisfy my needs, as I want to use the number in a Linear shift register (LFSR) later on, currently, I'm looking for an answer which utilizes std::bitset.

Answer 1

So, there is alsready an answer. But just dumped code, without any explanation. Not good. Anyway...
I would like to add an answer with a different approach, and explain the steps.
Basically, if you want to have all combinations of a binary number, then you could simply "count" or "increment by one". Example for a 3 bit value. This would be decimal 0, 1, 2, 3, 4, 5, 6, 7 and binary 000, 001, 010, 011, 100, 101, 110, 111. You see that it is simple counting.
If we think far back to school days, where we learned boolean algebra and a little bit of automata theory, then we rember how this counting operation is done on low level. We always flip the least significant bit, and, if there is a transition from 1 to 0, then we basically had an overflow and must also flip the next bit. That's the principle of a binary adder. We want to add always 1 in our example. So, add 1 to 0, result is 1, then no overflow. But add 1 to 1, result is 0, then we we have an overlow and must add 1 to the next bit. This will effectively flip the next bit, and so on and so on.
The advantage of this method is, that we do not always need to operate on all bits. So, the complexity is not O(n), but rather O(log n).
Additional advantage: It fits very good to your request for using a std::bitset.
3rd advantage, and maybe not that obvious: You can decouple the task of calculating the next combination from the rest of your program. No need to integrate your real-task-code in such a function. That is also the reason, why std::next_permutation is implemented like this.
And, the algorithms desribed above works for all values, no sorting or something necessary.
That part was for the algorithm you have asked for.
Next part is for your request that only certain bits can change. Of course, we need to specify these bits. And because your are working with std::bitset masking is no solution here. The better approach is to use indices. Meaning, give the bit positions of the bits that are allowed to be changed.
And then we can use the above described algorithm, with just one additional indirection. So, we do not use bits[pos], but bits[index[pos]].
The indices can easily be stored in a std::vector using an initializer list. We can also derive the indices-vector from a string or whatever. I used a std::string as example.
All the above will result in some short / compact code, with just a few lines and is easy to understand. I also added some driver code that makes use of this function.
Please see:
#include <iostream>
#include <vector>
#include <string>
#include <bitset>
#include <algorithm>
#include <cassert>
constexpr size_t BitSetSize = 32U;
void nextCombination(std::bitset<BitSetSize>& bits, const std::vector<size_t>& indices) {
for (size_t i{}; i < indices.size(); ++i) {
// Get the current index, and check, if it is valid
if (const size_t pos = indices[i]; pos < BitSetSize) {
// Flip bit at lowest positions
bits[pos].flip();
// If there is no transition of the just flipped bit, then stop
// If there is a transition from high to low, then we need to flip the next bit
if (bits.test(pos))
break;
}
}
}
// Some driver code
int main() {
// Use any kind of mechanism to indicate which index should be changed or not
std::string mask{ "x00x0000x000000x00x00x000x000x" };
// Here, we will store the indices
std::vector<size_t> index{};
// Populated the indices vector from the string
std::for_each(mask.crbegin(), mask.crend(), [&, i = 0U](const char c) mutable {if ('x' == c) index.push_back(i); ++i; });
// The bitset, for which we want to calculate the combinations
std::bitset<BitSetSize> bits(0);
// Play around
for (size_t combination{}; combination < (1 << (index.size())); ++combination) {
// This is the do something
std::cout << bits.to_string() << '\n';
// calculate the next permutation
nextCombination(bits, index);
}
return 0;
}
This software has been compiled wth MSVC 19 Community Edition using C++17
If you should have additional questions or need more clarifications, then I am happy to answer

Answer 2

The integers that satisfy the pattern can be enumerated by iterating with a "masked increment", which increments the variable bits but leaves the fixed bits the same. For convenience I will assume that the "fixed bits" are zero, but it they weren't it would still work with minor changes. mask is 1 for the fixed bits and 0 for the variable bits.
uint32_t x = 0;
do {
// use x
...
// masked increment
x = (x | mask) + 1 & ~mask;
} while (x != 0);
x | mask sets the fixed bits, so that the carry will "go through" the fixed bits. +1 increments the variable bits. &~mask cleans up the extra bits that were set, turning the fixed bits back into zeroes.
std::bitset cannot be incremented so it is difficult to use directly, but integers can be converted to std::bitset if necessary.

Answer 3

Something like this
// sample indexes
static const int indexes[8] = { 0, 4, 8, 11, 13, 16, 22, 25 };
std::bitset<32> clear_bit_n(std::bitset<32> number, int n)
{
return number.reset(indexes[n]);
}
std::bitset<32> set_bit_n(std::bitset<32> number, int n)
{
return number.set(indexes[n]);
}
void all_combinations(std::bitset<32> number, int n)
{
if (n == 8)
{
// do something with number
}
else
{
all_combinations(clear_bit_n(number, n), n + 1);
all_combinations(set_bit_n(number, n), n + 1);
}
}
all_combinations(std::bitset<32>(), 0);