Emulating signed integers using unsigned integers in C

As already suggested by Eric Postpischil in the comments above, this is surely simpler and more efficient than the book version (or any of the other answers posted so far, AFAICT):

bool is_signed_less(unsigned a, unsigned b) {
   unsigned const int_min = UINT_MAX / 2 + 1; /* 0x80000000 on 32-bit platforms */
   return (a - int_min) < (b - int_min); 
}

This code simply subtracts an offset from both of the inputs, so that the number representing the lowest possible signed integer value (int_min) is mapped to the lowest possible unsigned integer (0), and then does an unsigned comparison.

In particular, the subtraction maps the most negative signed integer (int_min) to 0, the second most negative signed integer (int_min + 1) to 1, the third most negative (int_min + 2) to 2, and so on. Meanwhile, non-negative signed integers (whose bit patterns correspond to unsigned integers less than int_min) will cause the subtraction to wrap around, yielding values that are higher than those corresponding to any negative input.

Note that there are several possible (and equivalent) variations of this code. For example, a curious numeric quirk of how fixed-width binary arithmetic works means that int_min is the unique unsigned integer for which x + int_min, x - int_min and x ^ int_min are all equal (for any x) — all of these operations just flip the most significant bit of x. Thus, in the code above, the - operators can be replaced by either + or ^ without changing the behavior of the code in any way!

(There could theoretically be a small performance difference, if some of these operations happened to run faster or pipeline better on your CPU, and if your compiler wasn't smart enough to optimize them all into the same assembly code. If you're worried that might be the case, benchmark them all and find out. Most likely they'll all be equally fast, though. Also, if you really want to obfuscate the code and confuse readers, try mixing and matching the operators into something like return (a ^ int_min) < (int_min + b). :P)

Yes, it's an error. One way of resolving it is this:

bool is_signed_less(unsigned a, unsigned b) {
    bool negativeA = is_negative(a);
    bool negativeB = is_negative(b);
    return (
        (
            negativeA != negativeB ?
            negativeA :
            a < b
        )
    );
}

First I computed negativeA and negativeB, respectively to avoid computing them again and again. Then, I checked if their sign differs.

Because if the sign of a and b differs and a is negative, then a < b.

Otherwise, if the sign of a and b is different and a is positive, then a > b.

In the other case, when their sign is the same, we simply compare them.

Yes, this is an error for the reason you specified.

In the case the signs are the same, using a < b works as normal. If they differ, then we need to use a > b instead as all "negative" values are greater than all positive values.

bool is_signed_less(unsigned a, unsigned b) {
   if (is_negative(b) != is_negative(a)) return b < a;
   else return a < b;
}

Indeed Jens seems to have made a mistake...

Here is a simpler and hopefully correct version of this function:

bool is_signed_less(unsigned a, unsigned b) {
   const unsigned sign_bit = ~(UINT_MAX >> 1);
   return (a ^ sign_bit) < (b ^ sign_bit); 
}

Indeed, this is a bug in the last edition of Modern C. I don't remember exactly when and how, but a correction has already made it in the C23 edition, which is to appear soon:

bool is_negative (unsigned a) {
    constexpr unsigned int_max = UINT_MAX/2;
    return a > int_max ;
}
bool is_signed_less (unsigned a, unsigned b) {
    if (is_negative (a) != is_negative (b)) return a > b ;
    else return a < b ;
}

I hope this is now correct.

Or just use the second-most obvious way:

bool is_signed_less(unsigned a, unsigned b) {
  return is_negative(a-b);
}