strcmp like interface for comparing numbers in C

Question

I want to make strcmp-like interface for comparing numbers, e.g., ncmp(x, y) that returns an int > 0 if x > y, 0 if x = y, < 0 if x < y in C (not C++).

Although I necessarily do not want to constrain the types, my main interest is to compare signed long ints and doubles. The 'interface' can be a macro as in tgmath.h, or it can be a (set of) functions. I want all pairs of signed long int and double to work; (signed long int, double) and (double, double) should work for instance.

What I'm currently using is the following macro:

#define ncmp(x, y) ((x) > (y)) - ((x) < (y))

Does this naive macro have any pitfalls? Is there a better, robust solution to compare numbers?

Any help would be greatly appreciated!

Answer 1

I want all pairs of signed long int and double to work;

Since C11, code can use _Generic to steer function selection based on type.

int cmp_long(long x, long y) {
  return (x > y) - (x < y);
}  

int cmp_double(double x, double y) {
  return (x > y) - (x < y);
}  

#define cmp(X, Y) _Generic((X) - (Y), \
    long: cmp_long((X),(Y)), \
    double: cmp_double((X),(Y)) \
)

This approach does not well detect cases where X, Y are of different types as the (X) - (Y) uses the common type between them @Ian Abbott. Yet it is a start.

int main(void) {
  printf("%d\n", cmp(1L, 2L));
  printf("%d\n", cmp(3.0, 4.0));
}

---

A more complex 2-stage _Generic could be made to distinguish long, double and double, long. I'll leave that part to OP.

The compare function would be like the one below. The tricky part is to not lose precision of long (it might be 64-bit) when comparing to double.

// TBD: handling of NANs
#define DBL_LONG_MAX_P1 ((LONG_MAX/2 + 1)*2.0)
int cmp_long_double(long x, double y) {
  // These 2 compares are expected to be exact - no rounding
  if (y >= DBL_LONG_MAX_P1) return -1;
  if (y < (double)LONG_MIN) return 1;

  // (long) y is now in range of `long`.  (Aside from NANs)
  long y_long = (long) y; // Lose the fraction
  if (y_long > x) return -1;
  if (y_long < x) return 1;
 
  // Still equal, so look at fraction
  double whole;
  double fraction = modf(y, &whole);
  if (fraction > 0.0) return -1;
  if (fraction < 0.0) return 1;
  return 0;
}

Simplifications may exist.

---

When double encodes all long exactly or when long double exists and encodes all long exactly, it's easiest to convert both the long and double to the common type and compare.

Answer 2

For this macro:

#define ncmp(x, y) ((x) > (y)) - ((x) < (y))

the main problems are:

1. It requires an additional set of parentheses in the expansion to form a primary expression.There are not enough parentheses in the expansion to turn it into a primary expression. It should be:

   #define ncmp(x, y) (((x) > (y)) - ((x) < (y)))
   

2. It evaluates (x) and (y) twice, which could be a problem if the evaluation has side effects.

To avoid the problem of multiple evaluation, the macro expansion could use a generic selection expression to call a different function for each type being compared.

Note 1: generic selection was added in the 2011 version of the C standard (C11).)

Here is an example macro using generic selection. It may need to be extended to support additional types:

#define ncmp(x, y) _Generic((x) < (y), \
    int: ncmp_si,                      \
    unsigned: ncmp_ui,                 \
    long: ncmp_sli,                    \
    unsigned long: ncmp_uli,           \
    long long: ncmp_slli,              \
    unsigned long long: ncmp_ulli,     \
    float: ncmp_f,                     \
    double: ncmp_d,                    \
    long double: ncmp_ld               \
    )((x), (y))

Note 2: The controlling expression of the generic selection ((x) < (y)) is not evaluated, but its type is used to select a corresponding generic association expression (if any).

Note 3: The choice of < in the controlling expression does not matter much, but it does at least check that (x) and (y) have an ordered relationship. For arithmetic operands, the type of the controlling expression is the result of the usual arithmetic conversions.

Note 4: Due to the usual arithmetic conversions done to the operands of < in the controlling expression, there is no need to add cases for integer types below the rank of int.

Note 5: It is possible to add a default: generic association. For example, it could be defined to fall back to using the less safe multiple evaluation method as follows:

#define ncmp(x, y) _Generic((x) < (y),         \
    int: ncmp_si((x), (y)),                    \
    unsigned: ncmp_ui((x), (y)),               \
    long: ncmp_sli((x), (y)),                  \
    unsigned long: ncmp_uli((x), (y)),         \
    long long: ncmp_slli((x), (y)),            \
    unsigned long long: ncmp_ulli((x), (y)),   \
    float: ncmp_f((x), (y)),                   \
    double: ncmp_d((x), (y)),                  \
    long double: ncmp_ld((x), (y)),            \
    default: ((x) > (y)) - ((x) < (y))         \
    )

but I chose to leave it up to the programmer to add the missing cases.

It is necessary to define the functions used by each of the generic associations above. To save a bit of typing, a helper macro could be defined to define them:

#define MK_NCMP_(suf, T) \
static inline int ncmp_##suf(T x, T y) { return (x > y) - (x < y); }

MK_NCMP_(si, int)
MK_NCMP_(ui, unsigned)
MK_NCMP_(sli, long)
MK_NCMP_(uli, unsigned long)
MK_NCMP_(slli, long long)
MK_NCMP_(ulli, unsigned long long)
MK_NCMP_(f, float)
MK_NCMP_(d, double)
MK_NCMP_(ld, long double)