From mboxrd@z Thu Jan 1 00:00:00 1970 From: Marcel Lorenz To: development@lists.ipfire.org Subject: [PATCH] mpfr: update to 3.1.3 Date: Wed, 09 Mar 2016 07:29:48 +0100 Message-ID: <1457504988-13650-1-git-send-email-marcel.lorenz@ipfire.org> MIME-Version: 1.0 Content-Type: multipart/mixed; boundary="===============6643568912114311495==" List-Id: --===============6643568912114311495== Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Signed-off-by: Marcel Lorenz --- config/rootfiles/common/mpfr | 4 +- lfs/mpfr | 9 +- src/patches/mpfr-3.1.3-upstream_fixes-1.patch | 1707 +++++++++++++++++++++++= ++ 3 files changed, 1714 insertions(+), 6 deletions(-) create mode 100644 src/patches/mpfr-3.1.3-upstream_fixes-1.patch diff --git a/config/rootfiles/common/mpfr b/config/rootfiles/common/mpfr index 70b925b..1e33e05 100644 --- a/config/rootfiles/common/mpfr +++ b/config/rootfiles/common/mpfr @@ -4,7 +4,7 @@ #usr/lib/libmpfr.la #usr/lib/libmpfr.so usr/lib/libmpfr.so.4 -usr/lib/libmpfr.so.4.1.2 +usr/lib/libmpfr.so.4.1.3 #usr/share/doc/mpfr #usr/share/doc/mpfr/AUTHORS #usr/share/doc/mpfr/BUGS @@ -19,4 +19,4 @@ usr/lib/libmpfr.so.4.1.2 #usr/share/doc/mpfr/examples/rndo-add.c #usr/share/doc/mpfr/examples/sample.c #usr/share/doc/mpfr/examples/version.c -#usr/share/info/mpfr.info +#usr/share/info/mpfr.info \ No newline at end of file diff --git a/lfs/mpfr b/lfs/mpfr index b4cfc66..bdf083b 100644 --- a/lfs/mpfr +++ b/lfs/mpfr @@ -1,7 +1,7 @@ ############################################################################= ### # = # # IPFire.org - A linux based firewall = # -# Copyright (C) 2007 Michael Tremer & Christian Schmidt = # +# Copyright (C) 2007-2016 IPFire Team = # # = # # This program is free software: you can redistribute it and/or modify = # # it under the terms of the GNU General Public License as published by = # @@ -24,7 +24,7 @@ =20 include Config =20 -VER =3D 3.1.2 +VER =3D 3.1.3 =20 THISAPP =3D mpfr-$(VER) DL_FILE =3D $(THISAPP).tar.xz @@ -40,7 +40,7 @@ objects =3D $(DL_FILE) =20 $(DL_FILE) =3D $(DL_FROM)/$(DL_FILE) =20 -$(DL_FILE)_MD5 =3D e3d203d188b8fe60bb6578dd3152e05c +$(DL_FILE)_MD5 =3D 6969398cd2fbc56a6af570b5273c56a9 =20 install : $(TARGET) =20 @@ -70,8 +70,9 @@ $(subst %,%_MD5,$(objects)) : $(TARGET) : $(patsubst %,$(DIR_DL)/%,$(objects)) @$(PREBUILD) @rm -rf $(DIR_APP) && cd $(DIR_SRC) && tar axf $(DIR_DL)/$(DL_FILE) + cd $(DIR_APP) && patch -Np1 -i $(DIR_SRC)/src/patches/mpfr-3.1.3-upstream_f= ixes-1.patch cd $(DIR_APP) && $(CONFIGURE_ARGS) ./configure --prefix=3D/usr \ - --enable-thread-safe --disable-nls + --enable-thread-safe --disable-nls cd $(DIR_APP) && make $(MAKETUNING) cd $(DIR_APP) && make install @rm -rf $(DIR_APP) diff --git a/src/patches/mpfr-3.1.3-upstream_fixes-1.patch b/src/patches/mpfr= -3.1.3-upstream_fixes-1.patch new file mode 100644 index 0000000..949ff73 --- /dev/null +++ b/src/patches/mpfr-3.1.3-upstream_fixes-1.patch @@ -0,0 +1,1707 @@ +Submitted By: Bruce Dubbs +Date: 2015-08-25 +Initial Package Version: 3.3.3 +Upstream Status: Already in upstream patch repo +Origin: Upstream http://www.mpfr.org/mpfr-current/allpatches + as of 2015-08-25. +Description: This patch contains bug fixes identified upstream. + +diff -Naurd mpfr-3.1.3-a/PATCHES mpfr-3.1.3-b/PATCHES +--- mpfr-3.1.3-a/PATCHES 2015-07-02 10:49:23.950112879 +0000 ++++ mpfr-3.1.3-b/PATCHES 2015-07-02 10:49:24.042113845 +0000 +@@ -0,0 +1 @@ ++lngamma-and-doc +diff -Naurd mpfr-3.1.3-a/VERSION mpfr-3.1.3-b/VERSION +--- mpfr-3.1.3-a/VERSION 2015-06-19 19:55:09.000000000 +0000 ++++ mpfr-3.1.3-b/VERSION 2015-07-02 10:49:24.042113845 +0000 +@@ -1 +1 @@ +-3.1.3 ++3.1.3-p1 +diff -Naurd mpfr-3.1.3-a/doc/mpfr.texi mpfr-3.1.3-b/doc/mpfr.texi +--- mpfr-3.1.3-a/doc/mpfr.texi 2015-06-19 19:55:11.000000000 +0000 ++++ mpfr-3.1.3-b/doc/mpfr.texi 2015-07-02 10:49:24.018113593 +0000 +@@ -810,13 +810,17 @@ + When the input point is in the closure of the domain of the mathematical + function and an input argument is +0 (resp.@: @minus{}0), one considers + the limit when the corresponding argument approaches 0 from above +-(resp.@: below). If the limit is not defined (e.g., @code{mpfr_log} on +-(a)minus{}0), the behavior is specified in the description of the MPFR func= tion. ++(resp.@: below), if possible. If the limit is not defined (e.g., ++(a)code{mpfr_sqrt} and @code{mpfr_log} on @minus{}0), the behavior is ++specified in the description of the MPFR function, but must be consistent ++with the rule from the above paragraph (e.g., @code{mpfr_log} on @pom{}0 ++gives @minus{}Inf). +=20 + When the result is equal to 0, its sign is determined by considering the + limit as if the input point were not in the domain: If one approaches 0 + from above (resp.@: below), the result is +0 (resp.@: @minus{}0); +-for example, @code{mpfr_sin} on +0 gives +0. ++for example, @code{mpfr_sin} on @minus{}0 gives @minus{}0 and ++(a)code{mpfr_acos} on 1 gives +0 (in all rounding modes). + In the other cases, the sign is specified in the description of the MPFR + function; for example @code{mpfr_max} on @minus{}0 and +0 gives +0. +=20 +@@ -832,8 +836,8 @@ + @c that advantages in practice), like for any bug fix. + Example: @code{mpfr_hypot} on (NaN,0) gives NaN, but @code{mpfr_hypot} + on (NaN,+Inf) gives +Inf (as specified in @ref{Special Functions}), +-since for any finite input @var{x}, @code{mpfr_hypot} on (@var{x},+Inf) +-gives +Inf. ++since for any finite or infinite input @var{x}, @code{mpfr_hypot} on ++(@var{x},+Inf) gives +Inf. +=20 + @node Exceptions, Memory Handling, Floating-Point Values on Special Numbers= , MPFR Basics + @comment node-name, next, previous, up +@@ -1581,7 +1585,8 @@ + @deftypefunx int mpfr_add_z (mpfr_t @var{rop}, mpfr_t @var{op1}, mpz_t @var= {op2}, mpfr_rnd_t @var{rnd}) + @deftypefunx int mpfr_add_q (mpfr_t @var{rop}, mpfr_t @var{op1}, mpq_t @var= {op2}, mpfr_rnd_t @var{rnd}) + Set @var{rop} to @math{@var{op1} + @var{op2}} rounded in the direction +-(a)var{rnd}. For types having no signed zero, it is considered unsigned ++(a)var{rnd}. The IEEE-754 rules are used, in particular for signed zeros. ++But for types having no signed zeros, 0 is considered unsigned + (i.e., (+0) + 0 =3D (+0) and (@minus{}0) + 0 =3D (@minus{}0)). + The @code{mpfr_add_d} function assumes that the radix of the @code{double} = type + is a power of 2, with a precision at most that declared by the C implementa= tion +@@ -1599,7 +1604,8 @@ + @deftypefunx int mpfr_sub_z (mpfr_t @var{rop}, mpfr_t @var{op1}, mpz_t @var= {op2}, mpfr_rnd_t @var{rnd}) + @deftypefunx int mpfr_sub_q (mpfr_t @var{rop}, mpfr_t @var{op1}, mpq_t @var= {op2}, mpfr_rnd_t @var{rnd}) + Set @var{rop} to @math{@var{op1} - @var{op2}} rounded in the direction +-(a)var{rnd}. For types having no signed zero, it is considered unsigned ++(a)var{rnd}. The IEEE-754 rules are used, in particular for signed zeros. ++But for types having no signed zeros, 0 is considered unsigned + (i.e., (+0) @minus{} 0 =3D (+0), (@minus{}0) @minus{} 0 =3D (@minus{}0), + 0 @minus{} (+0) =3D (@minus{}0) and 0 @minus{} (@minus{}0) =3D (+0)). + The same restrictions than for @code{mpfr_add_d} apply to @code{mpfr_d_sub} +@@ -1615,7 +1621,7 @@ + Set @var{rop} to @math{@var{op1} @GMPtimes{} @var{op2}} rounded in the + direction @var{rnd}. + When a result is zero, its sign is the product of the signs of the operands +-(for types having no signed zero, it is considered positive). ++(for types having no signed zeros, 0 is considered positive). + The same restrictions than for @code{mpfr_add_d} apply to @code{mpfr_mul_d}. + @end deftypefun +=20 +@@ -1635,7 +1641,7 @@ + @deftypefunx int mpfr_div_q (mpfr_t @var{rop}, mpfr_t @var{op1}, mpq_t @var= {op2}, mpfr_rnd_t @var{rnd}) + Set @var{rop} to @math{@var{op1}/@var{op2}} rounded in the direction @var{r= nd}. + When a result is zero, its sign is the product of the signs of the operands +-(for types having no signed zero, it is considered positive). ++(for types having no signed zeros, 0 is considered positive). + The same restrictions than for @code{mpfr_add_d} apply to @code{mpfr_d_div} + and @code{mpfr_div_d}. + @end deftypefun +@@ -1643,15 +1649,18 @@ + @deftypefun int mpfr_sqrt (mpfr_t @var{rop}, mpfr_t @var{op}, mpfr_rnd_t @v= ar{rnd}) + @deftypefunx int mpfr_sqrt_ui (mpfr_t @var{rop}, unsigned long int @var{op}= , mpfr_rnd_t @var{rnd}) + Set @var{rop} to @m{\sqrt{@var{op}}, the square root of @var{op}} +-rounded in the direction @var{rnd} (set @var{rop} to @minus{}0 if @var{op} = is +-(a)minus{}0, to be consistent with the IEEE 754 standard). ++rounded in the direction @var{rnd}. Set @var{rop} to @minus{}0 if ++(a)var{op} is @minus{}0, to be consistent with the IEEE 754 standard. + Set @var{rop} to NaN if @var{op} is negative. + @end deftypefun +=20 + @deftypefun int mpfr_rec_sqrt (mpfr_t @var{rop}, mpfr_t @var{op}, mpfr_rnd_= t @var{rnd}) + Set @var{rop} to @m{1/\sqrt{@var{op}}, the reciprocal square root of @var{o= p}} +-rounded in the direction @var{rnd}. Set @var{rop} to +Inf if @var{op} is +-(a)pom{}0, +0 if @var{op} is +Inf, and NaN if @var{op} is negative. ++rounded in the direction @var{rnd}. Set @var{rop} to +Inf if @var{op} is ++(a)pom{}0, +0 if @var{op} is +Inf, and NaN if @var{op} is negative. Warnin= g! ++Therefore the result on @minus{}0 is different from the one of the rSqrt ++function recommended by the IEEE 754-2008 standard (Section 9.2.1), which ++is @minus{}Inf instead of +Inf. + @end deftypefun +=20 + @deftypefun int mpfr_cbrt (mpfr_t @var{rop}, mpfr_t @var{op}, mpfr_rnd_t @v= ar{rnd}) +@@ -1832,7 +1841,9 @@ + @m{\log_2 @var{op}, log2(@var{op})} or + @m{\log_{10} @var{op}, log10(@var{op})}, respectively, + rounded in the direction @var{rnd}. +-Set @var{rop} to @minus{}Inf if @var{op} is @minus{}0 ++Set @var{rop} to +0 if @var{op} is 1 (in all rounding modes), ++for consistency with the ISO C99 and IEEE 754-2008 standards. ++Set @var{rop} to @minus{}Inf if @var{op} is @pom{}0 + (i.e., the sign of the zero has no influence on the result). + @end deftypefun +=20 +@@ -2003,8 +2014,11 @@ + @deftypefun int mpfr_lngamma (mpfr_t @var{rop}, mpfr_t @var{op}, mpfr_rnd_t= @var{rnd}) + Set @var{rop} to the value of the logarithm of the Gamma function on @var{o= p}, + rounded in the direction @var{rnd}. +-When @math{@minus{}2(a)var{k}@minus{}1 @le{} @var{op} @le{} @minus{}2(a)var= {k}}, +-(a)var{k} being a non-negative integer, @var{rop} is set to NaN. ++When @var{op} is 1 or 2, set @var{rop} to +0 (in all rounding modes). ++When @var{op} is an infinity or a nonpositive integer, set @var{rop} to +In= f, ++following the general rules on special values. ++When @math{@minus{}2(a)var{k}@minus{}1 < @var{op} < @minus{}2(a)var{k}}, ++(a)var{k} being a nonnegative integer, set @var{rop} to NaN(a). + See also @code{mpfr_lgamma}. + @end deftypefun +=20 +@@ -2012,10 +2026,11 @@ + Set @var{rop} to the value of the logarithm of the absolute value of the + Gamma function on @var{op}, rounded in the direction @var{rnd}. The sign + (1 or @minus{}1) of Gamma(@var{op}) is returned in the object pointed to +-by @var{signp}. When @var{op} is an infinity or a non-positive integer, set +-(a)var{rop} to +Inf. When @var{op} is NaN, @minus{}Inf or a negative intege= r, +-*@var{signp} is undefined, and when @var{op} is @pom{}0, *@var{signp} is +-the sign of the zero. ++by @var{signp}. ++When @var{op} is 1 or 2, set @var{rop} to +0 (in all rounding modes). ++When @var{op} is an infinity or a nonpositive integer, set @var{rop} to +In= f. ++When @var{op} is NaN, @minus{}Inf or a negative integer, *@var{signp} is ++undefined, and when @var{op} is @pom{}0, *@var{signp} is the sign of the ze= ro. + @end deftypefun +=20 + @deftypefun int mpfr_digamma (mpfr_t @var{rop}, mpfr_t @var{op}, mpfr_rnd_t= @var{rnd}) +@@ -2064,7 +2079,10 @@ + @deftypefunx int mpfr_fms (mpfr_t @var{rop}, mpfr_t @var{op1}, mpfr_t @var{= op2}, mpfr_t @var{op3}, mpfr_rnd_t @var{rnd}) + Set @var{rop} to @math{(@var{op1} @GMPtimes{} @var{op2}) + @var{op3}} + (resp.@: @math{(@var{op1} @GMPtimes{} @var{op2}) - @var{op3}}) +-rounded in the direction @var{rnd}. ++rounded in the direction @var{rnd}. Concerning special values (signed zero= s, ++infinities, NaN), these functions behave like a multiplication followed by a ++separate addition or subtraction. That is, the fused operation matters only ++for rounding. + @end deftypefun +=20 + @deftypefun int mpfr_agm (mpfr_t @var{rop}, mpfr_t @var{op1}, mpfr_t @var{o= p2}, mpfr_rnd_t @var{rnd}) +@@ -2089,8 +2107,8 @@ + i.e., $\sqrt{x^2+y^2}$, + @end tex + rounded in the direction @var{rnd}. +-Special values are handled as described in Section F.9.4.3 of +-the ISO C99 and IEEE 754-2008 standards: ++Special values are handled as described in the ISO C99 (Section F.9.4.3) ++and IEEE 754-2008 (Section 9.2.1) standards: + If @var{x} or @var{y} is an infinity, then +Inf is returned in @var{rop}, + even if the other number is NaN. + @end deftypefun +diff -Naurd mpfr-3.1.3-a/doc/mpfr.info mpfr-3.1.3-b/doc/mpfr.info +--- mpfr-3.1.3-a/doc/mpfr.info 2015-06-19 19:55:53.000000000 +0000 ++++ mpfr-3.1.3-b/doc/mpfr.info 2015-07-02 10:49:38.718267817 +0000 +@@ -1,4 +1,4 @@ +-This is mpfr.info, produced by makeinfo version 5.2 from mpfr.texi. ++This is mpfr.info, produced by makeinfo version 6.0 from mpfr.texi. +=20 + This manual documents how to install and use the Multiple Precision + Floating-Point Reliable Library, version 3.1.3. +@@ -55,7 +55,7 @@ + MPFR Copying Conditions + *********************** +=20 +-The GNU MPFR library (or MPFR for short) is "free"; this means that ++The GNU MPFR library (or MPFR for short) is =E2=80=9Cfree=E2=80=9D; this me= ans that + everyone is free to use it and free to redistribute it on a free basis. + The library is not in the public domain; it is copyrighted and there are + restrictions on its distribution, but these restrictions are designed to +@@ -418,7 +418,7 @@ + 4.2 Nomenclature and Types + =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D +=20 +-A "floating-point number", or "float" for short, is an arbitrary ++A =E2=80=9Cfloating-point number=E2=80=9D, or =E2=80=9Cfloat=E2=80=9D for s= hort, is an arbitrary + precision significand (also called mantissa) with a limited precision + exponent. The C data type for such objects is =E2=80=98mpfr_t=E2=80=99 (in= ternally + defined as a one-element array of a structure, and =E2=80=98mpfr_ptr=E2=80= =99 is the C +@@ -432,7 +432,7 @@ + to the other functions supported by MPFR. Unless documented otherwise, + the sign bit of a NaN is unspecified. +=20 +-The "precision" is the number of bits used to represent the significand ++The =E2=80=9Cprecision=E2=80=9D is the number of bits used to represent the= significand + of a floating-point number; the corresponding C data type is + =E2=80=98mpfr_prec_t=E2=80=99. The precision can be any integer between = =E2=80=98MPFR_PREC_MIN=E2=80=99 + and =E2=80=98MPFR_PREC_MAX=E2=80=99. In the current implementation, =E2=80= =98MPFR_PREC_MIN=E2=80=99 is +@@ -446,7 +446,7 @@ + may abort, crash or have undefined behavior (depending on your C + implementation). +=20 +-The "rounding mode" specifies the way to round the result of a ++The =E2=80=9Crounding mode=E2=80=9D specifies the way to round the result o= f a + floating-point operation, in case the exact result can not be + represented exactly in the destination significand; the corresponding C + data type is =E2=80=98mpfr_rnd_t=E2=80=99. +@@ -499,14 +499,14 @@ + representable numbers, it is rounded to the one with the least + significant bit set to zero. For example, the number 2.5, which is + represented by (10.1) in binary, is rounded to (10.0)=3D2 with a precision +-of two bits, and not to (11.0)=3D3. This rule avoids the "drift" ++of two bits, and not to (11.0)=3D3. This rule avoids the =E2=80=9Cdrift=E2= =80=9D + phenomenon mentioned by Knuth in volume 2 of The Art of Computer + Programming (Section 4.2.2). +=20 + Most MPFR functions take as first argument the destination variable, + as second and following arguments the input variables, as last argument + a rounding mode, and have a return value of type =E2=80=98int=E2=80=99, cal= led the +-"ternary value". The value stored in the destination variable is ++=E2=80=9Cternary value=E2=80=9D. The value stored in the destination varia= ble is + correctly rounded, i.e., MPFR behaves as if it computed the result with + an infinite precision, then rounded it to the precision of this + variable. The input variables are regarded as exact (in particular, +@@ -572,15 +572,18 @@ + When the input point is in the closure of the domain of the + mathematical function and an input argument is +0 (resp. =E2=88=920), one + considers the limit when the corresponding argument approaches 0 from +-above (resp. below). If the limit is not defined (e.g., =E2=80=98mpfr_log= =E2=80=99 on +-=E2=88=920), the behavior is specified in the description of the MPFR funct= ion. ++above (resp. below), if possible. If the limit is not defined (e.g., ++=E2=80=98mpfr_sqrt=E2=80=99 and =E2=80=98mpfr_log=E2=80=99 on =E2=88=920), = the behavior is specified in the ++description of the MPFR function, but must be consistent with the rule ++from the above paragraph (e.g., =E2=80=98mpfr_log=E2=80=99 on =C2=B10 gives= =E2=88=92Inf). +=20 + When the result is equal to 0, its sign is determined by considering + the limit as if the input point were not in the domain: If one + approaches 0 from above (resp. below), the result is +0 (resp. =E2=88=920);= for +-example, =E2=80=98mpfr_sin=E2=80=99 on +0 gives +0. In the other cases, th= e sign is +-specified in the description of the MPFR function; for example +-=E2=80=98mpfr_max=E2=80=99 on =E2=88=920 and +0 gives +0. ++example, =E2=80=98mpfr_sin=E2=80=99 on =E2=88=920 gives =E2=88=920 and =E2= =80=98mpfr_acos=E2=80=99 on 1 gives +0 (in all ++rounding modes). In the other cases, the sign is specified in the ++description of the MPFR function; for example =E2=80=98mpfr_max=E2=80=99 on= =E2=88=920 and +0 ++gives +0. +=20 + When the input point is not in the closure of the domain of the + function, the result is NaN. Example: =E2=80=98mpfr_sqrt=E2=80=99 on =E2=88= =9217 gives NaN. +@@ -590,8 +593,8 @@ + numbers; such a case is always explicitly specified in *note MPFR + Interface::. Example: =E2=80=98mpfr_hypot=E2=80=99 on (NaN,0) gives NaN, b= ut + =E2=80=98mpfr_hypot=E2=80=99 on (NaN,+Inf) gives +Inf (as specified in *not= e Special +-Functions::), since for any finite input X, =E2=80=98mpfr_hypot=E2=80=99 on= (X,+Inf) +-gives +Inf. ++Functions::), since for any finite or infinite input X, =E2=80=98mpfr_hypot= =E2=80=99 on ++(X,+Inf) gives +Inf. +=20 + =1F + File: mpfr.info, Node: Exceptions, Next: Memory Handling, Prev: Floating= -Point Values on Special Numbers, Up: MPFR Basics +@@ -1253,8 +1256,9 @@ + mpfr_rnd_t RND) + -- Function: int mpfr_add_q (mpfr_t ROP, mpfr_t OP1, mpq_t OP2, + mpfr_rnd_t RND) +- Set ROP to OP1 + OP2 rounded in the direction RND. For types +- having no signed zero, it is considered unsigned (i.e., (+0) + 0 =3D ++ Set ROP to OP1 + OP2 rounded in the direction RND. The IEEE-754 ++ rules are used, in particular for signed zeros. But for types ++ having no signed zeros, 0 is considered unsigned (i.e., (+0) + 0 =3D + (+0) and (=E2=88=920) + 0 =3D (=E2=88=920)). The =E2=80=98mpfr_add_d= =E2=80=99 function assumes that + the radix of the =E2=80=98double=E2=80=99 type is a power of 2, with a= precision at + most that declared by the C implementation (macro +@@ -1280,8 +1284,9 @@ + mpfr_rnd_t RND) + -- Function: int mpfr_sub_q (mpfr_t ROP, mpfr_t OP1, mpq_t OP2, + mpfr_rnd_t RND) +- Set ROP to OP1 - OP2 rounded in the direction RND. For types +- having no signed zero, it is considered unsigned (i.e., (+0) =E2=88=92= 0 =3D ++ Set ROP to OP1 - OP2 rounded in the direction RND. The IEEE-754 ++ rules are used, in particular for signed zeros. But for types ++ having no signed zeros, 0 is considered unsigned (i.e., (+0) =E2=88=92= 0 =3D + (+0), (=E2=88=920) =E2=88=92 0 =3D (=E2=88=920), 0 =E2=88=92 (+0) =3D = (=E2=88=920) and 0 =E2=88=92 (=E2=88=920) =3D (+0)). The + same restrictions than for =E2=80=98mpfr_add_d=E2=80=99 apply to =E2= =80=98mpfr_d_sub=E2=80=99 and + =E2=80=98mpfr_sub_d=E2=80=99. +@@ -1300,7 +1305,7 @@ + mpfr_rnd_t RND) + Set ROP to OP1 times OP2 rounded in the direction RND. When a + result is zero, its sign is the product of the signs of the +- operands (for types having no signed zero, it is considered ++ operands (for types having no signed zeros, 0 is considered + positive). The same restrictions than for =E2=80=98mpfr_add_d=E2=80= =99 apply to + =E2=80=98mpfr_mul_d=E2=80=99. +=20 +@@ -1327,21 +1332,24 @@ + mpfr_rnd_t RND) + Set ROP to OP1/OP2 rounded in the direction RND. When a result is + zero, its sign is the product of the signs of the operands (for +- types having no signed zero, it is considered positive). The same ++ types having no signed zeros, 0 is considered positive). The same + restrictions than for =E2=80=98mpfr_add_d=E2=80=99 apply to =E2=80=98m= pfr_d_div=E2=80=99 and + =E2=80=98mpfr_div_d=E2=80=99. +=20 + -- Function: int mpfr_sqrt (mpfr_t ROP, mpfr_t OP, mpfr_rnd_t RND) + -- Function: int mpfr_sqrt_ui (mpfr_t ROP, unsigned long int OP, + mpfr_rnd_t RND) +- Set ROP to the square root of OP rounded in the direction RND (set +- ROP to =E2=88=920 if OP is =E2=88=920, to be consistent with the IEEE = 754 +- standard). Set ROP to NaN if OP is negative. ++ Set ROP to the square root of OP rounded in the direction RND. Set ++ ROP to =E2=88=920 if OP is =E2=88=920, to be consistent with the IEEE = 754 standard. ++ Set ROP to NaN if OP is negative. +=20 + -- Function: int mpfr_rec_sqrt (mpfr_t ROP, mpfr_t OP, mpfr_rnd_t RND) + Set ROP to the reciprocal square root of OP rounded in the + direction RND. Set ROP to +Inf if OP is =C2=B10, +0 if OP is +Inf, and +- NaN if OP is negative. ++ NaN if OP is negative. Warning! Therefore the result on =E2=88=920 is ++ different from the one of the rSqrt function recommended by the ++ IEEE 754-2008 standard (Section 9.2.1), which is =E2=88=92Inf instead = of ++ +Inf. +=20 + -- Function: int mpfr_cbrt (mpfr_t ROP, mpfr_t OP, mpfr_rnd_t RND) + -- Function: int mpfr_root (mpfr_t ROP, mpfr_t OP, unsigned long int K, +@@ -1515,8 +1523,10 @@ + -- Function: int mpfr_log2 (mpfr_t ROP, mpfr_t OP, mpfr_rnd_t RND) + -- Function: int mpfr_log10 (mpfr_t ROP, mpfr_t OP, mpfr_rnd_t RND) + Set ROP to the natural logarithm of OP, log2(OP) or log10(OP), +- respectively, rounded in the direction RND. Set ROP to =E2=88=92Inf i= f OP +- is =E2=88=920 (i.e., the sign of the zero has no influence on the resu= lt). ++ respectively, rounded in the direction RND. Set ROP to +0 if OP is ++ 1 (in all rounding modes), for consistency with the ISO C99 and ++ IEEE 754-2008 standards. Set ROP to =E2=88=92Inf if OP is =C2=B10 (i.= e., the ++ sign of the zero has no influence on the result). +=20 + -- Function: int mpfr_exp (mpfr_t ROP, mpfr_t OP, mpfr_rnd_t RND) + -- Function: int mpfr_exp2 (mpfr_t ROP, mpfr_t OP, mpfr_rnd_t RND) +@@ -1649,17 +1659,21 @@ +=20 + -- Function: int mpfr_lngamma (mpfr_t ROP, mpfr_t OP, mpfr_rnd_t RND) + Set ROP to the value of the logarithm of the Gamma function on OP, +- rounded in the direction RND. When =E2=88=922K=E2=88=921 <=3D OP <=3D= =E2=88=922K, K being a +- non-negative integer, ROP is set to NaN. See also =E2=80=98mpfr_lgamma= =E2=80=99. ++ rounded in the direction RND. When OP is 1 or 2, set ROP to +0 (in ++ all rounding modes). When OP is an infinity or a nonpositive ++ integer, set ROP to +Inf, following the general rules on special ++ values. When =E2=88=922K=E2=88=921 < OP < =E2=88=922K, K being a nonn= egative integer, set ++ ROP to NaN. See also =E2=80=98mpfr_lgamma=E2=80=99. +=20 + -- Function: int mpfr_lgamma (mpfr_t ROP, int *SIGNP, mpfr_t OP, + mpfr_rnd_t RND) + Set ROP to the value of the logarithm of the absolute value of the + Gamma function on OP, rounded in the direction RND. The sign (1 or + =E2=88=921) of Gamma(OP) is returned in the object pointed to by SIGNP. +- When OP is an infinity or a non-positive integer, set ROP to +Inf. +- When OP is NaN, =E2=88=92Inf or a negative integer, *SIGNP is undefine= d, +- and when OP is =C2=B10, *SIGNP is the sign of the zero. ++ When OP is 1 or 2, set ROP to +0 (in all rounding modes). When OP ++ is an infinity or a nonpositive integer, set ROP to +Inf. When OP ++ is NaN, =E2=88=92Inf or a negative integer, *SIGNP is undefined, and w= hen ++ OP is =C2=B10, *SIGNP is the sign of the zero. +=20 + -- Function: int mpfr_digamma (mpfr_t ROP, mpfr_t OP, mpfr_rnd_t RND) + Set ROP to the value of the Digamma (sometimes also called Psi) +@@ -1703,7 +1717,10 @@ + -- Function: int mpfr_fms (mpfr_t ROP, mpfr_t OP1, mpfr_t OP2, mpfr_t + OP3, mpfr_rnd_t RND) + Set ROP to (OP1 times OP2) + OP3 (resp. (OP1 times OP2) - OP3) +- rounded in the direction RND. ++ rounded in the direction RND. Concerning special values (signed ++ zeros, infinities, NaN), these functions behave like a ++ multiplication followed by a separate addition or subtraction. ++ That is, the fused operation matters only for rounding. +=20 + -- Function: int mpfr_agm (mpfr_t ROP, mpfr_t OP1, mpfr_t OP2, + mpfr_rnd_t RND) +@@ -1717,9 +1734,10 @@ + RND) + Set ROP to the Euclidean norm of X and Y, i.e., the square root of + the sum of the squares of X and Y, rounded in the direction RND. +- Special values are handled as described in Section F.9.4.3 of the +- ISO C99 and IEEE 754-2008 standards: If X or Y is an infinity, then +- +Inf is returned in ROP, even if the other number is NaN. ++ Special values are handled as described in the ISO C99 (Section ++ F.9.4.3) and IEEE 754-2008 (Section 9.2.1) standards: If X or Y is ++ an infinity, then +Inf is returned in ROP, even if the other number ++ is NaN. +=20 + -- Function: int mpfr_ai (mpfr_t ROP, mpfr_t X, mpfr_rnd_t RND) + Set ROP to the value of the Airy function Ai on X, rounded in the +@@ -2670,7 +2688,7 @@ + 5.16 Internals + =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D +=20 +-A "limb" means the part of a multi-precision number that fits in a ++A =E2=80=9Climb=E2=80=9D means the part of a multi-precision number that fi= ts in a + single word. Usually a limb contains 32 or 64 bits. The C data type + for a limb is =E2=80=98mp_limb_t=E2=80=99. +=20 +@@ -3140,7 +3158,7 @@ + 0. PREAMBLE +=20 + The purpose of this License is to make a manual, textbook, or other +- functional and useful document "free" in the sense of freedom: to ++ functional and useful document =E2=80=9Cfree=E2=80=9D in the sense of = freedom: to + assure everyone the effective freedom to copy and redistribute it, + with or without modifying it, either commercially or + noncommercially. Secondarily, this License preserves for the +@@ -3655,9 +3673,9 @@ + * Menu: +=20 + * mpfr_abs: Basic Arithmetic Functions. +- (line 160) +-* mpfr_acos: Special Functions. (line 51) +-* mpfr_acosh: Special Functions. (line 115) ++ (line 165) ++* mpfr_acos: Special Functions. (line 53) ++* mpfr_acosh: Special Functions. (line 117) + * mpfr_add: Basic Arithmetic Functions. + (line 6) + * mpfr_add_d: Basic Arithmetic Functions. +@@ -3670,15 +3688,15 @@ + (line 8) + * mpfr_add_z: Basic Arithmetic Functions. + (line 14) +-* mpfr_agm: Special Functions. (line 210) +-* mpfr_ai: Special Functions. (line 226) +-* mpfr_asin: Special Functions. (line 52) +-* mpfr_asinh: Special Functions. (line 116) ++* mpfr_agm: Special Functions. (line 219) ++* mpfr_ai: Special Functions. (line 236) ++* mpfr_asin: Special Functions. (line 54) ++* mpfr_asinh: Special Functions. (line 118) + * mpfr_asprintf: Formatted Output Functions. + (line 193) +-* mpfr_atan: Special Functions. (line 53) +-* mpfr_atan2: Special Functions. (line 63) +-* mpfr_atanh: Special Functions. (line 117) ++* mpfr_atan: Special Functions. (line 55) ++* mpfr_atan2: Special Functions. (line 65) ++* mpfr_atanh: Special Functions. (line 119) + * mpfr_buildopt_decimal_p: Miscellaneous Functions. + (line 162) + * mpfr_buildopt_gmpinternals_p: Miscellaneous Functions. +@@ -3690,7 +3708,7 @@ + * mpfr_can_round: Rounding Related Functions. + (line 39) + * mpfr_cbrt: Basic Arithmetic Functions. +- (line 108) ++ (line 113) + * mpfr_ceil: Integer Related Functions. + (line 7) + * mpfr_check_range: Exception Related Functions. +@@ -3735,18 +3753,18 @@ + (line 27) + * mpfr_cmp_z: Comparison Functions. + (line 11) +-* mpfr_const_catalan: Special Functions. (line 237) +-* mpfr_const_euler: Special Functions. (line 236) +-* mpfr_const_log2: Special Functions. (line 234) +-* mpfr_const_pi: Special Functions. (line 235) ++* mpfr_const_catalan: Special Functions. (line 247) ++* mpfr_const_euler: Special Functions. (line 246) ++* mpfr_const_log2: Special Functions. (line 244) ++* mpfr_const_pi: Special Functions. (line 245) + * mpfr_copysign: Miscellaneous Functions. + (line 109) +-* mpfr_cos: Special Functions. (line 29) +-* mpfr_cosh: Special Functions. (line 95) +-* mpfr_cot: Special Functions. (line 47) +-* mpfr_coth: Special Functions. (line 111) +-* mpfr_csc: Special Functions. (line 46) +-* mpfr_csch: Special Functions. (line 110) ++* mpfr_cos: Special Functions. (line 31) ++* mpfr_cosh: Special Functions. (line 97) ++* mpfr_cot: Special Functions. (line 49) ++* mpfr_coth: Special Functions. (line 113) ++* mpfr_csc: Special Functions. (line 48) ++* mpfr_csch: Special Functions. (line 112) + * mpfr_custom_get_exp: Custom Interface. (line 75) + * mpfr_custom_get_kind: Custom Interface. (line 65) + * mpfr_custom_get_significand: Custom Interface. (line 70) +@@ -3756,47 +3774,47 @@ + * mpfr_custom_move: Custom Interface. (line 82) + * MPFR_DECL_INIT: Initialization Functions. + (line 74) +-* mpfr_digamma: Special Functions. (line 166) ++* mpfr_digamma: Special Functions. (line 172) + * mpfr_dim: Basic Arithmetic Functions. +- (line 166) ++ (line 171) + * mpfr_div: Basic Arithmetic Functions. +- (line 72) ++ (line 74) + * mpfr_divby0_p: Exception Related Functions. + (line 134) + * mpfr_div_2exp: Compatibility with MPF. + (line 49) + * mpfr_div_2si: Basic Arithmetic Functions. +- (line 181) ++ (line 186) + * mpfr_div_2ui: Basic Arithmetic Functions. +- (line 179) ++ (line 184) + * mpfr_div_d: Basic Arithmetic Functions. +- (line 84) ++ (line 86) + * mpfr_div_q: Basic Arithmetic Functions. +- (line 88) ++ (line 90) + * mpfr_div_si: Basic Arithmetic Functions. +- (line 80) ++ (line 82) + * mpfr_div_ui: Basic Arithmetic Functions. +- (line 76) ++ (line 78) + * mpfr_div_z: Basic Arithmetic Functions. +- (line 86) ++ (line 88) + * mpfr_d_div: Basic Arithmetic Functions. +- (line 82) ++ (line 84) + * mpfr_d_sub: Basic Arithmetic Functions. +- (line 35) +-* mpfr_eint: Special Functions. (line 133) ++ (line 36) ++* mpfr_eint: Special Functions. (line 135) + * mpfr_eq: Compatibility with MPF. + (line 28) + * mpfr_equal_p: Comparison Functions. + (line 59) + * mpfr_erangeflag_p: Exception Related Functions. + (line 137) +-* mpfr_erf: Special Functions. (line 177) +-* mpfr_erfc: Special Functions. (line 178) +-* mpfr_exp: Special Functions. (line 23) +-* mpfr_exp10: Special Functions. (line 25) +-* mpfr_exp2: Special Functions. (line 24) +-* mpfr_expm1: Special Functions. (line 129) +-* mpfr_fac_ui: Special Functions. (line 121) ++* mpfr_erf: Special Functions. (line 183) ++* mpfr_erfc: Special Functions. (line 184) ++* mpfr_exp: Special Functions. (line 25) ++* mpfr_exp10: Special Functions. (line 27) ++* mpfr_exp2: Special Functions. (line 26) ++* mpfr_expm1: Special Functions. (line 131) ++* mpfr_fac_ui: Special Functions. (line 123) + * mpfr_fits_intmax_p: Conversion Functions. + (line 150) + * mpfr_fits_sint_p: Conversion Functions. +@@ -3815,20 +3833,20 @@ + (line 147) + * mpfr_floor: Integer Related Functions. + (line 8) +-* mpfr_fma: Special Functions. (line 203) ++* mpfr_fma: Special Functions. (line 209) + * mpfr_fmod: Integer Related Functions. + (line 92) +-* mpfr_fms: Special Functions. (line 205) ++* mpfr_fms: Special Functions. (line 211) + * mpfr_fprintf: Formatted Output Functions. + (line 157) + * mpfr_frac: Integer Related Functions. + (line 76) +-* mpfr_free_cache: Special Functions. (line 244) ++* mpfr_free_cache: Special Functions. (line 254) + * mpfr_free_str: Conversion Functions. + (line 137) + * mpfr_frexp: Conversion Functions. + (line 45) +-* mpfr_gamma: Special Functions. (line 148) ++* mpfr_gamma: Special Functions. (line 150) + * mpfr_get_d: Conversion Functions. + (line 7) + * mpfr_get_decimal64: Conversion Functions. +@@ -3887,7 +3905,7 @@ + (line 56) + * mpfr_greater_p: Comparison Functions. + (line 55) +-* mpfr_hypot: Special Functions. (line 218) ++* mpfr_hypot: Special Functions. (line 227) + * mpfr_inexflag_p: Exception Related Functions. + (line 136) + * mpfr_inf_p: Comparison Functions. +@@ -3922,21 +3940,21 @@ + (line 31) + * mpfr_integer_p: Integer Related Functions. + (line 119) +-* mpfr_j0: Special Functions. (line 182) +-* mpfr_j1: Special Functions. (line 183) +-* mpfr_jn: Special Functions. (line 184) ++* mpfr_j0: Special Functions. (line 188) ++* mpfr_j1: Special Functions. (line 189) ++* mpfr_jn: Special Functions. (line 190) + * mpfr_lessequal_p: Comparison Functions. + (line 58) + * mpfr_lessgreater_p: Comparison Functions. + (line 64) + * mpfr_less_p: Comparison Functions. + (line 57) +-* mpfr_lgamma: Special Functions. (line 157) +-* mpfr_li2: Special Functions. (line 143) +-* mpfr_lngamma: Special Functions. (line 152) ++* mpfr_lgamma: Special Functions. (line 162) ++* mpfr_li2: Special Functions. (line 145) ++* mpfr_lngamma: Special Functions. (line 154) + * mpfr_log: Special Functions. (line 16) + * mpfr_log10: Special Functions. (line 18) +-* mpfr_log1p: Special Functions. (line 125) ++* mpfr_log1p: Special Functions. (line 127) + * mpfr_log2: Special Functions. (line 17) + * mpfr_max: Miscellaneous Functions. + (line 22) +@@ -3947,29 +3965,29 @@ + * mpfr_modf: Integer Related Functions. + (line 82) + * mpfr_mul: Basic Arithmetic Functions. +- (line 51) ++ (line 53) + * mpfr_mul_2exp: Compatibility with MPF. + (line 47) + * mpfr_mul_2si: Basic Arithmetic Functions. +- (line 174) ++ (line 179) + * mpfr_mul_2ui: Basic Arithmetic Functions. +- (line 172) ++ (line 177) + * mpfr_mul_d: Basic Arithmetic Functions. +- (line 57) ++ (line 59) + * mpfr_mul_q: Basic Arithmetic Functions. +- (line 61) ++ (line 63) + * mpfr_mul_si: Basic Arithmetic Functions. +- (line 55) ++ (line 57) + * mpfr_mul_ui: Basic Arithmetic Functions. +- (line 53) ++ (line 55) + * mpfr_mul_z: Basic Arithmetic Functions. +- (line 59) ++ (line 61) + * mpfr_nanflag_p: Exception Related Functions. + (line 135) + * mpfr_nan_p: Comparison Functions. + (line 39) + * mpfr_neg: Basic Arithmetic Functions. +- (line 159) ++ (line 164) + * mpfr_nextabove: Miscellaneous Functions. + (line 15) + * mpfr_nextbelow: Miscellaneous Functions. +@@ -3983,13 +4001,13 @@ + * mpfr_overflow_p: Exception Related Functions. + (line 133) + * mpfr_pow: Basic Arithmetic Functions. +- (line 116) ++ (line 121) + * mpfr_pow_si: Basic Arithmetic Functions. +- (line 120) ++ (line 125) + * mpfr_pow_ui: Basic Arithmetic Functions. +- (line 118) ++ (line 123) + * mpfr_pow_z: Basic Arithmetic Functions. +- (line 122) ++ (line 127) + * mpfr_prec_round: Rounding Related Functions. + (line 13) + * =E2=80=98mpfr_prec_t=E2=80=99: Nomenclature and T= ypes. +@@ -3999,7 +4017,7 @@ + * mpfr_print_rnd_mode: Rounding Related Functions. + (line 71) + * mpfr_rec_sqrt: Basic Arithmetic Functions. +- (line 103) ++ (line 105) + * mpfr_regular_p: Comparison Functions. + (line 43) + * mpfr_reldiff: Compatibility with MPF. +@@ -4021,11 +4039,11 @@ + * =E2=80=98mpfr_rnd_t=E2=80=99: Nomenclature and T= ypes. + (line 34) + * mpfr_root: Basic Arithmetic Functions. +- (line 109) ++ (line 114) + * mpfr_round: Integer Related Functions. + (line 9) +-* mpfr_sec: Special Functions. (line 45) +-* mpfr_sech: Special Functions. (line 109) ++* mpfr_sec: Special Functions. (line 47) ++* mpfr_sech: Special Functions. (line 111) + * mpfr_set: Assignment Functions. + (line 9) + * mpfr_setsign: Miscellaneous Functions. +@@ -4100,57 +4118,57 @@ + (line 49) + * mpfr_signbit: Miscellaneous Functions. + (line 99) +-* mpfr_sin: Special Functions. (line 30) +-* mpfr_sinh: Special Functions. (line 96) +-* mpfr_sinh_cosh: Special Functions. (line 101) +-* mpfr_sin_cos: Special Functions. (line 35) ++* mpfr_sin: Special Functions. (line 32) ++* mpfr_sinh: Special Functions. (line 98) ++* mpfr_sinh_cosh: Special Functions. (line 103) ++* mpfr_sin_cos: Special Functions. (line 37) + * mpfr_si_div: Basic Arithmetic Functions. +- (line 78) ++ (line 80) + * mpfr_si_sub: Basic Arithmetic Functions. +- (line 31) ++ (line 32) + * mpfr_snprintf: Formatted Output Functions. + (line 180) + * mpfr_sprintf: Formatted Output Functions. + (line 170) + * mpfr_sqr: Basic Arithmetic Functions. +- (line 69) ++ (line 71) + * mpfr_sqrt: Basic Arithmetic Functions. +- (line 96) ++ (line 98) + * mpfr_sqrt_ui: Basic Arithmetic Functions. +- (line 97) ++ (line 99) + * mpfr_strtofr: Assignment Functions. + (line 80) + * mpfr_sub: Basic Arithmetic Functions. +- (line 25) ++ (line 26) + * mpfr_subnormalize: Exception Related Functions. + (line 60) + * mpfr_sub_d: Basic Arithmetic Functions. +- (line 37) ++ (line 38) + * mpfr_sub_q: Basic Arithmetic Functions. +- (line 43) ++ (line 44) + * mpfr_sub_si: Basic Arithmetic Functions. +- (line 33) ++ (line 34) + * mpfr_sub_ui: Basic Arithmetic Functions. +- (line 29) ++ (line 30) + * mpfr_sub_z: Basic Arithmetic Functions. +- (line 41) +-* mpfr_sum: Special Functions. (line 252) ++ (line 42) ++* mpfr_sum: Special Functions. (line 262) + * mpfr_swap: Assignment Functions. + (line 150) + * =E2=80=98mpfr_t=E2=80=99: Nomenclature and T= ypes. + (line 6) +-* mpfr_tan: Special Functions. (line 31) +-* mpfr_tanh: Special Functions. (line 97) ++* mpfr_tan: Special Functions. (line 33) ++* mpfr_tanh: Special Functions. (line 99) + * mpfr_trunc: Integer Related Functions. + (line 10) + * mpfr_ui_div: Basic Arithmetic Functions. +- (line 74) ++ (line 76) + * mpfr_ui_pow: Basic Arithmetic Functions. +- (line 126) ++ (line 131) + * mpfr_ui_pow_ui: Basic Arithmetic Functions. +- (line 124) ++ (line 129) + * mpfr_ui_sub: Basic Arithmetic Functions. +- (line 27) ++ (line 28) + * mpfr_underflow_p: Exception Related Functions. + (line 132) + * mpfr_unordered_p: Comparison Functions. +@@ -4181,61 +4199,61 @@ + (line 182) + * mpfr_vsprintf: Formatted Output Functions. + (line 171) +-* mpfr_y0: Special Functions. (line 193) +-* mpfr_y1: Special Functions. (line 194) +-* mpfr_yn: Special Functions. (line 195) ++* mpfr_y0: Special Functions. (line 199) ++* mpfr_y1: Special Functions. (line 200) ++* mpfr_yn: Special Functions. (line 201) + * mpfr_zero_p: Comparison Functions. + (line 42) +-* mpfr_zeta: Special Functions. (line 171) +-* mpfr_zeta_ui: Special Functions. (line 172) ++* mpfr_zeta: Special Functions. (line 177) ++* mpfr_zeta_ui: Special Functions. (line 178) + * mpfr_z_sub: Basic Arithmetic Functions. +- (line 39) ++ (line 40) +=20 +=20 + =1F + Tag Table: + Node: Top=7F775 + Node: Copying=7F2007 +-Node: Introduction to MPFR=7F3766 +-Node: Installing MPFR=7F5880 +-Node: Reporting Bugs=7F11323 +-Node: MPFR Basics=7F13353 +-Node: Headers and Libraries=7F13669 +-Node: Nomenclature and Types=7F16828 +-Node: MPFR Variable Conventions=7F18874 +-Node: Rounding Modes=7F20418 +-Ref: ternary value=7F21544 +-Node: Floating-Point Values on Special Numbers=7F23526 +-Node: Exceptions=7F26572 +-Node: Memory Handling=7F29749 +-Node: MPFR Interface=7F30894 +-Node: Initialization Functions=7F33008 +-Node: Assignment Functions=7F40318 +-Node: Combined Initialization and Assignment Functions=7F49673 +-Node: Conversion Functions=7F50974 +-Node: Basic Arithmetic Functions=7F60035 +-Node: Comparison Functions=7F69200 +-Node: Special Functions=7F72687 +-Node: Input and Output Functions=7F86672 +-Node: Formatted Output Functions=7F88644 +-Node: Integer Related Functions=7F98431 +-Node: Rounding Related Functions=7F105051 +-Node: Miscellaneous Functions=7F108888 +-Node: Exception Related Functions=7F117568 +-Node: Compatibility with MPF=7F124386 +-Node: Custom Interface=7F127127 +-Node: Internals=7F131526 +-Node: API Compatibility=7F133066 +-Node: Type and Macro Changes=7F134995 +-Node: Added Functions=7F137844 +-Node: Changed Functions=7F141132 +-Node: Removed Functions=7F145545 +-Node: Other Changes=7F145973 +-Node: Contributors=7F147576 +-Node: References=7F150219 +-Node: GNU Free Documentation License=7F151973 +-Node: Concept Index=7F174562 +-Node: Function and Type Index=7F180659 ++Node: Introduction to MPFR=7F3770 ++Node: Installing MPFR=7F5884 ++Node: Reporting Bugs=7F11327 ++Node: MPFR Basics=7F13357 ++Node: Headers and Libraries=7F13673 ++Node: Nomenclature and Types=7F16832 ++Node: MPFR Variable Conventions=7F18894 ++Node: Rounding Modes=7F20438 ++Ref: ternary value=7F21568 ++Node: Floating-Point Values on Special Numbers=7F23554 ++Node: Exceptions=7F26813 ++Node: Memory Handling=7F29990 ++Node: MPFR Interface=7F31135 ++Node: Initialization Functions=7F33249 ++Node: Assignment Functions=7F40559 ++Node: Combined Initialization and Assignment Functions=7F49914 ++Node: Conversion Functions=7F51215 ++Node: Basic Arithmetic Functions=7F60276 ++Node: Comparison Functions=7F69777 ++Node: Special Functions=7F73264 ++Node: Input and Output Functions=7F87862 ++Node: Formatted Output Functions=7F89834 ++Node: Integer Related Functions=7F99621 ++Node: Rounding Related Functions=7F106241 ++Node: Miscellaneous Functions=7F110078 ++Node: Exception Related Functions=7F118758 ++Node: Compatibility with MPF=7F125576 ++Node: Custom Interface=7F128317 ++Node: Internals=7F132716 ++Node: API Compatibility=7F134260 ++Node: Type and Macro Changes=7F136189 ++Node: Added Functions=7F139038 ++Node: Changed Functions=7F142326 ++Node: Removed Functions=7F146739 ++Node: Other Changes=7F147167 ++Node: Contributors=7F148770 ++Node: References=7F151413 ++Node: GNU Free Documentation License=7F153167 ++Node: Concept Index=7F175760 ++Node: Function and Type Index=7F181857 + =1F + End Tag Table +=20 +diff -Naurd mpfr-3.1.3-a/src/lngamma.c mpfr-3.1.3-b/src/lngamma.c +--- mpfr-3.1.3-a/src/lngamma.c 2015-06-19 19:55:10.000000000 +0000 ++++ mpfr-3.1.3-b/src/lngamma.c 2015-07-02 10:49:24.018113593 +0000 +@@ -603,16 +603,17 @@ + mpfr_get_prec (y), mpfr_log_prec, y, inex)); +=20 + /* special cases */ +- if (MPFR_UNLIKELY (MPFR_IS_SINGULAR (x))) ++ if (MPFR_UNLIKELY (MPFR_IS_SINGULAR (x) || ++ (MPFR_IS_NEG (x) && mpfr_integer_p (x)))) + { +- if (MPFR_IS_NAN (x) || MPFR_IS_NEG (x)) ++ if (MPFR_IS_NAN (x)) + { + MPFR_SET_NAN (y); + MPFR_RET_NAN; + } +- else /* lngamma(+Inf) =3D lngamma(+0) =3D +Inf */ ++ else /* lngamma(+/-Inf) =3D lngamma(nonpositive integer) =3D +Inf */ + { +- if (MPFR_IS_ZERO (x)) ++ if (!MPFR_IS_INF (x)) + mpfr_set_divby0 (); + MPFR_SET_INF (y); + MPFR_SET_POS (y); +@@ -620,8 +621,8 @@ + } + } +=20 +- /* if x < 0 and -2k-1 <=3D x <=3D -2k, then lngamma(x) =3D NaN */ +- if (MPFR_IS_NEG (x) && (unit_bit (x) =3D=3D 0 || mpfr_integer_p (x))) ++ /* if -2k-1 < x < -2k <=3D 0, then lngamma(x) =3D NaN */ ++ if (MPFR_IS_NEG (x) && unit_bit (x) =3D=3D 0) + { + MPFR_SET_NAN (y); + MPFR_RET_NAN; +diff -Naurd mpfr-3.1.3-a/src/mpfr.h mpfr-3.1.3-b/src/mpfr.h +--- mpfr-3.1.3-a/src/mpfr.h 2015-06-19 19:55:10.000000000 +0000 ++++ mpfr-3.1.3-b/src/mpfr.h 2015-07-02 10:49:24.038113803 +0000 +@@ -27,7 +27,7 @@ + #define MPFR_VERSION_MAJOR 3 + #define MPFR_VERSION_MINOR 1 + #define MPFR_VERSION_PATCHLEVEL 3 +-#define MPFR_VERSION_STRING "3.1.3" ++#define MPFR_VERSION_STRING "3.1.3-p1" +=20 + /* Macros dealing with MPFR VERSION */ + #define MPFR_VERSION_NUM(a,b,c) (((a) << 16L) | ((b) << 8) | (c)) +diff -Naurd mpfr-3.1.3-a/src/version.c mpfr-3.1.3-b/src/version.c +--- mpfr-3.1.3-a/src/version.c 2015-06-19 19:55:10.000000000 +0000 ++++ mpfr-3.1.3-b/src/version.c 2015-07-02 10:49:24.042113845 +0000 +@@ -25,5 +25,5 @@ + const char * + mpfr_get_version (void) + { +- return "3.1.3"; ++ return "3.1.3-p1"; + } +diff -Naurd mpfr-3.1.3-a/tests/tlngamma.c mpfr-3.1.3-b/tests/tlngamma.c +--- mpfr-3.1.3-a/tests/tlngamma.c 2015-06-19 19:55:10.000000000 +0000 ++++ mpfr-3.1.3-b/tests/tlngamma.c 2015-07-02 10:49:24.018113593 +0000 +@@ -33,7 +33,7 @@ + special (void) + { + mpfr_t x, y; +- int inex; ++ int i, inex; +=20 + mpfr_init (x); + mpfr_init (y); +@@ -46,25 +46,29 @@ + exit (1); + } +=20 +- mpfr_set_inf (x, -1); ++ mpfr_set_inf (x, 1); ++ mpfr_clear_flags (); + mpfr_lngamma (y, x, MPFR_RNDN); +- if (!mpfr_nan_p (y)) ++ if (!mpfr_inf_p (y) || mpfr_sgn (y) < 0 || __gmpfr_flags !=3D 0) + { +- printf ("Error for lngamma(-Inf)\n"); ++ printf ("Error for lngamma(+Inf)\n"); + exit (1); + } +=20 +- mpfr_set_inf (x, 1); ++ mpfr_set_inf (x, -1); ++ mpfr_clear_flags (); + mpfr_lngamma (y, x, MPFR_RNDN); +- if (!mpfr_inf_p (y) || mpfr_sgn (y) < 0) ++ if (!mpfr_inf_p (y) || mpfr_sgn (y) < 0 || __gmpfr_flags !=3D 0) + { +- printf ("Error for lngamma(+Inf)\n"); ++ printf ("Error for lngamma(-Inf)\n"); + exit (1); + } +=20 + mpfr_set_ui (x, 0, MPFR_RNDN); ++ mpfr_clear_flags (); + mpfr_lngamma (y, x, MPFR_RNDN); +- if (!mpfr_inf_p (y) || mpfr_sgn (y) < 0) ++ if (!mpfr_inf_p (y) || mpfr_sgn (y) < 0 || ++ __gmpfr_flags !=3D MPFR_FLAGS_DIVBY0) + { + printf ("Error for lngamma(+0)\n"); + exit (1); +@@ -72,32 +76,58 @@ +=20 + mpfr_set_ui (x, 0, MPFR_RNDN); + mpfr_neg (x, x, MPFR_RNDN); ++ mpfr_clear_flags (); + mpfr_lngamma (y, x, MPFR_RNDN); +- if (!mpfr_nan_p (y)) ++ if (!mpfr_inf_p (y) || mpfr_sgn (y) < 0 || ++ __gmpfr_flags !=3D MPFR_FLAGS_DIVBY0) + { + printf ("Error for lngamma(-0)\n"); + exit (1); + } +=20 + mpfr_set_ui (x, 1, MPFR_RNDN); ++ mpfr_clear_flags (); + mpfr_lngamma (y, x, MPFR_RNDN); +- if (MPFR_IS_NAN (y) || mpfr_cmp_ui (y, 0) || MPFR_IS_NEG (y)) ++ if (mpfr_cmp_ui0 (y, 0) || MPFR_IS_NEG (y)) + { + printf ("Error for lngamma(1)\n"); + exit (1); + } +=20 +- mpfr_set_si (x, -1, MPFR_RNDN); +- mpfr_lngamma (y, x, MPFR_RNDN); +- if (!mpfr_nan_p (y)) ++ for (i =3D 1; i <=3D 5; i++) + { +- printf ("Error for lngamma(-1)\n"); +- exit (1); ++ int c; ++ ++ mpfr_set_si (x, -i, MPFR_RNDN); ++ mpfr_clear_flags (); ++ mpfr_lngamma (y, x, MPFR_RNDN); ++ if (!mpfr_inf_p (y) || mpfr_sgn (y) < 0 || ++ __gmpfr_flags !=3D MPFR_FLAGS_DIVBY0) ++ { ++ printf ("Error for lngamma(-%d)\n", i); ++ exit (1); ++ } ++ if (i & 1) ++ { ++ mpfr_nextabove (x); ++ c =3D '+'; ++ } ++ else ++ { ++ mpfr_nextbelow (x); ++ c =3D '-'; ++ } ++ mpfr_lngamma (y, x, MPFR_RNDN); ++ if (!mpfr_nan_p (y)) ++ { ++ printf ("Error for lngamma(-%d%cepsilon)\n", i, c); ++ exit (1); ++ } + } +=20 + mpfr_set_ui (x, 2, MPFR_RNDN); + mpfr_lngamma (y, x, MPFR_RNDN); +- if (MPFR_IS_NAN (y) || mpfr_cmp_ui (y, 0) || MPFR_IS_NEG (y)) ++ if (mpfr_cmp_ui0 (y, 0) || MPFR_IS_NEG (y)) + { + printf ("Error for lngamma(2)\n"); + exit (1); +@@ -127,7 +157,7 @@ + mpfr_set_str (x, CHECK_X2, 10, MPFR_RNDN); + mpfr_lngamma (y, x, MPFR_RNDN); + mpfr_set_str (x, CHECK_Y2, 10, MPFR_RNDN); +- if (MPFR_IS_NAN (y) || mpfr_cmp (y, x)) ++ if (mpfr_cmp0 (y, x)) + { + printf ("mpfr_lngamma("CHECK_X2") is wrong:\n" + "expected "); +@@ -143,7 +173,7 @@ + mpfr_lngamma (y, x, MPFR_RNDU); + mpfr_set_prec (x, 175); + mpfr_set_str_binary (x, "0.1010001100011101101011001101110010100001000001= 00000111001100000110110000111100100100010101101110010001010101111010011111010= 1010100010011010010000101010111001100011000101111E7"); +- if (MPFR_IS_NAN (y) || mpfr_cmp (x, y)) ++ if (mpfr_cmp0 (x, y)) + { + printf ("Error in mpfr_lngamma (1)\n"); + exit (1); +@@ -155,7 +185,7 @@ + mpfr_lngamma (x, y, MPFR_RNDZ); + mpfr_set_prec (y, 21); + mpfr_set_str_binary (y, "0.111000101000001100101E9"); +- if (MPFR_IS_NAN (x) || mpfr_cmp (x, y)) ++ if (mpfr_cmp0 (x, y)) + { + printf ("Error in mpfr_lngamma (120)\n"); + printf ("Expected "); mpfr_print_binary (y); puts (""); +@@ -169,7 +199,7 @@ + inex =3D mpfr_lngamma (y, x, MPFR_RNDN); + mpfr_set_prec (x, 206); + mpfr_set_str_binary (x, "0.1000011101100000001110001010100110011000111000= 01111000110001001001101100100010110111101010011110111101100000010101001110110= 10000000011100110110101100111000111010011110010000100010111101010001101000110= 101001E13"); +- if (MPFR_IS_NAN (y) || mpfr_cmp (x, y)) ++ if (mpfr_cmp0 (x, y)) + { + printf ("Error in mpfr_lngamma (768)\n"); + exit (1); +@@ -185,7 +215,7 @@ + mpfr_set_str_binary (x, "0.1100E-66"); + mpfr_lngamma (y, x, MPFR_RNDN); + mpfr_set_str_binary (x, "0.1100E6"); +- if (MPFR_IS_NAN (y) || mpfr_cmp (x, y)) ++ if (mpfr_cmp0 (x, y)) + { + printf ("Error for lngamma(0.1100E-66)\n"); + exit (1); +@@ -199,7 +229,7 @@ + mpfr_lngamma (y, x, MPFR_RNDN); + mpfr_set_prec (x, 32); + mpfr_set_str_binary (x, "-0.10001000111011111011000010100010E207"); +- if (MPFR_IS_NAN (y) || mpfr_cmp (x, y)) ++ if (mpfr_cmp0 (x, y)) + { + printf ("Error for lngamma(-2^199+0.5)\n"); + printf ("Got "); +diff -Naurd mpfr-3.1.3-a/PATCHES mpfr-3.1.3-b/PATCHES +--- mpfr-3.1.3-a/PATCHES 2015-07-02 10:50:08.046573308 +0000 ++++ mpfr-3.1.3-b/PATCHES 2015-07-02 10:50:08.126574142 +0000 +@@ -0,0 +1 @@ ++muldiv-2exp-overflow +diff -Naurd mpfr-3.1.3-a/VERSION mpfr-3.1.3-b/VERSION +--- mpfr-3.1.3-a/VERSION 2015-07-02 10:49:24.042113845 +0000 ++++ mpfr-3.1.3-b/VERSION 2015-07-02 10:50:08.126574142 +0000 +@@ -1 +1 @@ +-3.1.3-p1 ++3.1.3-p2 +diff -Naurd mpfr-3.1.3-a/src/div_2si.c mpfr-3.1.3-b/src/div_2si.c +--- mpfr-3.1.3-a/src/div_2si.c 2015-06-19 19:55:10.000000000 +0000 ++++ mpfr-3.1.3-b/src/div_2si.c 2015-07-02 10:50:08.106573933 +0000 +@@ -49,7 +49,7 @@ + rnd_mode =3D MPFR_RNDZ; + return mpfr_underflow (y, rnd_mode, MPFR_SIGN(y)); + } +- else if (MPFR_UNLIKELY(n < 0 && (__gmpfr_emax < MPFR_EMIN_MIN - n || ++ else if (MPFR_UNLIKELY(n <=3D 0 && (__gmpfr_emax < MPFR_EMIN_MIN - n = || + exp > __gmpfr_emax + n)) ) + return mpfr_overflow (y, rnd_mode, MPFR_SIGN(y)); +=20 +diff -Naurd mpfr-3.1.3-a/src/div_2ui.c mpfr-3.1.3-b/src/div_2ui.c +--- mpfr-3.1.3-a/src/div_2ui.c 2015-06-19 19:55:10.000000000 +0000 ++++ mpfr-3.1.3-b/src/div_2ui.c 2015-07-02 10:50:08.106573933 +0000 +@@ -32,7 +32,7 @@ + rnd_mode), + ("y[%Pu]=3D%.*Rg inexact=3D%d", mpfr_get_prec(y), mpfr_log_prec, y, ine= xact)); +=20 +- if (MPFR_UNLIKELY (MPFR_IS_SINGULAR (x))) ++ if (MPFR_UNLIKELY (n =3D=3D 0 || MPFR_IS_SINGULAR (x))) + return mpfr_set (y, x, rnd_mode); + else + { +diff -Naurd mpfr-3.1.3-a/src/mpfr.h mpfr-3.1.3-b/src/mpfr.h +--- mpfr-3.1.3-a/src/mpfr.h 2015-07-02 10:49:24.038113803 +0000 ++++ mpfr-3.1.3-b/src/mpfr.h 2015-07-02 10:50:08.126574142 +0000 +@@ -27,7 +27,7 @@ + #define MPFR_VERSION_MAJOR 3 + #define MPFR_VERSION_MINOR 1 + #define MPFR_VERSION_PATCHLEVEL 3 +-#define MPFR_VERSION_STRING "3.1.3-p1" ++#define MPFR_VERSION_STRING "3.1.3-p2" +=20 + /* Macros dealing with MPFR VERSION */ + #define MPFR_VERSION_NUM(a,b,c) (((a) << 16L) | ((b) << 8) | (c)) +diff -Naurd mpfr-3.1.3-a/src/mul_2si.c mpfr-3.1.3-b/src/mul_2si.c +--- mpfr-3.1.3-a/src/mul_2si.c 2015-06-19 19:55:10.000000000 +0000 ++++ mpfr-3.1.3-b/src/mul_2si.c 2015-07-02 10:50:08.106573933 +0000 +@@ -39,7 +39,7 @@ + { + mpfr_exp_t exp =3D MPFR_GET_EXP (x); + MPFR_SETRAW (inexact, y, x, exp, rnd_mode); +- if (MPFR_UNLIKELY( n > 0 && (__gmpfr_emax < MPFR_EMIN_MIN + n || ++ if (MPFR_UNLIKELY(n >=3D 0 && (__gmpfr_emax < MPFR_EMIN_MIN + n || + exp > __gmpfr_emax - n))) + return mpfr_overflow (y, rnd_mode, MPFR_SIGN(y)); + else if (MPFR_UNLIKELY(n < 0 && (__gmpfr_emin > MPFR_EMAX_MAX + n || +diff -Naurd mpfr-3.1.3-a/src/version.c mpfr-3.1.3-b/src/version.c +--- mpfr-3.1.3-a/src/version.c 2015-07-02 10:49:24.042113845 +0000 ++++ mpfr-3.1.3-b/src/version.c 2015-07-02 10:50:08.126574142 +0000 +@@ -25,5 +25,5 @@ + const char * + mpfr_get_version (void) + { +- return "3.1.3-p1"; ++ return "3.1.3-p2"; + } +diff -Naurd mpfr-3.1.3-a/tests/tmul_2exp.c mpfr-3.1.3-b/tests/tmul_2exp.c +--- mpfr-3.1.3-a/tests/tmul_2exp.c 2015-06-19 19:55:10.000000000 +0000 ++++ mpfr-3.1.3-b/tests/tmul_2exp.c 2015-07-02 10:50:08.106573933 +0000 +@@ -242,6 +242,76 @@ + large (MPFR_EMAX_MAX); + } +=20 ++/* Cases where the function overflows on n =3D 0 when rounding is like ++ away from zero. */ ++static void ++overflow0 (mpfr_exp_t emax) ++{ ++ mpfr_exp_t old_emax; ++ mpfr_t x, y1, y2; ++ int neg, r, op; ++ static char *sop[4] =3D { "mul_2ui", "mul_2si", "div_2ui", "div_2si" }; ++ ++ old_emax =3D mpfr_get_emax (); ++ set_emax (emax); ++ ++ mpfr_init2 (x, 8); ++ mpfr_inits2 (6, y1, y2, (mpfr_ptr) 0); ++ ++ mpfr_set_inf (x, 1); ++ mpfr_nextbelow (x); ++ ++ for (neg =3D 0; neg <=3D 1; neg++) ++ { ++ RND_LOOP (r) ++ { ++ int inex1, inex2; ++ unsigned int flags1, flags2; ++ ++ /* Even if there isn't an overflow (rounding ~ toward zero), ++ the result is the same as the one of an overflow. */ ++ inex1 =3D mpfr_overflow (y1, (mpfr_rnd_t) r, neg ? -1 : 1); ++ flags1 =3D MPFR_FLAGS_INEXACT; ++ if (mpfr_inf_p (y1)) ++ flags1 |=3D MPFR_FLAGS_OVERFLOW; ++ for (op =3D 0; op < 4; op++) ++ { ++ mpfr_clear_flags (); ++ inex2 =3D ++ op =3D=3D 0 ? mpfr_mul_2ui (y2, x, 0, (mpfr_rnd_t) r) : ++ op =3D=3D 1 ? mpfr_mul_2si (y2, x, 0, (mpfr_rnd_t) r) : ++ op =3D=3D 2 ? mpfr_div_2ui (y2, x, 0, (mpfr_rnd_t) r) : ++ op =3D=3D 3 ? mpfr_div_2si (y2, x, 0, (mpfr_rnd_t) r) : ++ (MPFR_ASSERTN (0), 0); ++ flags2 =3D __gmpfr_flags; ++ if (!(mpfr_equal_p (y1, y2) && ++ SAME_SIGN (inex1, inex2) && ++ flags1 =3D=3D flags2)) ++ { ++ printf ("Error in overflow0 for %s, mpfr_%s, emax =3D %" ++ MPFR_EXP_FSPEC "d,\nx =3D ", ++ mpfr_print_rnd_mode ((mpfr_rnd_t) r), sop[op], ++ (mpfr_eexp_t) emax); ++ mpfr_dump (x); ++ printf ("Expected "); ++ mpfr_dump (y1); ++ printf (" with inex =3D %d, flags =3D", inex1); ++ flags_out (flags1); ++ printf ("Got "); ++ mpfr_dump (y2); ++ printf (" with inex =3D %d, flags =3D", inex2); ++ flags_out (flags2); ++ exit (1); ++ } ++ } ++ } ++ mpfr_neg (x, x, MPFR_RNDN); ++ } ++ ++ mpfr_clears (x, y1, y2, (mpfr_ptr) 0); ++ set_emax (old_emax); ++} ++ + int + main (int argc, char *argv[]) + { +@@ -334,6 +404,11 @@ + underflow0 (); + large0 (); +=20 ++ if (mpfr_get_emax () !=3D MPFR_EMAX_MAX) ++ overflow0 (mpfr_get_emax ()); ++ overflow0 (MPFR_EMAX_MAX); ++ overflow0 (-1); ++ + tests_end_mpfr (); + return 0; + } +diff -Naurd mpfr-3.1.3-a/PATCHES mpfr-3.1.3-b/PATCHES +--- mpfr-3.1.3-a/PATCHES 2015-07-17 08:54:48.592799981 +0000 ++++ mpfr-3.1.3-b/PATCHES 2015-07-17 08:54:48.616811495 +0000 +@@ -0,0 +1 @@ ++muldiv-2exp-underflow +diff -Naurd mpfr-3.1.3-a/VERSION mpfr-3.1.3-b/VERSION +--- mpfr-3.1.3-a/VERSION 2015-07-02 10:50:08.126574142 +0000 ++++ mpfr-3.1.3-b/VERSION 2015-07-17 08:54:48.616811495 +0000 +@@ -1 +1 @@ +-3.1.3-p2 ++3.1.3-p3 +diff -Naurd mpfr-3.1.3-a/src/div_2si.c mpfr-3.1.3-b/src/div_2si.c +--- mpfr-3.1.3-a/src/div_2si.c 2015-07-02 10:50:08.106573933 +0000 ++++ mpfr-3.1.3-b/src/div_2si.c 2015-07-17 08:54:48.608807656 +0000 +@@ -45,7 +45,8 @@ + if (rnd_mode =3D=3D MPFR_RNDN && + (__gmpfr_emin > MPFR_EMAX_MAX - (n - 1) || + exp < __gmpfr_emin + (n - 1) || +- (inexact >=3D 0 && mpfr_powerof2_raw (y)))) ++ ((MPFR_IS_NEG (y) ? inexact <=3D 0 : inexact >=3D 0) && ++ mpfr_powerof2_raw (y)))) + rnd_mode =3D MPFR_RNDZ; + return mpfr_underflow (y, rnd_mode, MPFR_SIGN(y)); + } +diff -Naurd mpfr-3.1.3-a/src/div_2ui.c mpfr-3.1.3-b/src/div_2ui.c +--- mpfr-3.1.3-a/src/div_2ui.c 2015-07-02 10:50:08.106573933 +0000 ++++ mpfr-3.1.3-b/src/div_2ui.c 2015-07-17 08:54:48.608807656 +0000 +@@ -44,7 +44,9 @@ + if (MPFR_UNLIKELY (n >=3D diffexp)) /* exp - n <=3D emin - 1 */ + { + if (rnd_mode =3D=3D MPFR_RNDN && +- (n > diffexp || (inexact >=3D 0 && mpfr_powerof2_raw (y)))) ++ (n > diffexp || ++ ((MPFR_IS_NEG (y) ? inexact <=3D 0 : inexact >=3D 0) && ++ mpfr_powerof2_raw (y)))) + rnd_mode =3D MPFR_RNDZ; + return mpfr_underflow (y, rnd_mode, MPFR_SIGN (y)); + } +diff -Naurd mpfr-3.1.3-a/src/mpfr.h mpfr-3.1.3-b/src/mpfr.h +--- mpfr-3.1.3-a/src/mpfr.h 2015-07-02 10:50:08.126574142 +0000 ++++ mpfr-3.1.3-b/src/mpfr.h 2015-07-17 08:54:48.616811495 +0000 +@@ -27,7 +27,7 @@ + #define MPFR_VERSION_MAJOR 3 + #define MPFR_VERSION_MINOR 1 + #define MPFR_VERSION_PATCHLEVEL 3 +-#define MPFR_VERSION_STRING "3.1.3-p2" ++#define MPFR_VERSION_STRING "3.1.3-p3" +=20 + /* Macros dealing with MPFR VERSION */ + #define MPFR_VERSION_NUM(a,b,c) (((a) << 16L) | ((b) << 8) | (c)) +diff -Naurd mpfr-3.1.3-a/src/mul_2si.c mpfr-3.1.3-b/src/mul_2si.c +--- mpfr-3.1.3-a/src/mul_2si.c 2015-07-02 10:50:08.106573933 +0000 ++++ mpfr-3.1.3-b/src/mul_2si.c 2015-07-17 08:54:48.608807656 +0000 +@@ -48,7 +48,8 @@ + if (rnd_mode =3D=3D MPFR_RNDN && + (__gmpfr_emin > MPFR_EMAX_MAX + (n + 1) || + exp < __gmpfr_emin - (n + 1) || +- (inexact >=3D 0 && mpfr_powerof2_raw (y)))) ++ ((MPFR_IS_NEG (y) ? inexact <=3D 0 : inexact >=3D 0) && ++ mpfr_powerof2_raw (y)))) + rnd_mode =3D MPFR_RNDZ; + return mpfr_underflow (y, rnd_mode, MPFR_SIGN(y)); + } +diff -Naurd mpfr-3.1.3-a/src/version.c mpfr-3.1.3-b/src/version.c +--- mpfr-3.1.3-a/src/version.c 2015-07-02 10:50:08.126574142 +0000 ++++ mpfr-3.1.3-b/src/version.c 2015-07-17 08:54:48.616811495 +0000 +@@ -25,5 +25,5 @@ + const char * + mpfr_get_version (void) + { +- return "3.1.3-p2"; ++ return "3.1.3-p3"; + } +diff -Naurd mpfr-3.1.3-a/tests/tmul_2exp.c mpfr-3.1.3-b/tests/tmul_2exp.c +--- mpfr-3.1.3-a/tests/tmul_2exp.c 2015-07-02 10:50:08.106573933 +0000 ++++ mpfr-3.1.3-b/tests/tmul_2exp.c 2015-07-17 08:54:48.608807656 +0000 +@@ -50,77 +50,82 @@ + { + mpfr_t x, y, z1, z2; + mpfr_exp_t emin; +- int i, k; ++ int i, k, s; + int prec; + int rnd; + int div; + int inex1, inex2; + unsigned int flags1, flags2; +=20 +- /* Test mul_2si(x, e - k), div_2si(x, k - e) and div_2ui(x, k - e) +- * with emin =3D e, x =3D 1 + i/16, i in { -1, 0, 1 }, and k =3D 1 to 4, +- * by comparing the result with the one of a simple division. ++ /* Test mul_2si(x, e - k), div_2si(x, k - e) and div_2ui(x, k - e) with ++ * emin =3D e, x =3D s * (1 + i/16), i in { -1, 0, 1 }, s in { -1, 1 }, a= nd ++ * k =3D 1 to 4, by comparing the result with the one of a simple divisio= n. + */ + emin =3D mpfr_get_emin (); + set_emin (e); + mpfr_inits2 (8, x, y, (mpfr_ptr) 0); + for (i =3D 15; i <=3D 17; i++) +- { +- inex1 =3D mpfr_set_ui_2exp (x, i, -4, MPFR_RNDN); +- MPFR_ASSERTN (inex1 =3D=3D 0); +- for (prec =3D 6; prec >=3D 3; prec -=3D 3) +- { +- mpfr_inits2 (prec, z1, z2, (mpfr_ptr) 0); +- RND_LOOP (rnd) +- for (k =3D 1; k <=3D 4; k++) +- { +- /* The following one is assumed to be correct. */ +- inex1 =3D mpfr_mul_2si (y, x, e, MPFR_RNDN); +- MPFR_ASSERTN (inex1 =3D=3D 0); +- inex1 =3D mpfr_set_ui (z1, 1 << k, MPFR_RNDN); +- MPFR_ASSERTN (inex1 =3D=3D 0); +- mpfr_clear_flags (); +- /* Do not use mpfr_div_ui to avoid the optimization +- by mpfr_div_2si. */ +- inex1 =3D mpfr_div (z1, y, z1, (mpfr_rnd_t) rnd); +- flags1 =3D __gmpfr_flags; +- +- for (div =3D 0; div <=3D 2; div++) ++ for (s =3D 1; s >=3D -1; s -=3D 2) ++ { ++ inex1 =3D mpfr_set_si_2exp (x, s * i, -4, MPFR_RNDN); ++ MPFR_ASSERTN (inex1 =3D=3D 0); ++ for (prec =3D 6; prec >=3D 3; prec -=3D 3) ++ { ++ mpfr_inits2 (prec, z1, z2, (mpfr_ptr) 0); ++ RND_LOOP (rnd) ++ for (k =3D 1; k <=3D 4; k++) + { ++ /* The following one is assumed to be correct. */ ++ inex1 =3D mpfr_mul_2si (y, x, e, MPFR_RNDN); ++ MPFR_ASSERTN (inex1 =3D=3D 0); ++ inex1 =3D mpfr_set_ui (z1, 1 << k, MPFR_RNDN); ++ MPFR_ASSERTN (inex1 =3D=3D 0); + mpfr_clear_flags (); +- inex2 =3D div =3D=3D 0 ? +- mpfr_mul_2si (z2, x, e - k, (mpfr_rnd_t) rnd) : div =3D= =3D 1 ? +- mpfr_div_2si (z2, x, k - e, (mpfr_rnd_t) rnd) : +- mpfr_div_2ui (z2, x, k - e, (mpfr_rnd_t) rnd); +- flags2 =3D __gmpfr_flags; +- if (flags1 =3D=3D flags2 && SAME_SIGN (inex1, inex2) && +- mpfr_equal_p (z1, z2)) +- continue; +- printf ("Error in underflow("); +- if (e =3D=3D MPFR_EMIN_MIN) +- printf ("MPFR_EMIN_MIN"); +- else if (e =3D=3D emin) +- printf ("default emin"); +- else if (e >=3D LONG_MIN) +- printf ("%ld", (long) e); +- else +- printf ("=3D LONG_MIN) ++ printf ("%ld", (long) e); ++ else ++ printf (" 0) ++ mpfr_mul_2ui (y2, y2, e2, MPFR_RNDN); ++ else if (e2 < 0) ++ mpfr_div_2ui (y2, y2, -e2, MPFR_RNDN); ++ } ++ if (! (SAME_SIGN (inex1, inex2) && ++ mpfr_equal_p (y1, y2) && ++ flags1 =3D=3D flags2)) ++ { ++ printf ("Error in check1 for %s, red =3D %d, x =3D ", ++ mpfr_print_rnd_mode ((mpfr_rnd_t) r), red); ++ mpfr_dump (x); ++ printf ("Expected y1 =3D "); ++ mpfr_dump (y1); ++ printf ("Got y2 =3D "); ++ mpfr_dump (y2); ++ printf ("Expected inex ~=3D %d, got %d\n", inex1, ine= x2); ++ printf ("Expected flags:"); ++ flags_out (flags1); ++ printf ("Got flags: "); ++ flags_out (flags2); ++ exit (1); ++ } ++ } ++ } ++ mpfr_neg (x, x, MPFR_RNDN); ++ } ++ mpfr_nextabove (x); ++ } ++ ++ mpfr_clears (x, y1, y2, (mpfr_ptr) 0); ++ set_emin (emin); ++ set_emax (emax); ++} ++ + int + main (int argc, char *argv[]) + { + tests_start_mpfr (); +=20 + check_special (); ++ check1 (); +=20 + tests_end_mpfr (); + return 0; --=20 1.9.1 --===============6643568912114311495==--