Is there a way to convert an integer to 1 if it is >= 1 without using any relational operator?

Is there a way to convert an integer to 1 if it is >= 1 without using any relational operator?

For unsigned integers you can simply do:

unsigned int i = 42; // ... or any other value > 0.
unsigned int j = !!i; // j is 1 here.

i = 0;
j = !!i; // j is 0 here.

Update:

For signed integers you can do

int i = ...
int j = !!(i * !((1 << ((CHAR_BITS * sizeof i) - 1)) & i)); 

The above line results in

• 0 for any i < 1
• 1 for any i >= 1

Assuming you use two's complement you can do this. (The other answer to use !!x may or may not be what you are looking for, depending on the computer's instruction set and why you want to avoid relational operators)

int x = 42; // or any integer

int test = x-1;
if(test & 1 << (CHAR_BIT * sizeof(int) -1))
{
   // integer negative or zero
}
else
{
   // integer positive
}

I'm aware that this answer explicitly contradicts your question, but there are SIMD comparisons on all common SIMD architectures (at least all I know).

For SSE2 and int32 parameters there is pcmpgtd (intrinsic: _mm_cmpgt_epi32), assuming you have 4 integers in __m128i x, you can write

__m128i result = _mm_cmpgt_epi32(x, _mm_setzero_si128())

To get -1 (i.e. 0xFFFFFFFF) for every x>0 (i.e. x>=1) and 0 otherwise. If you need 1 instead of -1 just write

__m128i y =  _mm_sub_epi32(_mm_setzero_si128(), result);

I'm not familiar with C or using SIMD instructions, but if x is a positive integer,can't you just do this?

y = (x == 0) ? 1 : 0;

Use this: y= 1/(1+e^(-10000*(x-0.995)))

This will give y = 0 for x <= 0.99 and y=1 for x>= 1

I don't know what SIMD is and there could very well be a better way to do this. But I figured, if you don't want to use a condition you can use a sigmoid function that returns a 0 or a 1 according to your criteria. This function would be your some_operation(x) .Note that this function will only work for numbers with 2 decimals. That is, an input of 0.99 will return 0 but an input of 0.999 will return 1. Make sure you round your number down to the nearest 2-decimal number before doing the calculation.

I will go through step by step of my thought process below if anyone is interested:

If you want to use a function, and not a logical condition it would have to be continuous which by definition would mean that som of the values would not fit the criteria. But if those values were within a very narrow range, and your steps between numbers were bigger than that narrow range it would work.

So you could use a sigmoid function. (input it into wolfram alpha so see each change)

  y =  1/(1+e^(-x))   

And shift it one step to the right so it's centered around 1 instead of zero.

  y = 1/(1+e^(-(x-1)))

Then you can increase the slope of the function by increasing the weight.

  y= 1/(1+e^(-10000*(x-1))) 

Now the slope is really, really steep. But we still get y = 0.5 if we input x=1. So we need to shift the sigmoid a bit to the left.

y= 1/(1+e^(-10000*(x-0.995))) 

Now we will get y= 0 if x <= 0.99 and y=1 if x >= 1. If you want to use a finer resolution you would have to adjust the weight (10000 in this case) and the center point (0.995 in this case). I just checked the calculation in wolfram alpha and iterated what works. You can use a weight as low as 4000 if you are using only 2 decimals.

I'm sure there is a better way to do this, but this is how I would solve it.