Correct way to take absolute value of INT_MIN

Question

I want to perform some arithmetic in unsigned, and need to take absolute value of negative int, something like

do_some_arithmetic_in_unsigned_mode(int some_signed_value)
{
   unsigned int magnitude;
   int negative;
   if(some_signed_value<0) {
       magnitude = 0 - some_signed_value;
       negative = 1;
    } else {
       magnitude = some_signed_value;
       negative = 0;
    }
   ...snip...
}

But INT_MIN might be problematic, 0 - INT_MIN is UB if performed in signed arithmetic. What is a standard/robust/safe/efficient way to do this in C?

EDIT:

If we know we are in 2-complement, maybe implicit cast and explicit bit ops would be standard? if possible, I'd like to avoid this assumption.

do_some_arithmetic_in_unsigned_mode(int some_signed_value)
{
   unsigned int magnitude=some_signed_value;
   int negative=some_signed_value<0;
   if (negative) {
       magnitude = (~magnitude) + 1;
    }
   ...snip...
}

Answer 1

Conversion from signed to unsigned is well-defined: You get the corresponding representative modulo 2^N. Therefore, the following will give you the correct absolute value of n:

int n = /* ... */;

unsigned int abs_n = n < 0 ? UINT_MAX - ((unsigned int)(n)) + 1U
                           : (unsigned int)(n);

Update: As @aka.nice suggests, we can actually replace UINT_MAX + 1U by 0U:

unsigned int abs_n = n < 0 ? -((unsigned int)(n))
                           : +((unsigned int)(n));

Answer 2

In the negative case, take some_signed_value+1. Negate it (this is safe because it can't be INT_MIN). Convert to unsigned. Then add one;

Answer 3

You can always test for >= -INT_MAX, this is always well defined. The only case is interesting for you is if INT_MIN < -INT_MAX and that some_signed_value == INT_MIN. You'd have to test that case separately.

Answer 4

I want to perform some arithmetic in unsigned, and need to take absolute value of negative int, ...

To handle pedantic cases:

The |SOME_INT_MIN|¹ has some special cases:

1. Non-two's complement

Ones' complement and sign-magnitude are rarely seen these days.

SOME_INT_MIN == -SOME_INT_MAX and some_abs(some_int) is well defined. This is the easy case.

#if INT_MIN == -INT_MAX
some_abs(x);  // use matching abs, labs, llabs, imaxabs
#endif

2. SOME_INT_MAX == SOME_UINT_MAX, 2's complement

C allows the max of the signed and unsigned version of an integer type to be the same. This is rarely seen these days.

2 approaches:
1) use a wider integer type, if it exist.

#if -INTMAX_MAX <= SOME_INT_MIN
imaxabs((intmax_t)x)
#endif

2) Use wide(st) floating-point (FP) type.
Conversion to a wide FP will work for SOME_INT_MIN (2's complement) as that value is a -(power-of-2). For other large negatives, the cast may lose precision for a wide integer and not so wide long double. E.g. 64-bit long long and 64-bit long double.

fabsl(x);  // see restriction above.

3. SOME_INT_MAX < SOME_UINT_MAX

This is the common case well handle by @Kerrek SB's answer. The below also handles case 1.

x < 0 ? -((unsigned) x) : ((unsigned) x);

---

Higher Level Alternative

In cases when code is doing .... + abs(x), a well defined alternative is to subtract the negative absolute value: .... - nabs(x). Or as in abs(x) < 100, use nabs > -100.

// This is always well defined.
int nabs(int x) {
  return (x < 0) x : -x;
}

---

¹ SOME_INT implies int, long, long long or intmax_t.

Answer 5

 static unsigned absolute(int x)
 {
          if (INT_MIN == x) {
                  /* Avoid tricky arithmetic overflow possibilities */
                  return ((unsigned) -(INT_MIN + 1)) + 1U;
          } else if (x < 0) {
                  return -x;
          } else {
                  return x;
          }
 }