public static int mpfr_can_round(
	mpfr_t b,
	mpfr_exp_t err,
	mpfr_rnd_t rnd1,
	mpfr_rnd_t rnd2,
	mpfr_prec_t prec
)

Public Shared Function mpfr_can_round ( 
	b As mpfr_t,
	err As mpfr_exp_t,
	rnd1 As mpfr_rnd_t,
	rnd2 As mpfr_rnd_t,
	prec As mpfr_prec_t
) As Integer

public:
static int mpfr_can_round(
	mpfr_t^ b, 
	mpfr_exp_t err, 
	mpfr_rnd_t rnd1, 
	mpfr_rnd_t rnd2, 
	mpfr_prec_t prec
)

static member mpfr_can_round : 
        b : mpfr_t * 
        err : mpfr_exp_t * 
        rnd1 : mpfr_rnd_t * 
        rnd2 : mpfr_rnd_t * 
        prec : mpfr_prec_t -> int 

Parameters

b

Type: Math.Mpfr.Nativempfr_t
Floating-point number that approximates x.

err

Type: Math.Mpfr.Nativempfr_exp_t
The approximation error.

rnd1

Type: Math.Mpfr.Nativempfr_rnd_t
The rounding direction of the approximation.

rnd2

Type: Math.Mpfr.Nativempfr_rnd_t
The rounding direction of x.

prec

Type: Math.Mpfr.Nativempfr_prec_t
The precision of x.

Return Value

Assuming b is an approximation of an unknown number x in the direction rnd1 with error at most two to the power E(b) - err where E(b) is the exponent of b, return a non-zero value if one is able to round correctly x to precision prec with the direction rnd2 assuming an unbounded exponent range, and 0 otherwise (including for NaN and Inf). In other words, if the error on b is bounded by two to the power k ulps, and b has precision prec, you should give err = prec − k. This function does not modify its arguments.

If rnd1 is mpfr_rnd_t.MPFR_RNDN or mpfr_rnd_t.MPFR_RNDF, then the the error is considered to be either positive or negative, thus the possible range is twice as large as with a directed rounding for rnd1 (with the same value of err).

When rnd2 is MPFR_RNDF, let rnd3 be the opposite direction if rnd1 is a directed rounding, and MPFR_RNDN if rnd1 is MPFR_RNDN or MPFR_RNDF. The returned value of mpfr_can_round(mpfr_t, mpfr_exp_t, mpfr_rnd_t, mpfr_rnd_t, mpfr_prec_t)(b, err, rnd1, MPFR_RNDF, prec) is non-zero iff after the call mpfr_set(mpfr_t, mpfr_t, mpfr_rnd_t)(y, b, rnd3) with y of precision prec, y is guaranteed to be a faithful rounding of x.

Note: The ternary value cannot be determined in general with this function. However, if it is known that the exact value is not exactly representable in precision prec, then one can use the following trick to determine the (non-zero) ternary value in any rounding mode rnd2 (note that MPFR_RNDZ below can be replaced by any directed rounding mode):

if (mpfr_can_round(b, err, MPFR_RNDN, MPFR_RNDZ, prec + (rnd2 == mpfr_rnd_t.MPFR_RNDN)))
{
     /* round the approximation ’b’ to the result ’r’ of ’prec’ bits with rounding mode ’rnd2’ and get the ternary value ’inex’ */
     inex = mpfr_set(r, b, rnd2);
}

Indeed, if rnd2 is mpfr_rnd_t.MPFR_RNDN, this will check if one can round to prec + 1 bits with a directed rounding: if so, one can surely round to nearest to prec bits, and in addition one can determine the correct ternary value, which would not be the case when b is near from a value exactly representable on prec bits.

A detailed example is available in the examples subdirectory, file can_round.c.

Reference