a bitwise expression that returns 1 when mask is all zeros and x when mask is all ones

Let's say we have a mask variable that can either be 0 (all zoers) or -1 (all ones).

I have another variable x which is let's say 42.

What (possibly) is the bitwise expression that results in:

• 1 when mask == 0
• x when mask == -1

what I'm trying to do is explore ways to eliminate the following if statement

unsigned x = 3;
unsigned some_number = 42;

// ~~~

if (some_number % x == 0)
{
    some_number /= x;
}

Regarding the type of variables in the particular problem that I'm working on (look below), all of the numbers are unsigned integers for example unsigned.

EDIT 2 (MISTAKE): I made a mistake and forgot that mask is either 0 (all zeros) or, -1 (all ones) which I previously said 1 (only whose least significant bit is one). Please accept my apologies as I wasted your precious time.

EDIT 1:

Overall the point is not to use if-else constructs (including the conditional operator (?:)). Instead I'm looking for bit manipulations similar to those which is used in branchless practices. This question isn't whether it is going to be more performant or not in this case, or whether the answer could be considered a good practice or not. It's just to explore the world of bit manipulation.

Here is my try

// Check whether some_number is divisible by x
unsigned mask = ((some_number % x) - 1) >> 31;
unsigned deonm = // ??
some_number =/ denom

I'm using this to answer project Euler's third question and here's the code

size_t largest_prime_factor(size_t number)
{
    if (number < 2) return 0;
    if (number == 2) return 2;
    while ((number & 1) == 0)
    {
        number >>= 1;
    }
    size_t lpf = 2;
    size_t i = 3;
    size_t max_iter = sqrt(number);
    while (i < max_iter)
    {
        size_t mask = ((number % i) - 1) >> 31;
        lpf = (i & mask) | (lpf & ~mask);
        number /= X; // mask = 0 => X=1; mask = 1 => X=i
        i += 2;
    }
    return lpf;
}

NOTE: Please, if possible, suggest a better title.

In your particular case, you may not want to avoid the branch: divisions can be expensive, while a correctly predicted branch can be cheap. If the branch is not taken frequently (e.g. brute-force factoring), the result will be faster than trying to always divide by a computed divisor.

If you just want a branchless solution:

(x - 1) * mask + 1

works, but won't necessarily be faster due to the multiply. Alternatively, if mask is unsigned, you could use ((x - 1) & -mask) + 1 which is probably slightly faster.

You can also parallelize this a bit to reduce the dependency chain: (x & -mask) + !mask.

For the case where mask can be either 0 or 1

1 - mask  // or !mask => 1 when mask is 0
+         // or |
x * mask  //          => x when mask is 1

I'm going to assume the mask (which I'll call m), x, and the result (which I'll call r) are unsigned integer types of the same size. I shall call that type TYPE.

For most of the bits, it's easy: r_i = x_i & m_i

The least significant bit (r₀) is different, though. The following shows the desired value for r₀ based on the values of m₀ and x₀:

So we get r₀ = ~m₀ | x₀

Now, we just need to combine them.

We want to apply the first rule to all the bits but the last. This can be done by using a mask that lets through all bits but the last (... & ( ~(TYPE)1 )).

We want to apply the second rule for just the last bit. This can be done by using a mask that lets through only the last bit (... & 1).

All together:

r = ( x & m & ( ~(TYPE)1 ) ) | ( ( ~m | x ) & 1 );

And now we have a solution with just bit operations (and a cast which can maybe be avoided by using the correct numeric literal suffix).

With xor, you can get a shorter solution:

 ((x ^ 1) & mask) ^ 1

A bit and operation does almost produce the desired output:

• if your unsigned mask is all ones -1U then mask & x == x
• if your unsigned mask is all zeros 0U then mask & x == 0

We see that we can complement with another operation:

• if your unsigned mask is all ones -1U then mask + 1 == 0
• if your unsigned mask is all zeros 0U then mask + 1 == 1

By summing up the two expressions mask + 1 + (mask & x) you get what you want:

• 1 when mask == 0U
• xwhen mask == -1U