public static int mpfr_subnormalize(
	mpfr_t x,
	int t,
	mpfr_rnd_t rnd
)

Public Shared Function mpfr_subnormalize ( 
	x As mpfr_t,
	t As Integer,
	rnd As mpfr_rnd_t
) As Integer

public:
static int mpfr_subnormalize(
	mpfr_t^ x, 
	int t, 
	mpfr_rnd_t rnd
)

static member mpfr_subnormalize : 
        x : mpfr_t * 
        t : int * 
        rnd : mpfr_rnd_t -> int 

Parameters

x

Type: Math.Mpfr.Nativempfr_t
The operand floating-point number.

t

Type: SystemInt32
The input ternary value.

rnd

Type: Math.Mpfr.Nativempfr_rnd_t
The rounding direction.

Return Value

If x is outside the subnormal exponent range of the emulated floating-point system, this function just propagates the ternary value t; otherwise, it rounds x to precision EXP(x) - emin + 1 according to rounding mode rnd and previous ternary value t, avoiding double rounding problems. More precisely in the subnormal domain, denoting by e the value of emin, x is rounded in fixedpoint arithmetic to an integer multiple of two to the power e - 1; as a consequence, 1.5 multiplied by two to the power e - 1 when t is zero is rounded to two to the power e with rounding to nearest.

PREC(x) is not modified by this function. rnd and t must be the rounding mode and the returned ternary value used when computing x (as in mpfr_check_range). The subnormal exponent range is from emin to emin + PREC(x) - 1. If the result cannot be represented in the current exponent range of MPFR (due to a too small emax), the behavior is undefined. Note that unlike most functions, the result is compared to the exact one, not the input value x, i.e., the ternary value is propagated.

As usual, if the returned ternary value is non zero, the inexact flag is set. Moreover, if a second rounding occurred (because the input x was in the subnormal range), the underflow flag is set.

Warning! If you change emin (with mpfr_set_emin(mpfr_exp_t)) just before calling mpfr_subnormalize(mpfr_t, Int32, mpfr_rnd_t), you need to make sure that the value is in the current exponent range of MPFR. But it is better to change emin before any computation, if possible.

This is an example of how to emulate binary double IEEE 754 arithmetic (binary64 in IEEE 754-2008) using MPFR:

mpfr_t xa, xb; int i; volatile double a, b;
mpfr_set_default_prec(53);
mpfr_set_emin(-1073);
mpfr_set_emax(1024);

mpfr_init(xa); mpfr_init(xb);

b = 34.3; mpfr_set_d(xb, b, MPFR_RNDN);
a = 0x1.1235P-1021;
mpfr_set_d(xa, a, MPFR_RNDN);

a /= b;
i = mpfr_div(xa, xa, xb, MPFR_RNDN);
i = mpfr_subnormalize(xa, i, MPFR_RNDN); /* new ternary value */

mpfr_clear(xa);
mpfr_clear(xb);

Note that mpfr_set_emin(mpfr_exp_t) and mpfr_set_emax(mpfr_exp_t) are called early enough in order to make sure that all computed values are in the current exponent range. Warning! This emulates a double IEEE 754 arithmetic with correct rounding in the subnormal range, which may not be the case for your hardware.

Below is another example showing how to emulate fixed-point arithmetic in a specific case. Here we compute the sine of the integers 1 to 17 with a result in a fixed-point arithmetic rounded at 2−42 (using the fact that the result is at most 1 in absolute value):

mpfr_t x; int i, inex;
mpfr_set_emin(-41); 
mpfr_init2(x, 42);
for (i = 1; i ≤ 17; i++)
{ 
    mpfr_set_ui(x, i, MPFR_RNDN);
    inex = mpfr_sin(x, x, MPFR_RNDZ);
    mpfr_subnormalize(x, inex, MPFR_RNDZ);
    mpfr_dump(x);
}
mpfr_clear(x);

Reference