Transforming 'X' to 1 or 0, if its > 0 or == 0

Question

Currently, my algorithm is someValue + x. I am trying to figure out how I can transform x to 1 if its greater than 0, or to 0 if its equal to 0.

I don't want to use an if-else to produce this, but rather just transform x in my algorithm by itself.

For example: If someValue = 20, x = 4. It would produce 20 + 1 = 21. But if x = 0. It would just produce 20.

Thanks.

Answer 1

Use

someValue + (x>0? 1: 0);

But don't worry about writing a little to get what you need. It's important to write understandable code :)

Answer 2

return x > 0 ? someValue + 1 : someValue;

but it ends up with a conditional statement anyway. You just dont do it explicitly.

Answer 3

Assuming x will always be >=0 you can do:

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

Answer 4

Its simple operation , you can just use this

 n + (x>0? 1 : 0);

Answer 5

Why you want to do this without an if statement may be questionable but (as of Java 5) Integer has a signum method which will return -1, 0 or 1 depending on the integer value:

int newVal = someValue + Integer.signum (x);

Assuming your input value will be always zero or more, this will do what you want. But it's unlikely to be any faster than an if statement like:

int newVal = someValue;
if (x > 0) newVal++;

nor any more succinct than the ternary version:

int newVal = (x > 0) ? someValue + 1 : someValue;

I just though I'd include it as an option in case you want neither the if nor ternary variant.

Answer 6

Just to throw something else in the mix that could work (but not necessarily a sensible way to go about it)...

int value = 0;
try {
    value = x / x;
}
catch (Exception e) { }
return someValue + value;

Answer 7

For readability, define an extra method for the conditional part:

 public static int absoluteSignum(int x) {
   return x == 0 ? 0 : 1;
 }

and use it in you code:

 int result = someValue + absluteSignum(x);

Answer 8

Using someValue+(x>0)?1:0 should at best be equivalent to:

if(x>0) someValue++;

when compiled, so the branching is not avoided. If you for some reason absolutely have to avoid branching you can use:

x=-((~(x-1)|x)>>31);

As a bonus, for C language this would be:

x=(~(x-1)|x)>>(sizeof(x)*CHAR_BIT-1)

The result is 0 if x==0, 1 otherwise. It's pure bitwise ops, no branches and total 5 integer operations. For similar tricks (although this one isn't listed, I just modified another algorithm there) you can see this bit twiddling hacks page: http://graphics.stanford.edu/~seander/bithacks.html

Answer 9

x=-((~(x-1)|x)>>31);

in my opinion,it's the best answer.But first you should store the X into a 32-bits data type. such as int (x86).
No branches,No judgment

Answer 10

If x is non-negative integer:

return someValue + (x + 2)%(x + 1);