### 5.6 Comparison Functions

Function: `int` mpfr_cmp `(mpfr_t op1, mpfr_t op2)` ¶
Function: `int` mpfr_cmp_ui `(mpfr_t op1, unsigned long int op2)` ¶
Function: `int` mpfr_cmp_si `(mpfr_t op1, long int op2)` ¶
Function: `int` mpfr_cmp_d `(mpfr_t op1, double op2)` ¶
Function: `int` mpfr_cmp_ld `(mpfr_t op1, long double op2)` ¶
Function: `int` mpfr_cmp_z `(mpfr_t op1, mpz_t op2)` ¶
Function: `int` mpfr_cmp_q `(mpfr_t op1, mpq_t op2)` ¶
Function: `int` mpfr_cmp_f `(mpfr_t op1, mpf_t op2)` ¶

  Compare op1 and op2. Return a positive value if op1 > op2, zero if op1 = op2, and a negative value if op1 < op2. Both op1 and op2 are considered to their full own precision, which may differ. If one of the operands is NaN, set the erange flag and return zero.

  Note: These functions may be useful to distinguish the three possible cases. If you need to distinguish two cases only, it is recommended to use the predicate functions (e.g., `mpfr_equal_p` for the equality) described below; they behave like the IEEE 754 comparisons, in particular when one or both arguments are NaN. But only floating-point numbers can be compared (you may need to do a conversion first).

Function: `int` mpfr_cmp_ui_2exp `(mpfr_t op1, unsigned long int op2, mpfr_exp_t e)` ¶
Function: `int` mpfr_cmp_si_2exp `(mpfr_t op1, long int op2, mpfr_exp_t e)` ¶

  Compare op1 and op2 multiplied by two to the power e. Similar as above.

Function: `int` mpfr_cmpabs `(mpfr_t op1, mpfr_t op2)` ¶
Function: `int` mpfr_cmpabs_ui `(mpfr_t op1, unsigned long int op2)` ¶

  Compare |op1| and |op2|. Return a positive value if |op1| > |op2|, zero if |op1| = |op2|, and a negative value if |op1| < |op2|. If one of the operands is NaN, set the erange flag and return zero.

Function: `int` mpfr_nan_p `(mpfr_t op)` ¶
Function: `int` mpfr_inf_p `(mpfr_t op)` ¶
Function: `int` mpfr_number_p `(mpfr_t op)` ¶
Function: `int` mpfr_zero_p `(mpfr_t op)` ¶
Function: `int` mpfr_regular_p `(mpfr_t op)` ¶

  Return non-zero if op is respectively NaN, an infinity, an ordinary number (i.e., neither NaN nor an infinity), zero, or a regular number (i.e., neither NaN, nor an infinity nor zero). Return zero otherwise.

Macro: `int` mpfr_sgn `(mpfr_t op)` ¶

  Return a positive value if op > 0, zero if op = 0, and a negative value if op < 0. If the operand is NaN, set the erange flag and return zero. This is equivalent to `mpfr_cmp_ui (op, 0)`, but more efficient.

Function: `int` mpfr_greater_p `(mpfr_t op1, mpfr_t op2)` ¶
Function: `int` mpfr_greaterequal_p `(mpfr_t op1, mpfr_t op2)` ¶
Function: `int` mpfr_less_p `(mpfr_t op1, mpfr_t op2)` ¶
Function: `int` mpfr_lessequal_p `(mpfr_t op1, mpfr_t op2)` ¶
Function: `int` mpfr_equal_p `(mpfr_t op1, mpfr_t op2)` ¶

  Return non-zero if op1 > op2, op1 >= op2, op1 < op2, op1 <= op2, op1 = op2 respectively, and zero otherwise. Those functions return zero whenever op1 and/or op2 is NaN.

Function: `int` mpfr_lessgreater_p `(mpfr_t op1, mpfr_t op2)` ¶

  Return non-zero if op1 < op2 or op1 > op2 (i.e., neither op1, nor op2 is NaN, and op1 <> op2), zero otherwise (i.e., op1 and/or op2 is NaN, or op1 = op2).

Function: `int` mpfr_unordered_p `(mpfr_t op1, mpfr_t op2)` ¶

  Return non-zero if op1 or op2 is a NaN (i.e., they cannot be compared), zero otherwise.

Function: `int` mpfr_total_order_p `(mpfr_t x, mpfr_t y)` ¶

  This function implements the totalOrder predicate from IEEE 754, where −NaN < −Inf < negative finite numbers < −0 < +0 < positive finite numbers < +Inf < +NaN. It returns a non-zero value (true) when x is smaller than or equal to y for this order relation, and zero (false) otherwise. Contrary to `mpfr_cmp (x, y)`, which returns a ternary value, `mpfr_total_order_p` returns a binary value (zero or non-zero). In particular, `mpfr_total_order_p (x, x)` returns true, `mpfr_total_order_p (-0, +0)` returns true and `mpfr_total_order_p (+0, -0)` returns false. The sign bit of NaN also matters.