From 4f2d7949f03e1c198bc888f2d05f421d35c57e21 Mon Sep 17 00:00:00 2001 From: V3n3RiX Date: Mon, 9 Oct 2017 18:53:29 +0100 Subject: reinit the tree, so we can have metadata --- dev-libs/mpfr/Manifest | 23 + dev-libs/mpfr/files/2.4.2/patch01 | 184 +++++ dev-libs/mpfr/files/2.4.2/patch02 | 71 ++ dev-libs/mpfr/files/2.4.2/patch03 | 75 ++ dev-libs/mpfr/files/3.1.3/patch01 | 1117 +++++++++++++++++++++++++++ dev-libs/mpfr/files/3.1.3/patch02 | 161 ++++ dev-libs/mpfr/files/3.1.3/patch03 | 217 ++++++ dev-libs/mpfr/files/3.1.3/patch04 | 204 +++++ dev-libs/mpfr/files/3.1.5/patch01 | 82 ++ dev-libs/mpfr/files/3.1.5/patch02 | 92 +++ dev-libs/mpfr/files/mpfr-3.1.4-cygwin.patch | 39 + dev-libs/mpfr/metadata.xml | 8 + dev-libs/mpfr/mpfr-2.4.2_p3-r1.ebuild | 49 ++ dev-libs/mpfr/mpfr-3.1.3_p4.ebuild | 61 ++ dev-libs/mpfr/mpfr-3.1.4.ebuild | 55 ++ dev-libs/mpfr/mpfr-3.1.5_p2.ebuild | 54 ++ dev-libs/mpfr/mpfr-3.1.6.ebuild | 54 ++ 17 files changed, 2546 insertions(+) create mode 100644 dev-libs/mpfr/Manifest create mode 100644 dev-libs/mpfr/files/2.4.2/patch01 create mode 100644 dev-libs/mpfr/files/2.4.2/patch02 create mode 100644 dev-libs/mpfr/files/2.4.2/patch03 create mode 100644 dev-libs/mpfr/files/3.1.3/patch01 create mode 100644 dev-libs/mpfr/files/3.1.3/patch02 create mode 100644 dev-libs/mpfr/files/3.1.3/patch03 create mode 100644 dev-libs/mpfr/files/3.1.3/patch04 create mode 100644 dev-libs/mpfr/files/3.1.5/patch01 create mode 100644 dev-libs/mpfr/files/3.1.5/patch02 create mode 100644 dev-libs/mpfr/files/mpfr-3.1.4-cygwin.patch create mode 100644 dev-libs/mpfr/metadata.xml create mode 100644 dev-libs/mpfr/mpfr-2.4.2_p3-r1.ebuild create mode 100644 dev-libs/mpfr/mpfr-3.1.3_p4.ebuild create mode 100644 dev-libs/mpfr/mpfr-3.1.4.ebuild create mode 100644 dev-libs/mpfr/mpfr-3.1.5_p2.ebuild create mode 100644 dev-libs/mpfr/mpfr-3.1.6.ebuild (limited to 'dev-libs/mpfr') diff --git a/dev-libs/mpfr/Manifest b/dev-libs/mpfr/Manifest new file mode 100644 index 000000000000..13f55ce8c8b5 --- /dev/null +++ b/dev-libs/mpfr/Manifest @@ -0,0 +1,23 @@ +AUX 2.4.2/patch01 7136 SHA256 ff84b6a8626c79f869d5625d70900e1f99a37f623cb124fdd949dcbcf9f9757e SHA512 6abe563d839379e35c9cac37888d1996fa176453b5852b3bd725b952fbf5c72df898aa6a3be40632e5743264907e208b3b7a9f44a9d9a221b183eefd2c4fb134 WHIRLPOOL bd06a68155ab4ba69a5c6e8da933ad3538f8c7a69a0a266299b8d9d7ffe31f9466430655d0ac93bdab636a7bb8128b4c77761b815440e814a2e0c1a5f9a34a71 +AUX 2.4.2/patch02 2538 SHA256 b61b3ff4abaf93e031d446be201c659275d1b49d1a02ac0a2de45e5fafd47f0b SHA512 481316ce216fd2d84c88d57e24dac66abdfa3e32737752b70211c80523c909fb6742398971ef75e63039803da4dcfd564316df7722b6756d3da2d5e8ad3b1e21 WHIRLPOOL 95f4134d6972a582d66c1a95cc1362fba357a36ebf79c96422cb415838882be7a6c11c11eb2f9d73d68c31a65a3279c9f73eb72cb042b5523a7bedc1a9474cb2 +AUX 2.4.2/patch03 2544 SHA256 999bc180dbeb666cd0301e506f79c7394032bcfb81ca8ded85234d1e5f5563ce SHA512 78ed52e534e11348a49f0eaeef3381484d310c927f1c45fb315ecb0e18eab8cc53a8008a8b76bd14a6c241142ae4291aa3a9d49875e168bfc5c8b3dbf0eda972 WHIRLPOOL 8dda8a6d74eb4bdcd0596d4676ab856331187c6a93c23f8ccce79a74b892f8ed4ce21f90f0cd583a7a333a2292c8ecbc3ff549408fd7c5c43e64f7018ca0bcc7 +AUX 3.1.3/patch01 59693 SHA256 8ea28ea5a69ebbfa529a3b9b2e098d56eebf8f1db9b03e4b2dbbbef138a017c2 SHA512 93f3475dce39226e23dd7e823ff0b9e6e6c05d81b35547f3c591c75c896436e951c8d15d281a8775a36aa0a9caaec4339687bd22391a25550bd0c5a8f0290492 WHIRLPOOL 6f1147737cb620b2838c579d2b4f9c81e3ab17ec0baff25f4e46b267f2f0d06363d89b681777df793b254bd62fbec24e690b44a18720d7dea5e3af475d0dd440 +AUX 3.1.3/patch02 5847 SHA256 a3602e0f68587dc9589d192a444b05b25f3880f602932a953fff6a3f90c0fba5 SHA512 ff1d01141cc99cd1ddabbe032a71d031dec5c3b5e431c369c77b5d9b81699a521f2db91e4ec6c0372e32462dee6c98c806fda7bafa0a0841c33be17b7ba669dc WHIRLPOOL 3a5ffbad1146f1e873ced037c41ef74bb3588666ecd2440f9beb4a8ae0374e0a8607d6c17a93a7947240ff8950b4ab03806dd055cd3b46326bf0a15159d17d84 +AUX 3.1.3/patch03 9577 SHA256 2c1dce889ad21838895dc81ef7759f4a11c87fbece960703920b6abb783d3e5c SHA512 a52f9701e9a47431902cd0f550f0408cafcb1595e749f37f21b3bca9381f375a1864092b1830da14da0a383feaa3e9c2771fe0ca220c40bd9cdab14c955b9404 WHIRLPOOL 095edae48dad8fb8942725625c915475e595cf0ccc5091d5701ae33f0062da96ebe0848e2571e7de6a854eb254bd316e99e4638d31486eb7db800ec3f486bfd6 +AUX 3.1.3/patch04 7194 SHA256 5f0f4598dac63292ab80c18cf6a52fd886be6a12dc91a8387a42818b1ef7e26e SHA512 04ea17e27b1900638deede4746ee9d45d668e35072d30de5757dd0aeae0330062ad8591014e1e6985780a6209f4d68cf412215ff7f8f5247737a0f3192e4b3f6 WHIRLPOOL 5cee228cff4e9fd1711b55fd8fdc3258ff614a58948281db557aaeffb68d03b1db708a95bdff814eb194bbe19e3497edd9659e5c5093245220f819571f343f2f +AUX 3.1.5/patch01 2608 SHA256 dfd62a42a239c427bb44087b4a520edbcd65bae6ad1fbe07303c96ee8696afbd SHA512 572598ccdb536336734f85d3b451abd457a19e90f4f3ca47464c7aaa150092accd561b2354bc19eb2c2513fbb4cc534b34436e20e82a803467ddc61b0deb03f1 WHIRLPOOL d7ad0fea830fd0e4f1345b0633cd768acaeb9ca962a85756763f7f887d3055b641330b35a5e49d71c14db2f57e0b69b787bd5dea25908fb15dc1360d2e6d8417 +AUX 3.1.5/patch02 3447 SHA256 88dfefa6d39c9fd5a26a40d9bbc73df8da93f946c65c06038026261d78d919f5 SHA512 4308c772ed5ab385e583f2110217a140a14844b98692013682c0b603857b5a16284bc89e98e9816c7d341e6c422ba511dd532c7b27a0875f592e580642cfb90f WHIRLPOOL 1b58e26efce2f1c088d04a87626f5f23b1835ea45aee8232495d74f39561de32609700c88593a760ba4fb6a1a2ca1fffbeb08aecfb611c212ba31bafbaf33739 +AUX mpfr-3.1.4-cygwin.patch 1502 SHA256 ec2d87fcfb2fc8f7ea078aa38c309e6eaedc974d70cbe78ca921db06415b9029 SHA512 68cb97c873ce6f25b1cc8f74e7b367941565296d027bb76943b83c46fd7eb304479896ce69f1ae850b5a8ad5796c2a99a5c1949a0215be7cab74669d3352a82b WHIRLPOOL 9a5935bf7cd1aa2d01f16ecbc09e221e48f1d28313d1f040afdd54b319c4147d3b3abe4fa88e60a47605b5b7409249df0a7e65dcb9026d035be68611b05ce98f +DIST mpfr-2.4.2.tar.bz2 1077886 SHA256 c7e75a08a8d49d2082e4caee1591a05d11b9d5627514e678f02d66a124bcf2ba SHA512 c004b3dbf86c04960e4a1f8db37a409a7cc4cb76135e76e98dcc5ad93aaa8deb62334ee13ff84447a7c12a5e8cb57f25c62ac908c24920f1fb1a38d79d4a4c5e WHIRLPOOL d08935d1c5cda48753ddbf98b3b0e87d911279d7fea24e6b210da7e2378f769f3b20babe96859601195d6a9811cf8297d239df53ad2cfa6d0a1bb7bb02ac6a29 +DIST mpfr-3.1.3.tar.xz 1112096 SHA256 6835a08bd992c8257641791e9a6a2b35b02336c8de26d0a8577953747e514a16 SHA512 79846fd82974269aa48152c2b6dbcb2321130dc4d0f0ba2eb94d56619b177add9b2077ebf88b4382c56db19c4215910e5a252f216715c1eee40baa299da42eb4 WHIRLPOOL fba9174551511ffa0fed80d906c5282c095697e79ab9b6fdeb915b9a81f15e20290b3ae6aa7c9ee9ef10fa9c0f973d8a75e1a169aae43f87a28ca433a93c57ce +DIST mpfr-3.1.4.tar.xz 1122152 SHA256 761413b16d749c53e2bfd2b1dfaa3b027b0e793e404b90b5fbaeef60af6517f5 SHA512 4ef61708834efdea6b85258f46f1b25ce1c55b912f44b117d8c3d5e06d8f1177e50f627d9736f3289bd159c5bb10c80e09d1ad9f6f52c4ff43c3496034b04232 WHIRLPOOL 86021e6a60cad98ea42f8ab5bfe990a744ee21fbe89612e083dea43f7e981e84fcbc86de4a90e7a058c569b57b97359a29c9cf5252b960aa91f2247fb96c2743 +DIST mpfr-3.1.5.tar.xz 1126668 SHA256 015fde82b3979fbe5f83501986d328331ba8ddf008c1ff3da3c238f49ca062bc SHA512 3643469b9099b31e41d6ec9158196cd1c30894030c8864ee5b1b1e91b488bccbf7c263c951b03fe9f4ae6f9d29279e157a7dfed0885467d875f107a3d964f032 WHIRLPOOL 9bb135169a2f74bc96c0e36da76391cbc4cf0d131b89d6be6b6b7c859020276dbbeaf8b36a7a81f37490c8bbf7aaaeb4c32955d6ce27720c1492f4ac8b36b08c +DIST mpfr-3.1.6.tar.xz 1133672 SHA256 7a62ac1a04408614fccdc506e4844b10cf0ad2c2b1677097f8f35d3a1344a950 SHA512 746ee74d5026f267f74ab352d850ed30ff627d530aa840c71b24793e44875f8503946bd7399905dea2b2dd5744326254d7889337fe94cfe58d03c4066e9d8054 WHIRLPOOL 63998e125743c71171143485b97ca4f340bb6d154dc7f77ae0f12a7c8f1aebc2f3fbdef3f30ad56134fd53e035d286be6c4276d4086104b14a327286fb01f68a +EBUILD mpfr-2.4.2_p3-r1.ebuild 1438 SHA256 a187342cda4c014c3e5ab827ba09369a99e9331495ffdb38c0b13a1d3a196f24 SHA512 16b7e08f9a4630c5e8468d2fb776b004962a6bcd162ce6ccd7e385eb967e6692962ac3d831eea11a4fba3e15f171664ddaa4c6dd60546426526f17fa54b73192 WHIRLPOOL 0a6901b864739f98ceeb0bad7ab86e0c839190141ec85847f6eef9b5e3702a610952cb22333c7e7166183beb197010d60be379e1285cf14a96cdbe9462eaff1c +EBUILD mpfr-3.1.3_p4.ebuild 1758 SHA256 0fdf39a1fdb56c29cb80c0d3b89a9511677f19d4d5efb549a200762de4c596e8 SHA512 982e8cadc6e7a1b1c006564cfef208ab5a747739d1a24bb9e7e9ab3a2e8ad28c9e7d7f2d38109828eccf5a198a117e9f78680b26981c559addf884457b083403 WHIRLPOOL de68ae1472a3b97deda9952298237e2742e1b1ae11a0c406e3d51c7a4146faaf2872fde22744c712637cd2d71c0f6e184f9dff16f4cf72394912256bd9612fa5 +EBUILD mpfr-3.1.4.ebuild 1655 SHA256 07db0354ab9aedc7b2e913af597d3939c15823b24901d4c9948a04f526e5b6c9 SHA512 6b9f4b4a769e485fa0fccdcb7af0d79c18c9ef22c197c19f11a721dcb039399f6163458520e5d3744bc9d13209eac7c83ba339b9a2d0aa6589740475c828ccdf WHIRLPOOL 09c8e1fe77fd5e19dcc0440d2bbd63ec157a59b0c5a96d579c6483fe882e2476fcee89de9156e20099e4398f70bc76e38a6f9cef855252965f450ea30ebaeca1 +EBUILD mpfr-3.1.5_p2.ebuild 1647 SHA256 91e187d77c8324580ada19ab1b211584a36020dad2d169bd9c1e4787a5d35504 SHA512 8bad48b40f0a22389b68a9618c1e82b2ad73ddadbbfc2e5afc597611deefd4d7899d86ff391b93d7e9f3d77ab966ef5a2a2968a6e93e0075e58ca46e399f26ba WHIRLPOOL 853550dcb973afaf7c45fdd08702279181c43c1b8ae2b27f83f3413bd7543a3c97e901f6dfddde072f66143ad28ce8b73a0f1176b6c5445acef2a69a8862bf44 +EBUILD mpfr-3.1.6.ebuild 1647 SHA256 91e187d77c8324580ada19ab1b211584a36020dad2d169bd9c1e4787a5d35504 SHA512 8bad48b40f0a22389b68a9618c1e82b2ad73ddadbbfc2e5afc597611deefd4d7899d86ff391b93d7e9f3d77ab966ef5a2a2968a6e93e0075e58ca46e399f26ba WHIRLPOOL 853550dcb973afaf7c45fdd08702279181c43c1b8ae2b27f83f3413bd7543a3c97e901f6dfddde072f66143ad28ce8b73a0f1176b6c5445acef2a69a8862bf44 +MISC ChangeLog 6683 SHA256 999dcbf47f5e922dfc25d4d44f4032748214f4386a52926b62e0531c24b81dcf SHA512 cf72eef94a462986e5446cea06666291aa67b28d5e60fdfb3d67162c0a1cffda63c57eba0d207436fa83aa1d90d5456b27915cced251d6475a942541df600536 WHIRLPOOL f33706fedf9e9817de3bcca83e196b1ada072fe4eeea6d02c6da8efb214366b17a40382eeeccaf1b226e18a62e20c8ce6217ca0bf6f5bd399eee38b6385d93ef +MISC ChangeLog-2015 24479 SHA256 a51c8ad4156ba54a7772766b45dc2d31300bef80d9228b8384a24b7e2390c581 SHA512 66bb38a7f454f37ba53702bbae3171d2fa5fc1ac80780a3c9d8e3590a741bcff2510425600048526087c9251a52a4a5c3c11b40590f1b72bffbac658cb64d84c WHIRLPOOL 421ab9f1231c7f045c0a374af1e561767726ac11ea5e7d7564bcf8d2ff6acfdf7453a9587badf563abf25483c8a2c54b7e4c1cdd4ccc16813dac531afb55ce23 +MISC metadata.xml 257 SHA256 fcb691c3299a07a5fe4f936baa5aa146b8aa3cb9491ba88fd12547cb540b02c2 SHA512 fd85d9cf15f6b7db96e4d184e32ae6f1503a5b70cb4cb1ce930ba13a1d5d4c4b24971781e95b7f3f9ead58b31760f84c368bc6fa2a793b4b5baf78259b047ff1 WHIRLPOOL 62b62e3e5489b8983ddd7bfc6017411d5e02f9710763206baa84b826388c8685fe7bdc0bb6a76c029e73ae4c160e9af6c8544406dc70a203c7c3d65d4aa15400 diff --git a/dev-libs/mpfr/files/2.4.2/patch01 b/dev-libs/mpfr/files/2.4.2/patch01 new file mode 100644 index 000000000000..2721517c4281 --- /dev/null +++ b/dev-libs/mpfr/files/2.4.2/patch01 @@ -0,0 +1,184 @@ +diff -Naurd mpfr-2.4.2-a/PATCHES mpfr-2.4.2-b/PATCHES +--- mpfr-2.4.2-a/PATCHES 2009-12-07 13:37:12.000000000 +0000 ++++ mpfr-2.4.2-b/PATCHES 2009-12-07 13:37:12.000000000 +0000 +@@ -0,0 +1 @@ ++sin_cos_underflow +diff -Naurd mpfr-2.4.2-a/VERSION mpfr-2.4.2-b/VERSION +--- mpfr-2.4.2-a/VERSION 2009-11-30 02:43:08.000000000 +0000 ++++ mpfr-2.4.2-b/VERSION 2009-12-07 13:37:12.000000000 +0000 +@@ -1 +1 @@ +-2.4.2 ++2.4.2-p1 +diff -Naurd mpfr-2.4.2-a/mpfr.h mpfr-2.4.2-b/mpfr.h +--- mpfr-2.4.2-a/mpfr.h 2009-11-30 02:43:08.000000000 +0000 ++++ mpfr-2.4.2-b/mpfr.h 2009-12-07 13:37:12.000000000 +0000 +@@ -27,7 +27,7 @@ + #define MPFR_VERSION_MAJOR 2 + #define MPFR_VERSION_MINOR 4 + #define MPFR_VERSION_PATCHLEVEL 2 +-#define MPFR_VERSION_STRING "2.4.2" ++#define MPFR_VERSION_STRING "2.4.2-p1" + + /* Macros dealing with MPFR VERSION */ + #define MPFR_VERSION_NUM(a,b,c) (((a) << 16L) | ((b) << 8) | (c)) +diff -Naurd mpfr-2.4.2-a/sin_cos.c mpfr-2.4.2-b/sin_cos.c +--- mpfr-2.4.2-a/sin_cos.c 2009-11-30 02:43:09.000000000 +0000 ++++ mpfr-2.4.2-b/sin_cos.c 2009-12-07 13:37:12.000000000 +0000 +@@ -82,17 +82,19 @@ + if (y != x) + /* y and x differ, thus we can safely try to compute y first */ + { +- MPFR_FAST_COMPUTE_IF_SMALL_INPUT (y, x, -2 * expx, 2, 0, rnd_mode, +- { inexy = _inexact; +- goto small_input; }); ++ MPFR_FAST_COMPUTE_IF_SMALL_INPUT ( ++ y, x, -2 * expx, 2, 0, rnd_mode, ++ { inexy = _inexact; ++ goto small_input; }); + if (0) + { + small_input: + /* we can go here only if we can round sin(x) */ +- MPFR_FAST_COMPUTE_IF_SMALL_INPUT (z, __gmpfr_one, -2 * expx, +- 1, 0, rnd_mode, +- { inexz = _inexact; +- goto end; }); ++ MPFR_FAST_COMPUTE_IF_SMALL_INPUT ( ++ z, __gmpfr_one, -2 * expx, 1, 0, rnd_mode, ++ { inexz = _inexact; ++ MPFR_SAVE_EXPO_UPDATE_FLAGS (expo, __gmpfr_flags); ++ goto end; }); + } + + /* if we go here, one of the two MPFR_FAST_COMPUTE_IF_SMALL_INPUT +@@ -101,18 +103,19 @@ + else /* y and x are the same variable: try to compute z first, which + necessarily differs */ + { +- MPFR_FAST_COMPUTE_IF_SMALL_INPUT (z, __gmpfr_one, -2 * expx, +- 1, 0, rnd_mode, +- { inexz = _inexact; +- goto small_input2; }); ++ MPFR_FAST_COMPUTE_IF_SMALL_INPUT ( ++ z, __gmpfr_one, -2 * expx, 1, 0, rnd_mode, ++ { inexz = _inexact; ++ goto small_input2; }); + if (0) + { + small_input2: + /* we can go here only if we can round cos(x) */ +- MPFR_FAST_COMPUTE_IF_SMALL_INPUT (y, x, -2 * expx, 2, 0, +- rnd_mode, +- { inexy = _inexact; +- goto end; }); ++ MPFR_FAST_COMPUTE_IF_SMALL_INPUT ( ++ y, x, -2 * expx, 2, 0, rnd_mode, ++ { inexy = _inexact; ++ MPFR_SAVE_EXPO_UPDATE_FLAGS (expo, __gmpfr_flags); ++ goto end; }); + } + } + m += 2 * (-expx); +@@ -207,7 +210,6 @@ + mpfr_clear (xr); + + end: +- /* FIXME: update the underflow flag if need be. */ + MPFR_SAVE_EXPO_FREE (expo); + mpfr_check_range (y, inexy, rnd_mode); + mpfr_check_range (z, inexz, rnd_mode); +diff -Naurd mpfr-2.4.2-a/tests/tsin_cos.c mpfr-2.4.2-b/tests/tsin_cos.c +--- mpfr-2.4.2-a/tests/tsin_cos.c 2009-11-30 02:43:08.000000000 +0000 ++++ mpfr-2.4.2-b/tests/tsin_cos.c 2009-12-07 13:37:12.000000000 +0000 +@@ -382,23 +382,56 @@ + consistency (void) + { + mpfr_t x, s1, s2, c1, c2; ++ mp_exp_t emin, emax; + mp_rnd_t rnd; ++ unsigned int flags_sin, flags_cos, flags, flags_before, flags_ref; ++ int inex_sin, inex_cos, inex, inex_ref; + int i; + ++ emin = mpfr_get_emin (); ++ emax = mpfr_get_emax (); ++ + for (i = 0; i <= 10000; i++) + { + mpfr_init2 (x, MPFR_PREC_MIN + (randlimb () % 8)); + mpfr_inits2 (MPFR_PREC_MIN + (randlimb () % 8), s1, s2, c1, c2, + (mpfr_ptr) 0); +- tests_default_random (x, 256, -5, 50); +- rnd = RND_RAND (); +- mpfr_sin (s1, x, rnd); +- mpfr_cos (c1, x, rnd); +- mpfr_sin_cos (s2, c2, x, rnd); +- if (!(mpfr_equal_p (s1, s2) && mpfr_equal_p (c1, c2))) ++ if (i < 8 * GMP_RND_MAX) + { +- printf ("mpfr_sin_cos and mpfr_sin/mpfr_cos disagree on %s,\nx = ", +- mpfr_print_rnd_mode (rnd)); ++ int j = i / GMP_RND_MAX; ++ if (j & 1) ++ mpfr_set_emin (MPFR_EMIN_MIN); ++ mpfr_set_si (x, (j & 2) ? 1 : -1, GMP_RNDN); ++ mpfr_set_exp (x, mpfr_get_emin ()); ++ rnd = (mpfr_rnd_t) (i % GMP_RND_MAX); ++ flags_before = 0; ++ if (j & 4) ++ mpfr_set_emax (-17); ++ } ++ else ++ { ++ tests_default_random (x, 256, -5, 50); ++ rnd = RND_RAND (); ++ flags_before = (randlimb () & 1) ? ++ (unsigned int) (MPFR_FLAGS_ALL ^ MPFR_FLAGS_ERANGE) : ++ (unsigned int) 0; ++ } ++ __gmpfr_flags = flags_before; ++ inex_sin = mpfr_sin (s1, x, rnd); ++ flags_sin = __gmpfr_flags; ++ __gmpfr_flags = flags_before; ++ inex_cos = mpfr_cos (c1, x, rnd); ++ flags_cos = __gmpfr_flags; ++ __gmpfr_flags = flags_before; ++ inex = !!mpfr_sin_cos (s2, c2, x, rnd); ++ flags = __gmpfr_flags; ++ inex_ref = inex_sin || inex_cos; ++ flags_ref = flags_sin | flags_cos; ++ if (!(mpfr_equal_p (s1, s2) && mpfr_equal_p (c1, c2)) || ++ inex != inex_ref || flags != flags_ref) ++ { ++ printf ("mpfr_sin_cos and mpfr_sin/mpfr_cos disagree on %s," ++ " i = %d\nx = ", mpfr_print_rnd_mode (rnd), i); + mpfr_dump (x); + printf ("s1 = "); + mpfr_dump (s1); +@@ -408,9 +441,16 @@ + mpfr_dump (c1); + printf ("c2 = "); + mpfr_dump (c2); ++ printf ("inex_sin = %d, inex_cos = %d, inex = %d (expected %d)\n", ++ inex_sin, inex_cos, inex, inex_ref); ++ printf ("flags_sin = 0x%x, flags_cos = 0x%x, " ++ "flags = 0x%x (expected 0x%x)\n", ++ flags_sin, flags_cos, flags, flags_ref); + exit (1); + } + mpfr_clears (x, s1, s2, c1, c2, (mpfr_ptr) 0); ++ mpfr_set_emin (emin); ++ mpfr_set_emax (emax); + } + } + +diff -Naurd mpfr-2.4.2-a/version.c mpfr-2.4.2-b/version.c +--- mpfr-2.4.2-a/version.c 2009-11-30 02:43:08.000000000 +0000 ++++ mpfr-2.4.2-b/version.c 2009-12-07 13:37:12.000000000 +0000 +@@ -25,5 +25,5 @@ + const char * + mpfr_get_version (void) + { +- return "2.4.2"; ++ return "2.4.2-p1"; + } diff --git a/dev-libs/mpfr/files/2.4.2/patch02 b/dev-libs/mpfr/files/2.4.2/patch02 new file mode 100644 index 000000000000..fa85d8ef3c57 --- /dev/null +++ b/dev-libs/mpfr/files/2.4.2/patch02 @@ -0,0 +1,71 @@ +diff -Naurd mpfr-2.4.2-a/PATCHES mpfr-2.4.2-b/PATCHES +--- mpfr-2.4.2-a/PATCHES 2009-12-18 12:03:30.000000000 +0000 ++++ mpfr-2.4.2-b/PATCHES 2009-12-18 12:05:19.000000000 +0000 +@@ -0,0 +1 @@ ++longlong.h +diff -Naurd mpfr-2.4.2-a/VERSION mpfr-2.4.2-b/VERSION +--- mpfr-2.4.2-a/VERSION 2009-12-07 13:37:12.000000000 +0000 ++++ mpfr-2.4.2-b/VERSION 2009-12-18 12:05:09.000000000 +0000 +@@ -1 +1 @@ +-2.4.2-p1 ++2.4.2-p2 +diff -Naurd mpfr-2.4.2-a/mpfr-longlong.h mpfr-2.4.2-b/mpfr-longlong.h +--- mpfr-2.4.2-a/mpfr-longlong.h 2009-11-30 02:43:08.000000000 +0000 ++++ mpfr-2.4.2-b/mpfr-longlong.h 2009-12-18 12:04:29.000000000 +0000 +@@ -1011,7 +1011,15 @@ + #endif /* __m88000__ */ + + #if defined (__mips) && W_TYPE_SIZE == 32 +-#if __GNUC__ > 2 || __GNUC_MINOR__ >= 7 ++#if (__GNUC__ >= 5) || (__GNUC__ >= 4 && __GNUC_MINOR__ >= 4) ++#define umul_ppmm(w1, w0, u, v) \ ++ do { \ ++ UDItype _r; \ ++ _r = (UDItype) u * v; \ ++ (w1) = _r >> 32; \ ++ (w0) = (USItype) _r; \ ++ } while (0) ++#elif __GNUC__ > 2 || __GNUC_MINOR__ >= 7 + #define umul_ppmm(w1, w0, u, v) \ + __asm__ ("multu %2,%3" : "=l" (w0), "=h" (w1) : "d" (u), "d" (v)) + #else +@@ -1024,7 +1032,16 @@ + #endif /* __mips */ + + #if (defined (__mips) && __mips >= 3) && W_TYPE_SIZE == 64 +-#if __GNUC__ > 2 || __GNUC_MINOR__ >= 7 ++#if (__GNUC__ >= 5) || (__GNUC__ >= 4 && __GNUC_MINOR__ >= 4) ++typedef unsigned int UTItype __attribute__ ((mode (TI))); ++#define umul_ppmm(w1, w0, u, v) \ ++ do { \ ++ UTItype _r; \ ++ _r = (UTItype) u * v; \ ++ (w1) = _r >> 64; \ ++ (w0) = (UDItype) _r; \ ++ } while (0) ++#elif __GNUC__ > 2 || __GNUC_MINOR__ >= 7 + #define umul_ppmm(w1, w0, u, v) \ + __asm__ ("dmultu %2,%3" : "=l" (w0), "=h" (w1) : "d" (u), "d" (v)) + #else +diff -Naurd mpfr-2.4.2-a/mpfr.h mpfr-2.4.2-b/mpfr.h +--- mpfr-2.4.2-a/mpfr.h 2009-12-07 13:37:12.000000000 +0000 ++++ mpfr-2.4.2-b/mpfr.h 2009-12-18 12:05:09.000000000 +0000 +@@ -27,7 +27,7 @@ + #define MPFR_VERSION_MAJOR 2 + #define MPFR_VERSION_MINOR 4 + #define MPFR_VERSION_PATCHLEVEL 2 +-#define MPFR_VERSION_STRING "2.4.2-p1" ++#define MPFR_VERSION_STRING "2.4.2-p2" + + /* Macros dealing with MPFR VERSION */ + #define MPFR_VERSION_NUM(a,b,c) (((a) << 16L) | ((b) << 8) | (c)) +diff -Naurd mpfr-2.4.2-a/version.c mpfr-2.4.2-b/version.c +--- mpfr-2.4.2-a/version.c 2009-12-07 13:37:12.000000000 +0000 ++++ mpfr-2.4.2-b/version.c 2009-12-18 12:05:09.000000000 +0000 +@@ -25,5 +25,5 @@ + const char * + mpfr_get_version (void) + { +- return "2.4.2-p1"; ++ return "2.4.2-p2"; + } diff --git a/dev-libs/mpfr/files/2.4.2/patch03 b/dev-libs/mpfr/files/2.4.2/patch03 new file mode 100644 index 000000000000..3ce4952f2f38 --- /dev/null +++ b/dev-libs/mpfr/files/2.4.2/patch03 @@ -0,0 +1,75 @@ +diff -Naurd mpfr-2.4.2-a/PATCHES mpfr-2.4.2-b/PATCHES +--- mpfr-2.4.2-a/PATCHES 2010-01-11 15:27:18.000000000 +0000 ++++ mpfr-2.4.2-b/PATCHES 2010-01-11 15:30:31.000000000 +0000 +@@ -0,0 +1 @@ ++gmp5 +diff -Naurd mpfr-2.4.2-a/VERSION mpfr-2.4.2-b/VERSION +--- mpfr-2.4.2-a/VERSION 2009-12-18 12:05:09.000000000 +0000 ++++ mpfr-2.4.2-b/VERSION 2010-01-11 15:29:40.000000000 +0000 +@@ -1 +1 @@ +-2.4.2-p2 ++2.4.2-p3 +diff -Naurd mpfr-2.4.2-a/configure mpfr-2.4.2-b/configure +--- mpfr-2.4.2-a/configure 2009-11-30 02:44:35.000000000 +0000 ++++ mpfr-2.4.2-b/configure 2010-01-11 15:28:56.000000000 +0000 +@@ -20449,6 +20449,9 @@ + main () + { + ++#ifndef BITS_PER_MP_LIMB ++#define BITS_PER_MP_LIMB GMP_LIMB_BITS ++#endif + return BITS_PER_MP_LIMB == BYTES_PER_MP_LIMB * CHAR_BIT + && sizeof(mp_limb_t) == BYTES_PER_MP_LIMB ? 0 : 1; + +diff -Naurd mpfr-2.4.2-a/configure.in mpfr-2.4.2-b/configure.in +--- mpfr-2.4.2-a/configure.in 2009-11-30 02:43:08.000000000 +0000 ++++ mpfr-2.4.2-b/configure.in 2009-11-30 02:43:08.000000000 +0000 +@@ -424,6 +424,9 @@ + #include "gmp.h" + #include "gmp-impl.h" + ]], [[ ++#ifndef BITS_PER_MP_LIMB ++#define BITS_PER_MP_LIMB GMP_LIMB_BITS ++#endif + return BITS_PER_MP_LIMB == BYTES_PER_MP_LIMB * CHAR_BIT + && sizeof(mp_limb_t) == BYTES_PER_MP_LIMB ? 0 : 1; + ]])], [AC_MSG_RESULT(yes)], [ +diff -Naurd mpfr-2.4.2-a/mpfr-impl.h mpfr-2.4.2-b/mpfr-impl.h +--- mpfr-2.4.2-a/mpfr-impl.h 2009-11-30 02:43:08.000000000 +0000 ++++ mpfr-2.4.2-b/mpfr-impl.h 2010-01-11 15:28:01.000000000 +0000 +@@ -65,6 +65,12 @@ + # ifndef __GMP_IMPL_H__ + # include "gmp-impl.h" + # endif ++# ifndef BITS_PER_MP_LIMB ++# define BITS_PER_MP_LIMB GMP_LIMB_BITS ++# endif ++#ifndef mpn_sqr_n ++# define mpn_sqr_n mpn_sqr ++#endif + # ifdef MPFR_NEED_LONGLONG_H + # include "longlong.h" + # endif +diff -Naurd mpfr-2.4.2-a/mpfr.h mpfr-2.4.2-b/mpfr.h +--- mpfr-2.4.2-a/mpfr.h 2009-12-18 12:05:09.000000000 +0000 ++++ mpfr-2.4.2-b/mpfr.h 2010-01-11 15:29:40.000000000 +0000 +@@ -27,7 +27,7 @@ + #define MPFR_VERSION_MAJOR 2 + #define MPFR_VERSION_MINOR 4 + #define MPFR_VERSION_PATCHLEVEL 2 +-#define MPFR_VERSION_STRING "2.4.2-p2" ++#define MPFR_VERSION_STRING "2.4.2-p3" + + /* Macros dealing with MPFR VERSION */ + #define MPFR_VERSION_NUM(a,b,c) (((a) << 16L) | ((b) << 8) | (c)) +diff -Naurd mpfr-2.4.2-a/version.c mpfr-2.4.2-b/version.c +--- mpfr-2.4.2-a/version.c 2009-12-18 12:05:09.000000000 +0000 ++++ mpfr-2.4.2-b/version.c 2010-01-11 15:29:40.000000000 +0000 +@@ -25,5 +25,5 @@ + const char * + mpfr_get_version (void) + { +- return "2.4.2-p2"; ++ return "2.4.2-p3"; + } diff --git a/dev-libs/mpfr/files/3.1.3/patch01 b/dev-libs/mpfr/files/3.1.3/patch01 new file mode 100644 index 000000000000..d7e1cbf1e423 --- /dev/null +++ b/dev-libs/mpfr/files/3.1.3/patch01 @@ -0,0 +1,1117 @@ +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 +-@minus{}0), the behavior is specified in the description of the MPFR function. ++(resp.@: below), if possible. If the limit is not defined (e.g., ++@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). + + 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 ++@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. + +@@ -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. + + @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 +-@var{rnd}. For types having no signed zero, it is considered unsigned ++@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 = (+0) and (@minus{}0) + 0 = (@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 implementation +@@ -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 +-@var{rnd}. For types having no signed zero, it is considered unsigned ++@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 = (+0), (@minus{}0) @minus{} 0 = (@minus{}0), + 0 @minus{} (+0) = (@minus{}0) and 0 @minus{} (@minus{}0) = (+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 + +@@ -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{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_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 @var{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 +-@minus{}0, to be consistent with the IEEE 754 standard). ++rounded in the direction @var{rnd}. Set @var{rop} to @minus{}0 if ++@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 + + @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{op}} +-rounded in the direction @var{rnd}. Set @var{rop} to +Inf if @var{op} is +-@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 ++@pom{}0, +0 if @var{op} is +Inf, and NaN if @var{op} is negative. Warning! ++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 + + @deftypefun int mpfr_cbrt (mpfr_t @var{rop}, mpfr_t @var{op}, mpfr_rnd_t @var{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 + +@@ -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{op}, + rounded in the direction @var{rnd}. +-When @math{@minus{}2@var{k}@minus{}1 @le{} @var{op} @le{} @minus{}2@var{k}}, +-@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 +Inf, ++following the general rules on special values. ++When @math{@minus{}2@var{k}@minus{}1 < @var{op} < @minus{}2@var{k}}, ++@var{k} being a nonnegative integer, set @var{rop} to NaN@. + See also @code{mpfr_lgamma}. + @end deftypefun + +@@ -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 +-@var{rop} to +Inf. 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 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 +Inf. ++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 zero. + @end deftypefun + + @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 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. + @end deftypefun + + @deftypefun int mpfr_agm (mpfr_t @var{rop}, mpfr_t @var{op1}, mpfr_t @var{op2}, 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. + + 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 + *********************** + +-The GNU MPFR library (or MPFR for short) is "free"; this means that ++The GNU MPFR library (or MPFR for short) is “free”; this means 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 + ========================== + +-A "floating-point number", or "float" for short, is an arbitrary ++A “floating-point number”, or “float” for short, is an arbitrary + precision significand (also called mantissa) with a limited precision + exponent. The C data type for such objects is ‘mpfr_t’ (internally + defined as a one-element array of a structure, and ‘mpfr_ptr’ 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. + +-The "precision" is the number of bits used to represent the significand ++The “precision” is the number of bits used to represent the significand + of a floating-point number; the corresponding C data type is + ‘mpfr_prec_t’. The precision can be any integer between ‘MPFR_PREC_MIN’ + and ‘MPFR_PREC_MAX’. In the current implementation, ‘MPFR_PREC_MIN’ is +@@ -446,7 +446,7 @@ + may abort, crash or have undefined behavior (depending on your C + implementation). + +-The "rounding mode" specifies the way to round the result of a ++The “rounding mode” specifies the way to round the result of a + floating-point operation, in case the exact result can not be + represented exactly in the destination significand; the corresponding C + data type is ‘mpfr_rnd_t’. +@@ -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)=2 with a precision +-of two bits, and not to (11.0)=3. This rule avoids the "drift" ++of two bits, and not to (11.0)=3. This rule avoids the “drift” + phenomenon mentioned by Knuth in volume 2 of The Art of Computer + Programming (Section 4.2.2). + + 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 ‘int’, called the +-"ternary value". The value stored in the destination variable is ++“ternary value”. The value stored in the destination variable 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. −0), one + considers the limit when the corresponding argument approaches 0 from +-above (resp. below). If the limit is not defined (e.g., ‘mpfr_log’ on +-−0), the behavior is specified in the description of the MPFR function. ++above (resp. below), if possible. If the limit is not defined (e.g., ++‘mpfr_sqrt’ and ‘mpfr_log’ on −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., ‘mpfr_log’ on ±0 gives −Inf). + + 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. −0); for +-example, ‘mpfr_sin’ on +0 gives +0. In the other cases, the sign is +-specified in the description of the MPFR function; for example +-‘mpfr_max’ on −0 and +0 gives +0. ++example, ‘mpfr_sin’ on −0 gives −0 and ‘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 ‘mpfr_max’ on −0 and +0 ++gives +0. + + When the input point is not in the closure of the domain of the + function, the result is NaN. Example: ‘mpfr_sqrt’ on −17 gives NaN. +@@ -590,8 +593,8 @@ + numbers; such a case is always explicitly specified in *note MPFR + Interface::. Example: ‘mpfr_hypot’ on (NaN,0) gives NaN, but + ‘mpfr_hypot’ on (NaN,+Inf) gives +Inf (as specified in *note Special +-Functions::), since for any finite input X, ‘mpfr_hypot’ on (X,+Inf) +-gives +Inf. ++Functions::), since for any finite or infinite input X, ‘mpfr_hypot’ on ++(X,+Inf) gives +Inf. + +  + 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 = ++ 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 = + (+0) and (−0) + 0 = (−0)). The ‘mpfr_add_d’ function assumes that + the radix of the ‘double’ 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) − 0 = ++ 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 = + (+0), (−0) − 0 = (−0), 0 − (+0) = (−0) and 0 − (−0) = (+0)). The + same restrictions than for ‘mpfr_add_d’ apply to ‘mpfr_d_sub’ and + ‘mpfr_sub_d’. +@@ -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 ‘mpfr_add_d’ apply to + ‘mpfr_mul_d’. + +@@ -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 ‘mpfr_add_d’ apply to ‘mpfr_d_div’ and + ‘mpfr_div_d’. + + -- 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 −0 if OP is −0, 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 −0 if OP is −0, to be consistent with the IEEE 754 standard. ++ Set ROP to NaN if OP is negative. + + -- 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 ±0, +0 if OP is +Inf, and +- NaN if OP is negative. ++ NaN if OP is negative. Warning! Therefore the result on −0 is ++ different from the one of the rSqrt function recommended by the ++ IEEE 754-2008 standard (Section 9.2.1), which is −Inf instead of ++ +Inf. + + -- 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 −Inf if OP +- is −0 (i.e., the sign of the zero has no influence on the result). ++ 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 −Inf if OP is ±0 (i.e., the ++ sign of the zero has no influence on the result). + + -- 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 @@ + + -- 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 −2K−1 <= OP <= −2K, K being a +- non-negative integer, ROP is set to NaN. See also ‘mpfr_lgamma’. ++ 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 −2K−1 < OP < −2K, K being a nonnegative integer, set ++ ROP to NaN. See also ‘mpfr_lgamma’. + + -- 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 + −1) 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, −Inf or a negative integer, *SIGNP is undefined, +- and when OP is ±0, *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, −Inf or a negative integer, *SIGNP is undefined, and when ++ OP is ±0, *SIGNP is the sign of the zero. + + -- 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. + + -- 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. + + -- 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 + ============== + +-A "limb" means the part of a multi-precision number that fits in a ++A “limb” means the part of a multi-precision number that fits in a + single word. Usually a limb contains 32 or 64 bits. The C data type + for a limb is ‘mp_limb_t’. + +@@ -3140,7 +3158,7 @@ + 0. PREAMBLE + + 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 “free” 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: + + * 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) + * ‘mpfr_prec_t’: Nomenclature and Types. +@@ -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 @@ + * ‘mpfr_rnd_t’: Nomenclature and Types. + (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) + * ‘mpfr_t’: Nomenclature and Types. + (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) + + +  + Tag Table: + Node: Top775 + Node: Copying2007 +-Node: Introduction to MPFR3766 +-Node: Installing MPFR5880 +-Node: Reporting Bugs11323 +-Node: MPFR Basics13353 +-Node: Headers and Libraries13669 +-Node: Nomenclature and Types16828 +-Node: MPFR Variable Conventions18874 +-Node: Rounding Modes20418 +-Ref: ternary value21544 +-Node: Floating-Point Values on Special Numbers23526 +-Node: Exceptions26572 +-Node: Memory Handling29749 +-Node: MPFR Interface30894 +-Node: Initialization Functions33008 +-Node: Assignment Functions40318 +-Node: Combined Initialization and Assignment Functions49673 +-Node: Conversion Functions50974 +-Node: Basic Arithmetic Functions60035 +-Node: Comparison Functions69200 +-Node: Special Functions72687 +-Node: Input and Output Functions86672 +-Node: Formatted Output Functions88644 +-Node: Integer Related Functions98431 +-Node: Rounding Related Functions105051 +-Node: Miscellaneous Functions108888 +-Node: Exception Related Functions117568 +-Node: Compatibility with MPF124386 +-Node: Custom Interface127127 +-Node: Internals131526 +-Node: API Compatibility133066 +-Node: Type and Macro Changes134995 +-Node: Added Functions137844 +-Node: Changed Functions141132 +-Node: Removed Functions145545 +-Node: Other Changes145973 +-Node: Contributors147576 +-Node: References150219 +-Node: GNU Free Documentation License151973 +-Node: Concept Index174562 +-Node: Function and Type Index180659 ++Node: Introduction to MPFR3770 ++Node: Installing MPFR5884 ++Node: Reporting Bugs11327 ++Node: MPFR Basics13357 ++Node: Headers and Libraries13673 ++Node: Nomenclature and Types16832 ++Node: MPFR Variable Conventions18894 ++Node: Rounding Modes20438 ++Ref: ternary value21568 ++Node: Floating-Point Values on Special Numbers23554 ++Node: Exceptions26813 ++Node: Memory Handling29990 ++Node: MPFR Interface31135 ++Node: Initialization Functions33249 ++Node: Assignment Functions40559 ++Node: Combined Initialization and Assignment Functions49914 ++Node: Conversion Functions51215 ++Node: Basic Arithmetic Functions60276 ++Node: Comparison Functions69777 ++Node: Special Functions73264 ++Node: Input and Output Functions87862 ++Node: Formatted Output Functions89834 ++Node: Integer Related Functions99621 ++Node: Rounding Related Functions106241 ++Node: Miscellaneous Functions110078 ++Node: Exception Related Functions118758 ++Node: Compatibility with MPF125576 ++Node: Custom Interface128317 ++Node: Internals132716 ++Node: API Compatibility134260 ++Node: Type and Macro Changes136189 ++Node: Added Functions139038 ++Node: Changed Functions142326 ++Node: Removed Functions146739 ++Node: Other Changes147167 ++Node: Contributors148770 ++Node: References151413 ++Node: GNU Free Documentation License153167 ++Node: Concept Index175760 ++Node: Function and Type Index181857 +  + End Tag Table + +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)); + + /* 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) = lngamma(+0) = +Inf */ ++ else /* lngamma(+/-Inf) = lngamma(nonpositive integer) = +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 @@ + } + } + +- /* if x < 0 and -2k-1 <= x <= -2k, then lngamma(x) = NaN */ +- if (MPFR_IS_NEG (x) && (unit_bit (x) == 0 || mpfr_integer_p (x))) ++ /* if -2k-1 < x < -2k <= 0, then lngamma(x) = NaN */ ++ if (MPFR_IS_NEG (x) && unit_bit (x) == 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" + + /* 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; + + mpfr_init (x); + mpfr_init (y); +@@ -46,25 +46,29 @@ + exit (1); + } + +- 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 != 0) + { +- printf ("Error for lngamma(-Inf)\n"); ++ printf ("Error for lngamma(+Inf)\n"); + exit (1); + } + +- 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 != 0) + { +- printf ("Error for lngamma(+Inf)\n"); ++ printf ("Error for lngamma(-Inf)\n"); + exit (1); + } + + 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 != MPFR_FLAGS_DIVBY0) + { + printf ("Error for lngamma(+0)\n"); + exit (1); +@@ -72,32 +76,58 @@ + + 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 != MPFR_FLAGS_DIVBY0) + { + printf ("Error for lngamma(-0)\n"); + exit (1); + } + + 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); + } + +- mpfr_set_si (x, -1, MPFR_RNDN); +- mpfr_lngamma (y, x, MPFR_RNDN); +- if (!mpfr_nan_p (y)) ++ for (i = 1; i <= 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 != MPFR_FLAGS_DIVBY0) ++ { ++ printf ("Error for lngamma(-%d)\n", i); ++ exit (1); ++ } ++ if (i & 1) ++ { ++ mpfr_nextabove (x); ++ c = '+'; ++ } ++ else ++ { ++ mpfr_nextbelow (x); ++ c = '-'; ++ } ++ mpfr_lngamma (y, x, MPFR_RNDN); ++ if (!mpfr_nan_p (y)) ++ { ++ printf ("Error for lngamma(-%d%cepsilon)\n", i, c); ++ exit (1); ++ } + } + + 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.1010001100011101101011001101110010100001000001000001110011000001101100001111001001000101011011100100010101011110100111110101010100010011010010000101010111001100011000101111E7"); +- 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 = mpfr_lngamma (y, x, MPFR_RNDN); + mpfr_set_prec (x, 206); + mpfr_set_str_binary (x, "0.10000111011000000011100010101001100110001110000111100011000100100110110010001011011110101001111011110110000001010100111011010000000011100110110101100111000111010011110010000100010111101010001101000110101001E13"); +- 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 --git a/dev-libs/mpfr/files/3.1.3/patch02 b/dev-libs/mpfr/files/3.1.3/patch02 new file mode 100644 index 000000000000..df711fda21e5 --- /dev/null +++ b/dev-libs/mpfr/files/3.1.3/patch02 @@ -0,0 +1,161 @@ +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 = 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 <= 0 && (__gmpfr_emax < MPFR_EMIN_MIN - n || + exp > __gmpfr_emax + n)) ) + return mpfr_overflow (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-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]=%.*Rg inexact=%d", mpfr_get_prec(y), mpfr_log_prec, y, inexact)); + +- if (MPFR_UNLIKELY (MPFR_IS_SINGULAR (x))) ++ if (MPFR_UNLIKELY (n == 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" + + /* 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 = 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 >= 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); + } + ++/* Cases where the function overflows on n = 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] = { "mul_2ui", "mul_2si", "div_2ui", "div_2si" }; ++ ++ old_emax = 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 = 0; neg <= 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 = mpfr_overflow (y1, (mpfr_rnd_t) r, neg ? -1 : 1); ++ flags1 = MPFR_FLAGS_INEXACT; ++ if (mpfr_inf_p (y1)) ++ flags1 |= MPFR_FLAGS_OVERFLOW; ++ for (op = 0; op < 4; op++) ++ { ++ mpfr_clear_flags (); ++ inex2 = ++ op == 0 ? mpfr_mul_2ui (y2, x, 0, (mpfr_rnd_t) r) : ++ op == 1 ? mpfr_mul_2si (y2, x, 0, (mpfr_rnd_t) r) : ++ op == 2 ? mpfr_div_2ui (y2, x, 0, (mpfr_rnd_t) r) : ++ op == 3 ? mpfr_div_2si (y2, x, 0, (mpfr_rnd_t) r) : ++ (MPFR_ASSERTN (0), 0); ++ flags2 = __gmpfr_flags; ++ if (!(mpfr_equal_p (y1, y2) && ++ SAME_SIGN (inex1, inex2) && ++ flags1 == flags2)) ++ { ++ printf ("Error in overflow0 for %s, mpfr_%s, emax = %" ++ MPFR_EXP_FSPEC "d,\nx = ", ++ 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 = %d, flags =", inex1); ++ flags_out (flags1); ++ printf ("Got "); ++ mpfr_dump (y2); ++ printf (" with inex = %d, flags =", 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 (); + ++ if (mpfr_get_emax () != MPFR_EMAX_MAX) ++ overflow0 (mpfr_get_emax ()); ++ overflow0 (MPFR_EMAX_MAX); ++ overflow0 (-1); ++ + tests_end_mpfr (); + return 0; + } diff --git a/dev-libs/mpfr/files/3.1.3/patch03 b/dev-libs/mpfr/files/3.1.3/patch03 new file mode 100644 index 000000000000..c7be09f4aaf7 --- /dev/null +++ b/dev-libs/mpfr/files/3.1.3/patch03 @@ -0,0 +1,217 @@ +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 == MPFR_RNDN && + (__gmpfr_emin > MPFR_EMAX_MAX - (n - 1) || + exp < __gmpfr_emin + (n - 1) || +- (inexact >= 0 && mpfr_powerof2_raw (y)))) ++ ((MPFR_IS_NEG (y) ? inexact <= 0 : inexact >= 0) && ++ mpfr_powerof2_raw (y)))) + rnd_mode = 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 >= diffexp)) /* exp - n <= emin - 1 */ + { + if (rnd_mode == MPFR_RNDN && +- (n > diffexp || (inexact >= 0 && mpfr_powerof2_raw (y)))) ++ (n > diffexp || ++ ((MPFR_IS_NEG (y) ? inexact <= 0 : inexact >= 0) && ++ mpfr_powerof2_raw (y)))) + rnd_mode = 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" + + /* 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 == MPFR_RNDN && + (__gmpfr_emin > MPFR_EMAX_MAX + (n + 1) || + exp < __gmpfr_emin - (n + 1) || +- (inexact >= 0 && mpfr_powerof2_raw (y)))) ++ ((MPFR_IS_NEG (y) ? inexact <= 0 : inexact >= 0) && ++ mpfr_powerof2_raw (y)))) + rnd_mode = 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; + +- /* Test mul_2si(x, e - k), div_2si(x, k - e) and div_2ui(x, k - e) +- * with emin = e, x = 1 + i/16, i in { -1, 0, 1 }, and k = 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 = e, x = s * (1 + i/16), i in { -1, 0, 1 }, s in { -1, 1 }, and ++ * k = 1 to 4, by comparing the result with the one of a simple division. + */ + emin = mpfr_get_emin (); + set_emin (e); + mpfr_inits2 (8, x, y, (mpfr_ptr) 0); + for (i = 15; i <= 17; i++) +- { +- inex1 = mpfr_set_ui_2exp (x, i, -4, MPFR_RNDN); +- MPFR_ASSERTN (inex1 == 0); +- for (prec = 6; prec >= 3; prec -= 3) +- { +- mpfr_inits2 (prec, z1, z2, (mpfr_ptr) 0); +- RND_LOOP (rnd) +- for (k = 1; k <= 4; k++) +- { +- /* The following one is assumed to be correct. */ +- inex1 = mpfr_mul_2si (y, x, e, MPFR_RNDN); +- MPFR_ASSERTN (inex1 == 0); +- inex1 = mpfr_set_ui (z1, 1 << k, MPFR_RNDN); +- MPFR_ASSERTN (inex1 == 0); +- mpfr_clear_flags (); +- /* Do not use mpfr_div_ui to avoid the optimization +- by mpfr_div_2si. */ +- inex1 = mpfr_div (z1, y, z1, (mpfr_rnd_t) rnd); +- flags1 = __gmpfr_flags; +- +- for (div = 0; div <= 2; div++) ++ for (s = 1; s >= -1; s -= 2) ++ { ++ inex1 = mpfr_set_si_2exp (x, s * i, -4, MPFR_RNDN); ++ MPFR_ASSERTN (inex1 == 0); ++ for (prec = 6; prec >= 3; prec -= 3) ++ { ++ mpfr_inits2 (prec, z1, z2, (mpfr_ptr) 0); ++ RND_LOOP (rnd) ++ for (k = 1; k <= 4; k++) + { ++ /* The following one is assumed to be correct. */ ++ inex1 = mpfr_mul_2si (y, x, e, MPFR_RNDN); ++ MPFR_ASSERTN (inex1 == 0); ++ inex1 = mpfr_set_ui (z1, 1 << k, MPFR_RNDN); ++ MPFR_ASSERTN (inex1 == 0); + mpfr_clear_flags (); +- inex2 = div == 0 ? +- mpfr_mul_2si (z2, x, e - k, (mpfr_rnd_t) rnd) : div == 1 ? +- mpfr_div_2si (z2, x, k - e, (mpfr_rnd_t) rnd) : +- mpfr_div_2ui (z2, x, k - e, (mpfr_rnd_t) rnd); +- flags2 = __gmpfr_flags; +- if (flags1 == flags2 && SAME_SIGN (inex1, inex2) && +- mpfr_equal_p (z1, z2)) +- continue; +- printf ("Error in underflow("); +- if (e == MPFR_EMIN_MIN) +- printf ("MPFR_EMIN_MIN"); +- else if (e == emin) +- printf ("default emin"); +- else if (e >= LONG_MIN) +- printf ("%ld", (long) e); +- else +- printf ("= LONG_MIN) ++ printf ("%ld", (long) e); ++ else ++ printf ("mant, with + equality in case exact is non-zero. */ + +- /* test if rounding is possible, and if so exit the loop */ +- if (exact || mpfr_can_round_raw (result, ysize, +- (pstr->negative) ? -1 : 1, +- ysize_bits - err - 1, +- MPFR_RNDN, rnd, MPFR_PREC(x))) ++ /* test if rounding is possible, and if so exit the loop. ++ Note: we also need to be able to determine the correct ternary value, ++ thus we use the MPFR_PREC(x) + (rnd == MPFR_RNDN) trick. ++ For example if result = xxx...xxx111...111 and rnd = RNDN, ++ then we know the correct rounding is xxx...xx(x+1), but we cannot know ++ the correct ternary value. */ ++ if (exact || mpfr_round_p (result, ysize, ysize_bits - err - 1, ++ MPFR_PREC(x) + (rnd == MPFR_RNDN))) + break; + + next_loop: +diff -Naurd mpfr-3.1.5-a/src/version.c mpfr-3.1.5-b/src/version.c +--- mpfr-3.1.5-a/src/version.c 2016-12-15 08:35:46.544430346 +0000 ++++ mpfr-3.1.5-b/src/version.c 2016-12-19 22:11:17.094676820 +0000 +@@ -25,5 +25,5 @@ + const char * + mpfr_get_version (void) + { +- return "3.1.5-p1"; ++ return "3.1.5-p2"; + } +diff -Naurd mpfr-3.1.5-a/tests/tstrtofr.c mpfr-3.1.5-b/tests/tstrtofr.c +--- mpfr-3.1.5-a/tests/tstrtofr.c 2016-09-27 07:58:14.000000000 +0000 ++++ mpfr-3.1.5-b/tests/tstrtofr.c 2016-12-19 22:11:17.066676788 +0000 +@@ -1191,6 +1191,24 @@ + mpfr_clears (e, x1, x2, (mpfr_ptr) 0); + } + ++/* Note: the number is 5^47/2^9. */ ++static void ++bug20161217 (void) ++{ ++ mpfr_t fp, z; ++ static const char * num = "0.1387778780781445675529539585113525390625e31"; ++ int inex; ++ ++ mpfr_init2 (fp, 110); ++ mpfr_init2 (z, 110); ++ inex = mpfr_strtofr (fp, num, NULL, 10, MPFR_RNDN); ++ MPFR_ASSERTN(inex == 0); ++ mpfr_set_str_binary (z, "10001100001000010011110110011101101001010000001011011110010001010100010100100110111101000010001011001100001101E-9"); ++ MPFR_ASSERTN(mpfr_equal_p (fp, z)); ++ mpfr_clear (fp); ++ mpfr_clear (z); ++} ++ + int + main (int argc, char *argv[]) + { +@@ -1205,6 +1223,7 @@ + test20100310 (); + bug20120814 (); + bug20120829 (); ++ bug20161217 (); + + tests_end_mpfr (); + return 0; diff --git a/dev-libs/mpfr/files/mpfr-3.1.4-cygwin.patch b/dev-libs/mpfr/files/mpfr-3.1.4-cygwin.patch new file mode 100644 index 000000000000..c051b4621bd2 --- /dev/null +++ b/dev-libs/mpfr/files/mpfr-3.1.4-cygwin.patch @@ -0,0 +1,39 @@ +https://bugs.gentoo.org/579840 + +fix from upstream + +r10260 | vlefevre | 2016-04-08 19:17:07 -0400 (Fri, 08 Apr 2016) | 8 lines + +[src/mpfr-impl.h] Removed the detection of possible inconsistencies +under Unix because the tests could yield spurious errors with Cygwin +or other similar implementations. Moreover, such tests were used for +debugging purpose or to detect potential problems in the environment, +thus were not really useful for the end user. They were initially +added in the win-thread-safe-dll branch (r9682, following a problem +found in r9680). One alternative for checking by the MPFR developers +would be to output the status of some internal macros in tversion. + +Index: src/mpfr-impl.h +=================================================================== +--- src/mpfr-impl.h (revision 10259) ++++ src/mpfr-impl.h (revision 10260) +@@ -208,19 +208,6 @@ typedef struct __gmpfr_cache_s *mpfr_cac + # define MPFR_WIN_THREAD_SAFE_DLL 1 + #endif + +-/* Detect some possible inconsistencies under Unix. */ +-#if defined(__unix__) +-# if defined(_WIN32) +-# error "Both __unix__ and _WIN32 are defined" +-# endif +-# if __GMP_LIBGMP_DLL +-# error "__unix__ is defined and __GMP_LIBGMP_DLL is true" +-# endif +-# if defined(MPFR_WIN_THREAD_SAFE_DLL) +-# error "Both __unix__ and MPFR_WIN_THREAD_SAFE_DLL are defined" +-# endif +-#endif +- + #if defined(__MPFR_WITHIN_MPFR) || !defined(MPFR_WIN_THREAD_SAFE_DLL) + extern MPFR_THREAD_ATTR mpfr_flags_t __gmpfr_flags; + extern MPFR_THREAD_ATTR mpfr_exp_t __gmpfr_emin; diff --git a/dev-libs/mpfr/metadata.xml b/dev-libs/mpfr/metadata.xml new file mode 100644 index 000000000000..e396f3755977 --- /dev/null +++ b/dev-libs/mpfr/metadata.xml @@ -0,0 +1,8 @@ + + + + + toolchain@gentoo.org + Gentoo Toolchain Project + + diff --git a/dev-libs/mpfr/mpfr-2.4.2_p3-r1.ebuild b/dev-libs/mpfr/mpfr-2.4.2_p3-r1.ebuild new file mode 100644 index 000000000000..556230ad3917 --- /dev/null +++ b/dev-libs/mpfr/mpfr-2.4.2_p3-r1.ebuild @@ -0,0 +1,49 @@ +# Copyright 1999-2017 Gentoo Foundation +# Distributed under the terms of the GNU General Public License v2 + +# this ebuild is only for the libmpfr.so.1 ABI SONAME + +EAPI="5" + +inherit eutils libtool multilib multilib-minimal flag-o-matic + +MY_PV=${PV/_p*} +MY_P=${PN}-${MY_PV} +DESCRIPTION="library for multiple-precision floating-point computations with exact rounding" +HOMEPAGE="http://www.mpfr.org/" +SRC_URI="http://www.mpfr.org/mpfr-${MY_PV}/${MY_P}.tar.bz2" + +LICENSE="LGPL-2.1" +SLOT="1" +KEYWORDS="~alpha ~amd64 ~arm ~hppa ~ia64 ~m68k ~mips ~ppc ~ppc64 ~s390 ~sh ~sparc ~x86 ~ppc-aix ~sparc-fbsd ~x86-fbsd ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris" +IUSE="" + +RDEPEND=">=dev-libs/gmp-4.1.4-r2:0[${MULTILIB_USEDEP}]" +DEPEND="${RDEPEND}" + +S=${WORKDIR}/${MY_P} + +src_prepare() { + epatch "${FILESDIR}"/${MY_PV}/patch* + sed -i '/if test/s:==:=:' configure #261016 + find . -type f -exec touch -r configure {} + + elibtoolize +} + +multilib_src_configure() { + # Newer gmp has deleted this define, so export it for older mpfr. + append-cppflags -D__gmp_const=const + # Make sure mpfr doesn't go probing toolchains it shouldn't #476336#19 + ECONF_SOURCE=${S} \ + user_redefine_cc=yes \ + econf --disable-static +} + +multilib_src_compile() { + emake libmpfr.la +} + +multilib_src_install() { + emake DESTDIR="${D}" install-libLTLIBRARIES + rm -f "${ED}"/usr/*/libmpfr.{la,so,dylib,a} +} diff --git a/dev-libs/mpfr/mpfr-3.1.3_p4.ebuild b/dev-libs/mpfr/mpfr-3.1.3_p4.ebuild new file mode 100644 index 000000000000..dd9e659c9607 --- /dev/null +++ b/dev-libs/mpfr/mpfr-3.1.3_p4.ebuild @@ -0,0 +1,61 @@ +# Copyright 1999-2017 Gentoo Foundation +# Distributed under the terms of the GNU General Public License v2 + +EAPI="4" + +# NOTE: we cannot depend on autotools here starting with gcc-4.3.x +inherit eutils libtool multilib multilib-minimal + +MY_PV=${PV/_p*} +MY_P=${PN}-${MY_PV} +PLEVEL=${PV/*p} +DESCRIPTION="library for multiple-precision floating-point computations with exact rounding" +HOMEPAGE="http://www.mpfr.org/" +SRC_URI="http://www.mpfr.org/mpfr-${MY_PV}/${MY_P}.tar.xz" + +LICENSE="LGPL-2.1" +SLOT="0" +KEYWORDS="alpha amd64 arm arm64 hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~amd64-fbsd ~sparc-fbsd ~x86-fbsd ~amd64-linux ~arm-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris" +IUSE="static-libs" + +RDEPEND=">=dev-libs/gmp-4.1.4-r2[${MULTILIB_USEDEP},static-libs?]" +DEPEND="${RDEPEND}" + +S=${WORKDIR}/${MY_P} + +src_prepare() { + if [[ ${PLEVEL} != ${PV} ]] ; then + local i + for (( i = 1; i <= PLEVEL; ++i )) ; do + epatch "${FILESDIR}"/${MY_PV}/patch$(printf '%02d' ${i}) + done + fi + find . -type f -exec touch -r configure {} + + elibtoolize +} + +multilib_src_configure() { + # Make sure mpfr doesn't go probing toolchains it shouldn't #476336#19 + ECONF_SOURCE=${S} \ + user_redefine_cc=yes \ + econf \ + --docdir="\$(datarootdir)/doc/${PF}" \ + $(use_enable static-libs static) +} + +multilib_src_install_all() { + use static-libs || find "${ED}"/usr -name '*.la' -delete + + # clean up html/license install + pushd "${ED}"/usr/share/doc/${PF} >/dev/null + dohtml *.html && rm COPYING* *.html || die + popd >/dev/null +} + +pkg_preinst() { + preserve_old_lib /usr/$(get_libdir)/libmpfr$(get_libname 1) +} + +pkg_postinst() { + preserve_old_lib_notify /usr/$(get_libdir)/libmpfr$(get_libname 1) +} diff --git a/dev-libs/mpfr/mpfr-3.1.4.ebuild b/dev-libs/mpfr/mpfr-3.1.4.ebuild new file mode 100644 index 000000000000..5cd6fbc12d97 --- /dev/null +++ b/dev-libs/mpfr/mpfr-3.1.4.ebuild @@ -0,0 +1,55 @@ +# Copyright 1999-2017 Gentoo Foundation +# Distributed under the terms of the GNU General Public License v2 + +EAPI="4" + +# NOTE: we cannot depend on autotools here starting with gcc-4.3.x +inherit eutils libtool multilib-minimal + +MY_PV=${PV/_p*} +MY_P=${PN}-${MY_PV} +PLEVEL=${PV/*p} +DESCRIPTION="library for multiple-precision floating-point computations with exact rounding" +HOMEPAGE="http://www.mpfr.org/" +SRC_URI="http://www.mpfr.org/mpfr-${MY_PV}/${MY_P}.tar.xz" + +LICENSE="LGPL-2.1" +SLOT="0" +KEYWORDS="~alpha ~amd64 ~arm ~arm64 ~hppa ~ia64 ~m68k ~mips ~ppc ~ppc64 ~s390 ~sh ~sparc ~x86 ~ppc-aix ~amd64-fbsd ~sparc-fbsd ~x86-fbsd ~amd64-linux ~arm-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris" +IUSE="static-libs" + +RDEPEND=">=dev-libs/gmp-4.1.4-r2[${MULTILIB_USEDEP},static-libs?]" +DEPEND="${RDEPEND}" + +S=${WORKDIR}/${MY_P} + +src_prepare() { + if [[ ${PLEVEL} != ${PV} ]] ; then + local i + for (( i = 1; i <= PLEVEL; ++i )) ; do + epatch "${FILESDIR}"/${MY_PV}/patch$(printf '%02d' ${i}) + done + fi + epatch "${FILESDIR}"/${P}-cygwin.patch #579840 + epatch_user + find . -type f -exec touch -r configure {} + + elibtoolize +} + +multilib_src_configure() { + # Make sure mpfr doesn't go probing toolchains it shouldn't #476336#19 + ECONF_SOURCE=${S} \ + user_redefine_cc=yes \ + econf \ + --docdir="\$(datarootdir)/doc/${PF}" \ + $(use_enable static-libs static) +} + +multilib_src_install_all() { + use static-libs || find "${ED}"/usr -name '*.la' -delete + + # clean up html/license install + pushd "${ED}"/usr/share/doc/${PF} >/dev/null + dohtml *.html && rm COPYING* *.html || die + popd >/dev/null +} diff --git a/dev-libs/mpfr/mpfr-3.1.5_p2.ebuild b/dev-libs/mpfr/mpfr-3.1.5_p2.ebuild new file mode 100644 index 000000000000..46d667649b53 --- /dev/null +++ b/dev-libs/mpfr/mpfr-3.1.5_p2.ebuild @@ -0,0 +1,54 @@ +# Copyright 1999-2017 Gentoo Foundation +# Distributed under the terms of the GNU General Public License v2 + +EAPI=5 + +# NOTE: we cannot depend on autotools here starting with gcc-4.3.x +inherit eutils libtool multilib-minimal + +MY_PV=${PV/_p*} +MY_P=${PN}-${MY_PV} +PLEVEL=${PV/*p} +DESCRIPTION="library for multiple-precision floating-point computations with exact rounding" +HOMEPAGE="http://www.mpfr.org/" +SRC_URI="http://www.mpfr.org/mpfr-${MY_PV}/${MY_P}.tar.xz" + +LICENSE="LGPL-2.1" +SLOT="0/4" # libmpfr.so version +KEYWORDS="~alpha ~amd64 ~arm ~arm64 ~hppa ~ia64 ~m68k ~mips ~ppc ~ppc64 ~s390 ~sh ~sparc ~x86 ~ppc-aix ~x64-cygwin ~amd64-fbsd ~sparc-fbsd ~x86-fbsd ~amd64-linux ~arm-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris" +IUSE="static-libs" + +RDEPEND=">=dev-libs/gmp-4.1.4-r2[${MULTILIB_USEDEP},static-libs?]" +DEPEND="${RDEPEND}" + +S=${WORKDIR}/${MY_P} + +src_prepare() { + if [[ ${PLEVEL} != ${PV} ]] ; then + local i + for (( i = 1; i <= PLEVEL; ++i )) ; do + epatch "${FILESDIR}"/${MY_PV}/patch$(printf '%02d' ${i}) + done + fi + epatch_user + find . -type f -exec touch -r configure {} + + elibtoolize +} + +multilib_src_configure() { + # Make sure mpfr doesn't go probing toolchains it shouldn't #476336#19 + ECONF_SOURCE=${S} \ + user_redefine_cc=yes \ + econf \ + --docdir="\$(datarootdir)/doc/${PF}" \ + $(use_enable static-libs static) +} + +multilib_src_install_all() { + use static-libs || find "${ED}"/usr -name '*.la' -delete + + # clean up html/license install + pushd "${ED}"/usr/share/doc/${PF} >/dev/null || die + dohtml *.html && rm COPYING* *.html + popd >/dev/null || die +} diff --git a/dev-libs/mpfr/mpfr-3.1.6.ebuild b/dev-libs/mpfr/mpfr-3.1.6.ebuild new file mode 100644 index 000000000000..46d667649b53 --- /dev/null +++ b/dev-libs/mpfr/mpfr-3.1.6.ebuild @@ -0,0 +1,54 @@ +# Copyright 1999-2017 Gentoo Foundation +# Distributed under the terms of the GNU General Public License v2 + +EAPI=5 + +# NOTE: we cannot depend on autotools here starting with gcc-4.3.x +inherit eutils libtool multilib-minimal + +MY_PV=${PV/_p*} +MY_P=${PN}-${MY_PV} +PLEVEL=${PV/*p} +DESCRIPTION="library for multiple-precision floating-point computations with exact rounding" +HOMEPAGE="http://www.mpfr.org/" +SRC_URI="http://www.mpfr.org/mpfr-${MY_PV}/${MY_P}.tar.xz" + +LICENSE="LGPL-2.1" +SLOT="0/4" # libmpfr.so version +KEYWORDS="~alpha ~amd64 ~arm ~arm64 ~hppa ~ia64 ~m68k ~mips ~ppc ~ppc64 ~s390 ~sh ~sparc ~x86 ~ppc-aix ~x64-cygwin ~amd64-fbsd ~sparc-fbsd ~x86-fbsd ~amd64-linux ~arm-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris" +IUSE="static-libs" + +RDEPEND=">=dev-libs/gmp-4.1.4-r2[${MULTILIB_USEDEP},static-libs?]" +DEPEND="${RDEPEND}" + +S=${WORKDIR}/${MY_P} + +src_prepare() { + if [[ ${PLEVEL} != ${PV} ]] ; then + local i + for (( i = 1; i <= PLEVEL; ++i )) ; do + epatch "${FILESDIR}"/${MY_PV}/patch$(printf '%02d' ${i}) + done + fi + epatch_user + find . -type f -exec touch -r configure {} + + elibtoolize +} + +multilib_src_configure() { + # Make sure mpfr doesn't go probing toolchains it shouldn't #476336#19 + ECONF_SOURCE=${S} \ + user_redefine_cc=yes \ + econf \ + --docdir="\$(datarootdir)/doc/${PF}" \ + $(use_enable static-libs static) +} + +multilib_src_install_all() { + use static-libs || find "${ED}"/usr -name '*.la' -delete + + # clean up html/license install + pushd "${ED}"/usr/share/doc/${PF} >/dev/null || die + dohtml *.html && rm COPYING* *.html + popd >/dev/null || die +} -- cgit v1.2.3