pax_global_header00006660000000000000000000000064122265761700014522gustar00rootroot0000000000000052 comment=4c98f08193b9b0057a818e5da0721483b564cfc5 mpfrc++-3.5.6+ds/000077500000000000000000000000001222657617000133745ustar00rootroot00000000000000mpfrc++-3.5.6+ds/changelog000066400000000000000000000164401222657617000152530ustar00rootroot000000000000002013-10-11 Pavel Holoborodko * .hgtags: Added tag mpfrc++-3.5.6 for changeset 212d3bddf30c [e15c90a30ce6] [tip] * .hgtags, mpreal.h: Added support for GCC 7.1 and above [212d3bddf30c] [mpfrc++-3.5.6] 2013-10-10 Pavel Holoborodko * .hgtags: Added tag mpfrc++-3.5.5 for changeset 101440e2b33d [462681c3110d] * changelog: Added changelog [101440e2b33d] [mpfrc++-3.5.5] * copying.txt: Added GPL text as separate file [d2450011629e] * copying.txt, example/example.cpp, mpreal.h: License terms clarification [fe3b241512bb] 2013-10-09 Pavel Holoborodko * .hgtags: Added tag 3.5.5 for changeset 26663a149dfc [2efce445849a] 2013-10-08 Pavel Holoborodko * example/example.cpp: Added copyright notice to example [26663a149dfc] [3.5.5] * copying.txt, mpreal.h: Added "dual-licensing" terms [13837c895076] * mpreal.h: Added wrappers for low-level initializations check [bd04a7f7b521] 2013-09-02 Pavel Holoborodko * mpreal.h: Added move ctor / assignment, RVO optimization, compatibility with older MPFR. [72eac755d15c] 2013-02-19 Pavel Holoborodko * mpreal.h: Added macro-logic for int64_t support on Mac OS X [1b0d6fdcf92f] 2013-02-11 Pavel Holoborodko * mpreal.h: Initialization overhead minimization in mathematical functions [5c67b57960bd] 2013-02-10 Pavel Holoborodko * mpreal.h: Arithmetic operations speed up by RVO and overhead minimization [c524bcccda1d] 2013-01-24 Gael Guennebaud * mpreal.h: Enable compiler RVO in c = a + b; [863750c996ff] * mpreal.h: Enable compiler RVO in c = a * b; [4c502eded329] * mpreal.h: add a const version of mpfr_ptr [fb4da131c3e6] * mpreal.h: Workaround "error: floating-point literal cannot appear in a constant-expression" when compiling with gcc -pedantic [e79dc5492ce5] 2012-12-04 Pavel Holoborodko * mpreal.h: Fixed 'long int' and 'int64_t' clash on IA64 platforms [340d58c79215] 2012-10-26 Pavel Holoborodko * mpreal.h: Added work-around to avoid clash with min, max macroses in MSVC [75a3a3a2bafd] 2012-10-23 Pavel Holoborodko * mpreal.h: Speed-up in assignment and conversion from double [d40a2e23c6d7] 2012-10-22 Pavel Holoborodko * mpreal.h: Improved speciliazation for std::numeric_limits [4ee2d33724d2] 2012-10-21 Pavel Holoborodko * mpreal.h: Fixed formatting, TAB to spaces [f6db242a57d5] 2012-10-19 Pavel Holoborodko * example/example.cpp, mpreal.h: Changed round_style to function Fixed minor warnings Fixed contributor list [27b2cac5f626] 2012-10-19 Pavel Holoborodko * mpreal.h: Enhancement of std::numeric_limts, to be more compatible with LAPACK Template LIbrary [4e80c52d2bf4] * mpreal.h: Fixed messed up blank spaces [bb97d60dc279] * mpreal.h: New one-header MPREAL library [633ecbf6b601] * AUTHORS, COPYING, ChangeLog, INSTALL, MPRealSupport, Makefile.am, Makefile.in, NEWS, README, aclocal.m4, config.guess, config.sub, configure, configure.ac, copying.lib, depcomp, example.cpp, example.makefile, example/example.cpp, example/makefile, install-sh, ltmain.sh, missing, mpreal.cpp, mpreal.h: Complete update, old files clean up [54439186de7b] 2012-08-17 Jauhien Piatlicki * Makefile.am, Makefile.in, configure, configure.ac: correct so-version [365e3a6bb539] * autom4te.cache/output.0, autom4te.cache/output.1, autom4te.cache/requests, autom4te.cache/traces.0, autom4te.cache/traces.1: rm autom4te.cache [cfeb628317ea] * AUTHORS, COPYING, ChangeLog, INSTALL, Makefile.am, Makefile.in, NEWS, README, aclocal.m4, autom4te.cache/output.0, autom4te.cache/output.1, autom4te.cache/requests, autom4te.cache/traces.0, autom4te.cache/traces.1, config.guess, config.sub, configure, configure.ac, copying, depcomp, example.makefile, install-sh, ltmain.sh, makefile, missing: building with autotools added [210888972b8b] 2012-06-22 Pavel Holoborodko * mpreal.cpp: Replaced MPFR_RNDN to GMP_RNDN for compatibility [7b9efa6bd2c0] * mpreal.cpp, mpreal.h: Extended machine_epsilon() Restored compatibility with MPFR 2.3.1 Code clean-up and simplifications by Gael Guennebaud Added comments & explanations [452b3e42ef1e] * MPRealSupport: Code clean up and simplification by Gael Guennebaud Added constants and other features [c054b3966fa6] * dlmalloc.c, dlmalloc.h, makefile: Removed dlmalloc library since it is optional [9e88546ed3ba] 2012-05-23 Pavel Holoborodko * copying, copying.lib, example.cpp, makefile: Added makefile, example.cpp and license [d04cff7a41be] * mpreal.h: Added x64 support for MinGW64. Added "fuzzy" comparison [da1927a4c53a] 2012-01-16 Pavel Holoborodko * mpreal.h: Fixed bug which in conversion to mpfr_srcptr [88fa1ed2a7a5] 2012-01-12 Pavel Holoborodko * mpreal.cpp, mpreal.h: Fixed implicit conversion to mpfr_ptr/mpfr_srcptr and std::string [a87b193a75ab] * mpreal.h: - removed unneeded templated comparison operators - code re-formatting [d2167e612f81] 2012-01-11 Pavel Holoborodko * mpreal.cpp, mpreal.h: - fix many minor bugs, including DebugView update in unary operations - refactor binary operations as templated functions - remove implicit conversion operators to raw pointers - custom memory allocation is optional now. [7b310de78559] 2011-09-30 Pavel Holoborodko * mpreal.cpp, mpreal.h: Fixed bug x-x = -0. Signed zeros are perfectly supported now. toString() has been cleaned up. Fixed static members initialization hell. Added Debug Preview for MSVC - Alexei Zubanov. [4f8d7043bf92] 2011-09-09 Pavel Holoborodko * mpreal.cpp, mpreal.h: Disabled int64_t support for VC++ less than 2010 Added setZero(). Changed syntax of set_inf & set_nan. [2ee44062b841] 2011-09-05 Pavel Holoborodko * mpreal.h: Fixed few warnings on unused parameter ‘rnd_mode’. Added conversion operator mpfr_srcptr() Include for compatibility with MPFR < 3.0.0 [2faff5e271af] 2011-08-26 Pavel Holoborodko * mpreal.h: fix typo in comment [bd4bd7c0070f] * mpreal.h: disable MPFR_USE_INTMAX_T on x64 GCC builds [4d311588a233] * mpreal.h: detect x64 GCC builds and disable uint64_t since long int is already has 64-bits. [446bb69c5e42] * mpreal.cpp: clean up size_t & int types usage [2fdac1dc28fa] * mpreal.cpp, mpreal.h: - fixed urandom & sprintf_s - GCC compatibility [9de48e3cfb9c] 2011-08-25 Pavel Holoborodko * inttypes.h, stdint.h: removed unnecessary headers, needed for old MSVC [53846e0ba5d9] * mpreal.h: cleaning up of x64 support, needs testing on GCC [7711c5332b26] 2011-08-24 Pavel Holoborodko * MPRealSupport: added NumTraits for smooth integration with Eigen [860d3e3234a8] * dlmalloc.c, dlmalloc.h, inttypes.h, mpreal.cpp, mpreal.h, stdint.h: initial commit [9123b6b7751e] mpfrc++-3.5.6+ds/copying.txt000066400000000000000000001057541222657617000156210ustar00rootroot00000000000000 GNU GENERAL PUBLIC LICENSE Version 3, 29 June 2007 Copyright (C) 2007 Free Software Foundation, Inc. Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. Preamble The GNU General Public License is a free, copyleft license for software and other kinds of works. The licenses for most software and other practical works are designed to take away your freedom to share and change the works. By contrast, the GNU General Public License is intended to guarantee your freedom to share and change all versions of a program--to make sure it remains free software for all its users. We, the Free Software Foundation, use the GNU General Public License for most of our software; it applies also to any other work released this way by its authors. You can apply it to your programs, too. When we speak of free software, we are referring to freedom, not price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for them if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs, and that you know you can do these things. To protect your rights, we need to prevent others from denying you these rights or asking you to surrender the rights. Therefore, you have certain responsibilities if you distribute copies of the software, or if you modify it: responsibilities to respect the freedom of others. For example, if you distribute copies of such a program, whether gratis or for a fee, you must pass on to the recipients the same freedoms that you received. You must make sure that they, too, receive or can get the source code. And you must show them these terms so they know their rights. Developers that use the GNU GPL protect your rights with two steps: (1) assert copyright on the software, and (2) offer you this License giving you legal permission to copy, distribute and/or modify it. For the developers' and authors' protection, the GPL clearly explains that there is no warranty for this free software. For both users' and authors' sake, the GPL requires that modified versions be marked as changed, so that their problems will not be attributed erroneously to authors of previous versions. Some devices are designed to deny users access to install or run modified versions of the software inside them, although the manufacturer can do so. This is fundamentally incompatible with the aim of protecting users' freedom to change the software. The systematic pattern of such abuse occurs in the area of products for individuals to use, which is precisely where it is most unacceptable. Therefore, we have designed this version of the GPL to prohibit the practice for those products. If such problems arise substantially in other domains, we stand ready to extend this provision to those domains in future versions of the GPL, as needed to protect the freedom of users. Finally, every program is threatened constantly by software patents. States should not allow patents to restrict development and use of software on general-purpose computers, but in those that do, we wish to avoid the special danger that patents applied to a free program could make it effectively proprietary. To prevent this, the GPL assures that patents cannot be used to render the program non-free. The precise terms and conditions for copying, distribution and modification follow. TERMS AND CONDITIONS 0. Definitions. "This License" refers to version 3 of the GNU General Public License. "Copyright" also means copyright-like laws that apply to other kinds of works, such as semiconductor masks. "The Program" refers to any copyrightable work licensed under this License. Each licensee is addressed as "you". "Licensees" and "recipients" may be individuals or organizations. To "modify" a work means to copy from or adapt all or part of the work in a fashion requiring copyright permission, other than the making of an exact copy. The resulting work is called a "modified version" of the earlier work or a work "based on" the earlier work. A "covered work" means either the unmodified Program or a work based on the Program. To "propagate" a work means to do anything with it that, without permission, would make you directly or secondarily liable for infringement under applicable copyright law, except executing it on a computer or modifying a private copy. Propagation includes copying, distribution (with or without modification), making available to the public, and in some countries other activities as well. To "convey" a work means any kind of propagation that enables other parties to make or receive copies. Mere interaction with a user through a computer network, with no transfer of a copy, is not conveying. An interactive user interface displays "Appropriate Legal Notices" to the extent that it includes a convenient and prominently visible feature that (1) displays an appropriate copyright notice, and (2) tells the user that there is no warranty for the work (except to the extent that warranties are provided), that licensees may convey the work under this License, and how to view a copy of this License. If the interface presents a list of user commands or options, such as a menu, a prominent item in the list meets this criterion. 1. Source Code. The "source code" for a work means the preferred form of the work for making modifications to it. "Object code" means any non-source form of a work. A "Standard Interface" means an interface that either is an official standard defined by a recognized standards body, or, in the case of interfaces specified for a particular programming language, one that is widely used among developers working in that language. The "System Libraries" of an executable work include anything, other than the work as a whole, that (a) is included in the normal form of packaging a Major Component, but which is not part of that Major Component, and (b) serves only to enable use of the work with that Major Component, or to implement a Standard Interface for which an implementation is available to the public in source code form. A "Major Component", in this context, means a major essential component (kernel, window system, and so on) of the specific operating system (if any) on which the executable work runs, or a compiler used to produce the work, or an object code interpreter used to run it. The "Corresponding Source" for a work in object code form means all the source code needed to generate, install, and (for an executable work) run the object code and to modify the work, including scripts to control those activities. However, it does not include the work's System Libraries, or general-purpose tools or generally available free programs which are used unmodified in performing those activities but which are not part of the work. For example, Corresponding Source includes interface definition files associated with source files for the work, and the source code for shared libraries and dynamically linked subprograms that the work is specifically designed to require, such as by intimate data communication or control flow between those subprograms and other parts of the work. The Corresponding Source need not include anything that users can regenerate automatically from other parts of the Corresponding Source. The Corresponding Source for a work in source code form is that same work. 2. Basic Permissions. All rights granted under this License are granted for the term of copyright on the Program, and are irrevocable provided the stated conditions are met. This License explicitly affirms your unlimited permission to run the unmodified Program. The output from running a covered work is covered by this License only if the output, given its content, constitutes a covered work. This License acknowledges your rights of fair use or other equivalent, as provided by copyright law. You may make, run and propagate covered works that you do not convey, without conditions so long as your license otherwise remains in force. You may convey covered works to others for the sole purpose of having them make modifications exclusively for you, or provide you with facilities for running those works, provided that you comply with the terms of this License in conveying all material for which you do not control copyright. Those thus making or running the covered works for you must do so exclusively on your behalf, under your direction and control, on terms that prohibit them from making any copies of your copyrighted material outside their relationship with you. Conveying under any other circumstances is permitted solely under the conditions stated below. Sublicensing is not allowed; section 10 makes it unnecessary. 3. Protecting Users' Legal Rights From Anti-Circumvention Law. No covered work shall be deemed part of an effective technological measure under any applicable law fulfilling obligations under article 11 of the WIPO copyright treaty adopted on 20 December 1996, or similar laws prohibiting or restricting circumvention of such measures. When you convey a covered work, you waive any legal power to forbid circumvention of technological measures to the extent such circumvention is effected by exercising rights under this License with respect to the covered work, and you disclaim any intention to limit operation or modification of the work as a means of enforcing, against the work's users, your or third parties' legal rights to forbid circumvention of technological measures. 4. Conveying Verbatim Copies. You may convey verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice; keep intact all notices stating that this License and any non-permissive terms added in accord with section 7 apply to the code; keep intact all notices of the absence of any warranty; and give all recipients a copy of this License along with the Program. You may charge any price or no price for each copy that you convey, and you may offer support or warranty protection for a fee. 5. Conveying Modified Source Versions. You may convey a work based on the Program, or the modifications to produce it from the Program, in the form of source code under the terms of section 4, provided that you also meet all of these conditions: a) The work must carry prominent notices stating that you modified it, and giving a relevant date. b) The work must carry prominent notices stating that it is released under this License and any conditions added under section 7. This requirement modifies the requirement in section 4 to "keep intact all notices". c) You must license the entire work, as a whole, under this License to anyone who comes into possession of a copy. This License will therefore apply, along with any applicable section 7 additional terms, to the whole of the work, and all its parts, regardless of how they are packaged. This License gives no permission to license the work in any other way, but it does not invalidate such permission if you have separately received it. d) If the work has interactive user interfaces, each must display Appropriate Legal Notices; however, if the Program has interactive interfaces that do not display Appropriate Legal Notices, your work need not make them do so. A compilation of a covered work with other separate and independent works, which are not by their nature extensions of the covered work, and which are not combined with it such as to form a larger program, in or on a volume of a storage or distribution medium, is called an "aggregate" if the compilation and its resulting copyright are not used to limit the access or legal rights of the compilation's users beyond what the individual works permit. Inclusion of a covered work in an aggregate does not cause this License to apply to the other parts of the aggregate. 6. Conveying Non-Source Forms. You may convey a covered work in object code form under the terms of sections 4 and 5, provided that you also convey the machine-readable Corresponding Source under the terms of this License, in one of these ways: a) Convey the object code in, or embodied in, a physical product (including a physical distribution medium), accompanied by the Corresponding Source fixed on a durable physical medium customarily used for software interchange. b) Convey the object code in, or embodied in, a physical product (including a physical distribution medium), accompanied by a written offer, valid for at least three years and valid for as long as you offer spare parts or customer support for that product model, to give anyone who possesses the object code either (1) a copy of the Corresponding Source for all the software in the product that is covered by this License, on a durable physical medium customarily used for software interchange, for a price no more than your reasonable cost of physically performing this conveying of source, or (2) access to copy the Corresponding Source from a network server at no charge. c) Convey individual copies of the object code with a copy of the written offer to provide the Corresponding Source. This alternative is allowed only occasionally and noncommercially, and only if you received the object code with such an offer, in accord with subsection 6b. d) Convey the object code by offering access from a designated place (gratis or for a charge), and offer equivalent access to the Corresponding Source in the same way through the same place at no further charge. You need not require recipients to copy the Corresponding Source along with the object code. If the place to copy the object code is a network server, the Corresponding Source may be on a different server (operated by you or a third party) that supports equivalent copying facilities, provided you maintain clear directions next to the object code saying where to find the Corresponding Source. Regardless of what server hosts the Corresponding Source, you remain obligated to ensure that it is available for as long as needed to satisfy these requirements. e) Convey the object code using peer-to-peer transmission, provided you inform other peers where the object code and Corresponding Source of the work are being offered to the general public at no charge under subsection 6d. A separable portion of the object code, whose source code is excluded from the Corresponding Source as a System Library, need not be included in conveying the object code work. A "User Product" is either (1) a "consumer product", which means any tangible personal property which is normally used for personal, family, or household purposes, or (2) anything designed or sold for incorporation into a dwelling. In determining whether a product is a consumer product, doubtful cases shall be resolved in favor of coverage. For a particular product received by a particular user, "normally used" refers to a typical or common use of that class of product, regardless of the status of the particular user or of the way in which the particular user actually uses, or expects or is expected to use, the product. A product is a consumer product regardless of whether the product has substantial commercial, industrial or non-consumer uses, unless such uses represent the only significant mode of use of the product. "Installation Information" for a User Product means any methods, procedures, authorization keys, or other information required to install and execute modified versions of a covered work in that User Product from a modified version of its Corresponding Source. The information must suffice to ensure that the continued functioning of the modified object code is in no case prevented or interfered with solely because modification has been made. If you convey an object code work under this section in, or with, or specifically for use in, a User Product, and the conveying occurs as part of a transaction in which the right of possession and use of the User Product is transferred to the recipient in perpetuity or for a fixed term (regardless of how the transaction is characterized), the Corresponding Source conveyed under this section must be accompanied by the Installation Information. But this requirement does not apply if neither you nor any third party retains the ability to install modified object code on the User Product (for example, the work has been installed in ROM). The requirement to provide Installation Information does not include a requirement to continue to provide support service, warranty, or updates for a work that has been modified or installed by the recipient, or for the User Product in which it has been modified or installed. Access to a network may be denied when the modification itself materially and adversely affects the operation of the network or violates the rules and protocols for communication across the network. Corresponding Source conveyed, and Installation Information provided, in accord with this section must be in a format that is publicly documented (and with an implementation available to the public in source code form), and must require no special password or key for unpacking, reading or copying. 7. Additional Terms. "Additional permissions" are terms that supplement the terms of this License by making exceptions from one or more of its conditions. Additional permissions that are applicable to the entire Program shall be treated as though they were included in this License, to the extent that they are valid under applicable law. If additional permissions apply only to part of the Program, that part may be used separately under those permissions, but the entire Program remains governed by this License without regard to the additional permissions. When you convey a copy of a covered work, you may at your option remove any additional permissions from that copy, or from any part of it. (Additional permissions may be written to require their own removal in certain cases when you modify the work.) You may place additional permissions on material, added by you to a covered work, for which you have or can give appropriate copyright permission. Notwithstanding any other provision of this License, for material you add to a covered work, you may (if authorized by the copyright holders of that material) supplement the terms of this License with terms: a) Disclaiming warranty or limiting liability differently from the terms of sections 15 and 16 of this License; or b) Requiring preservation of specified reasonable legal notices or author attributions in that material or in the Appropriate Legal Notices displayed by works containing it; or c) Prohibiting misrepresentation of the origin of that material, or requiring that modified versions of such material be marked in reasonable ways as different from the original version; or d) Limiting the use for publicity purposes of names of licensors or authors of the material; or e) Declining to grant rights under trademark law for use of some trade names, trademarks, or service marks; or f) Requiring indemnification of licensors and authors of that material by anyone who conveys the material (or modified versions of it) with contractual assumptions of liability to the recipient, for any liability that these contractual assumptions directly impose on those licensors and authors. All other non-permissive additional terms are considered "further restrictions" within the meaning of section 10. If the Program as you received it, or any part of it, contains a notice stating that it is governed by this License along with a term that is a further restriction, you may remove that term. If a license document contains a further restriction but permits relicensing or conveying under this License, you may add to a covered work material governed by the terms of that license document, provided that the further restriction does not survive such relicensing or conveying. If you add terms to a covered work in accord with this section, you must place, in the relevant source files, a statement of the additional terms that apply to those files, or a notice indicating where to find the applicable terms. Additional terms, permissive or non-permissive, may be stated in the form of a separately written license, or stated as exceptions; the above requirements apply either way. 8. Termination. You may not propagate or modify a covered work except as expressly provided under this License. Any attempt otherwise to propagate or modify it is void, and will automatically terminate your rights under this License (including any patent licenses granted under the third paragraph of section 11). However, if you cease all violation of this License, then your license from a particular copyright holder is reinstated (a) provisionally, unless and until the copyright holder explicitly and finally terminates your license, and (b) permanently, if the copyright holder fails to notify you of the violation by some reasonable means prior to 60 days after the cessation. Moreover, your license from a particular copyright holder is reinstated permanently if the copyright holder notifies you of the violation by some reasonable means, this is the first time you have received notice of violation of this License (for any work) from that copyright holder, and you cure the violation prior to 30 days after your receipt of the notice. Termination of your rights under this section does not terminate the licenses of parties who have received copies or rights from you under this License. If your rights have been terminated and not permanently reinstated, you do not qualify to receive new licenses for the same material under section 10. 9. Acceptance Not Required for Having Copies. You are not required to accept this License in order to receive or run a copy of the Program. Ancillary propagation of a covered work occurring solely as a consequence of using peer-to-peer transmission to receive a copy likewise does not require acceptance. However, nothing other than this License grants you permission to propagate or modify any covered work. These actions infringe copyright if you do not accept this License. Therefore, by modifying or propagating a covered work, you indicate your acceptance of this License to do so. 10. Automatic Licensing of Downstream Recipients. Each time you convey a covered work, the recipient automatically receives a license from the original licensors, to run, modify and propagate that work, subject to this License. You are not responsible for enforcing compliance by third parties with this License. An "entity transaction" is a transaction transferring control of an organization, or substantially all assets of one, or subdividing an organization, or merging organizations. If propagation of a covered work results from an entity transaction, each party to that transaction who receives a copy of the work also receives whatever licenses to the work the party's predecessor in interest had or could give under the previous paragraph, plus a right to possession of the Corresponding Source of the work from the predecessor in interest, if the predecessor has it or can get it with reasonable efforts. You may not impose any further restrictions on the exercise of the rights granted or affirmed under this License. For example, you may not impose a license fee, royalty, or other charge for exercise of rights granted under this License, and you may not initiate litigation (including a cross-claim or counterclaim in a lawsuit) alleging that any patent claim is infringed by making, using, selling, offering for sale, or importing the Program or any portion of it. 11. Patents. A "contributor" is a copyright holder who authorizes use under this License of the Program or a work on which the Program is based. The work thus licensed is called the contributor's "contributor version". A contributor's "essential patent claims" are all patent claims owned or controlled by the contributor, whether already acquired or hereafter acquired, that would be infringed by some manner, permitted by this License, of making, using, or selling its contributor version, but do not include claims that would be infringed only as a consequence of further modification of the contributor version. For purposes of this definition, "control" includes the right to grant patent sublicenses in a manner consistent with the requirements of this License. Each contributor grants you a non-exclusive, worldwide, royalty-free patent license under the contributor's essential patent claims, to make, use, sell, offer for sale, import and otherwise run, modify and propagate the contents of its contributor version. In the following three paragraphs, a "patent license" is any express agreement or commitment, however denominated, not to enforce a patent (such as an express permission to practice a patent or covenant not to sue for patent infringement). To "grant" such a patent license to a party means to make such an agreement or commitment not to enforce a patent against the party. If you convey a covered work, knowingly relying on a patent license, and the Corresponding Source of the work is not available for anyone to copy, free of charge and under the terms of this License, through a publicly available network server or other readily accessible means, then you must either (1) cause the Corresponding Source to be so available, or (2) arrange to deprive yourself of the benefit of the patent license for this particular work, or (3) arrange, in a manner consistent with the requirements of this License, to extend the patent license to downstream recipients. "Knowingly relying" means you have actual knowledge that, but for the patent license, your conveying the covered work in a country, or your recipient's use of the covered work in a country, would infringe one or more identifiable patents in that country that you have reason to believe are valid. If, pursuant to or in connection with a single transaction or arrangement, you convey, or propagate by procuring conveyance of, a covered work, and grant a patent license to some of the parties receiving the covered work authorizing them to use, propagate, modify or convey a specific copy of the covered work, then the patent license you grant is automatically extended to all recipients of the covered work and works based on it. A patent license is "discriminatory" if it does not include within the scope of its coverage, prohibits the exercise of, or is conditioned on the non-exercise of one or more of the rights that are specifically granted under this License. You may not convey a covered work if you are a party to an arrangement with a third party that is in the business of distributing software, under which you make payment to the third party based on the extent of your activity of conveying the work, and under which the third party grants, to any of the parties who would receive the covered work from you, a discriminatory patent license (a) in connection with copies of the covered work conveyed by you (or copies made from those copies), or (b) primarily for and in connection with specific products or compilations that contain the covered work, unless you entered into that arrangement, or that patent license was granted, prior to 28 March 2007. Nothing in this License shall be construed as excluding or limiting any implied license or other defenses to infringement that may otherwise be available to you under applicable patent law. 12. No Surrender of Others' Freedom. If conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot convey a covered work so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not convey it at all. For example, if you agree to terms that obligate you to collect a royalty for further conveying from those to whom you convey the Program, the only way you could satisfy both those terms and this License would be to refrain entirely from conveying the Program. 13. Use with the GNU Affero General Public License. Notwithstanding any other provision of this License, you have permission to link or combine any covered work with a work licensed under version 3 of the GNU Affero General Public License into a single combined work, and to convey the resulting work. The terms of this License will continue to apply to the part which is the covered work, but the special requirements of the GNU Affero General Public License, section 13, concerning interaction through a network will apply to the combination as such. 14. Revised Versions of this License. The Free Software Foundation may publish revised and/or new versions of the GNU General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. Each version is given a distinguishing version number. If the Program specifies that a certain numbered version of the GNU General Public License "or any later version" applies to it, you have the option of following the terms and conditions either of that numbered version or of any later version published by the Free Software Foundation. If the Program does not specify a version number of the GNU General Public License, you may choose any version ever published by the Free Software Foundation. If the Program specifies that a proxy can decide which future versions of the GNU General Public License can be used, that proxy's public statement of acceptance of a version permanently authorizes you to choose that version for the Program. Later license versions may give you additional or different permissions. However, no additional obligations are imposed on any author or copyright holder as a result of your choosing to follow a later version. 15. Disclaimer of Warranty. THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 16. Limitation of Liability. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. 17. Interpretation of Sections 15 and 16. If the disclaimer of warranty and limitation of liability provided above cannot be given local legal effect according to their terms, reviewing courts shall apply local law that most closely approximates an absolute waiver of all civil liability in connection with the Program, unless a warranty or assumption of liability accompanies a copy of the Program in return for a fee. END OF TERMS AND CONDITIONS How to Apply These Terms to Your New Programs If you develop a new program, and you want it to be of the greatest possible use to the public, the best way to achieve this is to make it free software which everyone can redistribute and change under these terms. To do so, attach the following notices to the program. It is safest to attach them to the start of each source file to most effectively state the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found. Copyright (C) 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 the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see . Also add information on how to contact you by electronic and paper mail. If the program does terminal interaction, make it output a short notice like this when it starts in an interactive mode: Copyright (C) This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'. This is free software, and you are welcome to redistribute it under certain conditions; type `show c' for details. The hypothetical commands `show w' and `show c' should show the appropriate parts of the General Public License. Of course, your program's commands might be different; for a GUI interface, you would use an "about box". You should also get your employer (if you work as a programmer) or school, if any, to sign a "copyright disclaimer" for the program, if necessary. For more information on this, and how to apply and follow the GNU GPL, see . The GNU General Public License does not permit incorporating your program into proprietary programs. If your program is a subroutine library, you may consider it more useful to permit linking proprietary applications with the library. If this is what you want to do, use the GNU Lesser General Public License instead of this License. But first, please read . mpfrc++-3.5.6+ds/example/000077500000000000000000000000001222657617000150275ustar00rootroot00000000000000mpfrc++-3.5.6+ds/example/example.cpp000066400000000000000000000115371222657617000171750ustar00rootroot00000000000000/* This file is part of MPFR C++. MPFR C++: Multi-precision floating point number class for C++. Based on MPFR library: http://mpfr.org Project homepage: http://www.holoborodko.com/pavel/mpfr Contact e-mail: pavel@holoborodko.com Copyright (c) 2008-2013 Pavel Holoborodko Contributors: Dmitriy Gubanov, Konstantin Holoborodko, Brian Gladman, Helmut Jarausch, Fokko Beekhof, Ulrich Mutze, Heinz van Saanen, Pere Constans, Peter van Hoof, Gael Guennebaud, Tsai Chia Cheng, Alexei Zubanov, Jauhien Piatlicki, Victor Berger, John Westwood. Licensing: (A) MPFR C++ is under GNU General Public License ("GPL"). (B) Non-free licenses may also be purchased from the author, for users who do not want their programs protected by the GPL. The non-free licenses are for users that wish to use MPFR C++ in their products but are unwilling to release their software under the GPL (which would require them to release source code and allow free redistribution). Such users can purchase an unlimited-use license from the author. Contact us for more details. GNU General Public License ("GPL") copyright permissions statement: ************************************************************************** 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 the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see . */ #include #include "../mpreal.h" int main(int argc, char* argv[]) { using mpfr::mpreal; using std::cout; using std::endl; // Required precision of computations in decimal digits // Play with it to check different precisions const int digits = 50; // Setup default precision for all subsequent computations // MPFR accepts precision in bits - so we do the conversion mpreal::set_default_prec(mpfr::digits2bits(digits)); // Compute all the vital characteristics of mpreal (in current precision) // Analogous to lamch from LAPACK const mpreal one = 1.0; const mpreal zero = 0.0; const mpreal eps = std::numeric_limits::epsilon(); const int base = std::numeric_limits::radix; const mpreal prec = eps * base; const int bindigits = std::numeric_limits::digits(); // eqv. to mpfr::mpreal::get_default_prec(); const mpreal rnd = std::numeric_limits::round_error(); const mpreal maxval = std::numeric_limits::max(); const mpreal minval = std::numeric_limits::min(); const mpreal small = one / maxval; const mpreal sfmin = (small > minval) ? small * (one + eps) : minval; const mpreal round = std::numeric_limits::round_style(); const int min_exp = std::numeric_limits::min_exponent; const mpreal underflow = std::numeric_limits::min(); const int max_exp = std::numeric_limits::max_exponent; const mpreal overflow = std::numeric_limits::max(); // Additionally compute pi with required accuracy - just for fun :) const mpreal pi = mpfr::const_pi(); cout.precision(digits); // Show all the digits cout << "pi = "<< pi << endl; cout << "eps = "<< eps << endl; cout << "base = "<< base << endl; cout << "prec = "<< prec << endl; cout << "b.digits = "<< bindigits << endl; cout << "rnd = "<< rnd << endl; cout << "maxval = "<< maxval << endl; cout << "minval = "<< minval << endl; cout << "small = "<< small << endl; cout << "sfmin = "<< sfmin << endl; cout << "1/sfmin = "<< 1 / sfmin << endl; cout << "round = "<< round << endl; cout << "max_exp = "<< max_exp << endl; cout << "min_exp = "<< min_exp << endl; cout << "underflow = "<< underflow << endl; cout << "overflow = "<< overflow << endl; return 0; } mpfrc++-3.5.6+ds/example/makefile000066400000000000000000000001731222657617000165300ustar00rootroot00000000000000example: example.o g++ example.o -o example -lmpfr -lgmp example.o: example.cpp g++ -c example.cpp clean: rm -f *.o mpfrc++-3.5.6+ds/mpreal.h000066400000000000000000003213001222657617000150240ustar00rootroot00000000000000/* MPFR C++: Multi-precision floating point number class for C++. Based on MPFR library: http://mpfr.org Project homepage: http://www.holoborodko.com/pavel/mpfr Contact e-mail: pavel@holoborodko.com Copyright (c) 2008-2013 Pavel Holoborodko Contributors: Dmitriy Gubanov, Konstantin Holoborodko, Brian Gladman, Helmut Jarausch, Fokko Beekhof, Ulrich Mutze, Heinz van Saanen, Pere Constans, Peter van Hoof, Gael Guennebaud, Tsai Chia Cheng, Alexei Zubanov, Jauhien Piatlicki, Victor Berger, John Westwood. Licensing: (A) MPFR C++ is under GNU General Public License ("GPL"). (B) Non-free licenses may also be purchased from the author, for users who do not want their programs protected by the GPL. The non-free licenses are for users that wish to use MPFR C++ in their products but are unwilling to release their software under the GPL (which would require them to release source code and allow free redistribution). Such users can purchase an unlimited-use license from the author. Contact us for more details. GNU General Public License ("GPL") copyright permissions statement: ************************************************************************** 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 the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see . */ #ifndef __MPREAL_H__ #define __MPREAL_H__ #include #include #include #include #include #include #include #include // Options #define MPREAL_HAVE_INT64_SUPPORT // Enable int64_t support if possible. Available only for MSVC 2010 & GCC. #define MPREAL_HAVE_MSVC_DEBUGVIEW // Enable Debugger Visualizer for "Debug" builds in MSVC. // Detect compiler using signatures from http://predef.sourceforge.net/ #if defined(__GNUC__) && defined(__INTEL_COMPILER) #define IsInf(x) isinf(x) // Intel ICC compiler on Linux #elif defined(_MSC_VER) // Microsoft Visual C++ #define IsInf(x) (!_finite(x)) #else #define IsInf(x) std::isinf(x) // GNU C/C++ (and/or other compilers), just hope for C99 conformance #endif // Detect support for r-value references (move semantic). Borrowed from Eigen. // A Clang feature extension to determine compiler features. // We use it to determine 'cxx_rvalue_references' #ifndef __has_feature # define __has_feature(x) 0 #endif #if (__has_feature(cxx_rvalue_references) || \ defined(__GXX_EXPERIMENTAL_CXX0X__) || __cplusplus >= 201103L || \ (defined(_MSC_VER) && _MSC_VER >= 1600)) #define MPREAL_HAVE_MOVE_SUPPORT // Use fields in mpfr_t structure to check if it was initialized / set dummy initialization #define mpfr_is_initialized(x) (0 != (x)->_mpfr_d) #define mpfr_set_uninitialized(x) ((x)->_mpfr_d = 0 ) #endif // Detect available 64-bit capabilities #if defined(MPREAL_HAVE_INT64_SUPPORT) #define MPFR_USE_INTMAX_T // Should be defined before mpfr.h #if defined(_MSC_VER) // MSVC + Windows #if (_MSC_VER >= 1600) #include // is available only in msvc2010! #else // MPFR relies on intmax_t which is available only in msvc2010 #undef MPREAL_HAVE_INT64_SUPPORT // Besides, MPFR & MPIR have to be compiled with msvc2010 #undef MPFR_USE_INTMAX_T // Since we cannot detect this, disable x64 by default // Someone should change this manually if needed. #endif #elif defined (__GNUC__) && defined(__linux__) #if defined(__amd64__) || defined(__amd64) || defined(__x86_64__) || defined(__x86_64) || defined(__ia64) || defined(__itanium__) || defined(_M_IA64) #undef MPREAL_HAVE_INT64_SUPPORT // Remove all shaman dances for x64 builds since #undef MPFR_USE_INTMAX_T // GCC already supports x64 as of "long int" is 64-bit integer, nothing left to do #else #include // use int64_t, uint64_t otherwise #endif #else #include // rely on int64_t, uint64_t in all other cases, Mac OSX, etc. #endif #endif #if defined(MPREAL_HAVE_MSVC_DEBUGVIEW) && defined(_MSC_VER) && defined(_DEBUG) #define MPREAL_MSVC_DEBUGVIEW_CODE DebugView = toString(); #define MPREAL_MSVC_DEBUGVIEW_DATA std::string DebugView; #else #define MPREAL_MSVC_DEBUGVIEW_CODE #define MPREAL_MSVC_DEBUGVIEW_DATA #endif #include #if (MPFR_VERSION < MPFR_VERSION_NUM(3,0,0)) #include // Needed for random() #endif // Less important options #define MPREAL_DOUBLE_BITS_OVERFLOW -1 // Triggers overflow exception during conversion to double if mpreal // cannot fit in MPREAL_DOUBLE_BITS_OVERFLOW bits // = -1 disables overflow checks (default) #if defined(__GNUC__) #define MPREAL_PERMISSIVE_EXPR __extension__ #else #define MPREAL_PERMISSIVE_EXPR #endif namespace mpfr { class mpreal { private: mpfr_t mp; public: // Get default rounding mode & precision inline static mp_rnd_t get_default_rnd() { return (mp_rnd_t)(mpfr_get_default_rounding_mode()); } inline static mp_prec_t get_default_prec() { return mpfr_get_default_prec(); } // Constructors && type conversions mpreal(); mpreal(const mpreal& u); mpreal(const mpf_t u); mpreal(const mpz_t u, mp_prec_t prec = mpreal::get_default_prec(), mp_rnd_t mode = mpreal::get_default_rnd()); mpreal(const mpq_t u, mp_prec_t prec = mpreal::get_default_prec(), mp_rnd_t mode = mpreal::get_default_rnd()); mpreal(const double u, mp_prec_t prec = mpreal::get_default_prec(), mp_rnd_t mode = mpreal::get_default_rnd()); mpreal(const long double u, mp_prec_t prec = mpreal::get_default_prec(), mp_rnd_t mode = mpreal::get_default_rnd()); mpreal(const unsigned long int u, mp_prec_t prec = mpreal::get_default_prec(), mp_rnd_t mode = mpreal::get_default_rnd()); mpreal(const unsigned int u, mp_prec_t prec = mpreal::get_default_prec(), mp_rnd_t mode = mpreal::get_default_rnd()); mpreal(const long int u, mp_prec_t prec = mpreal::get_default_prec(), mp_rnd_t mode = mpreal::get_default_rnd()); mpreal(const int u, mp_prec_t prec = mpreal::get_default_prec(), mp_rnd_t mode = mpreal::get_default_rnd()); // Construct mpreal from mpfr_t structure. // shared = true allows to avoid deep copy, so that mpreal and 'u' shared same data & pointers. mpreal(const mpfr_t u, bool shared = false); #if defined (MPREAL_HAVE_INT64_SUPPORT) mpreal(const uint64_t u, mp_prec_t prec = mpreal::get_default_prec(), mp_rnd_t mode = mpreal::get_default_rnd()); mpreal(const int64_t u, mp_prec_t prec = mpreal::get_default_prec(), mp_rnd_t mode = mpreal::get_default_rnd()); #endif mpreal(const char* s, mp_prec_t prec = mpreal::get_default_prec(), int base = 10, mp_rnd_t mode = mpreal::get_default_rnd()); mpreal(const std::string& s, mp_prec_t prec = mpreal::get_default_prec(), int base = 10, mp_rnd_t mode = mpreal::get_default_rnd()); ~mpreal(); #ifdef MPREAL_HAVE_MOVE_SUPPORT mpreal& operator=(mpreal&& v); mpreal(mpreal&& u); #endif // Operations // = // +, -, *, /, ++, --, <<, >> // *=, +=, -=, /=, // <, >, ==, <=, >= // = mpreal& operator=(const mpreal& v); mpreal& operator=(const mpf_t v); mpreal& operator=(const mpz_t v); mpreal& operator=(const mpq_t v); mpreal& operator=(const long double v); mpreal& operator=(const double v); mpreal& operator=(const unsigned long int v); mpreal& operator=(const unsigned int v); mpreal& operator=(const long int v); mpreal& operator=(const int v); mpreal& operator=(const char* s); mpreal& operator=(const std::string& s); // + mpreal& operator+=(const mpreal& v); mpreal& operator+=(const mpf_t v); mpreal& operator+=(const mpz_t v); mpreal& operator+=(const mpq_t v); mpreal& operator+=(const long double u); mpreal& operator+=(const double u); mpreal& operator+=(const unsigned long int u); mpreal& operator+=(const unsigned int u); mpreal& operator+=(const long int u); mpreal& operator+=(const int u); #if defined (MPREAL_HAVE_INT64_SUPPORT) mpreal& operator+=(const int64_t u); mpreal& operator+=(const uint64_t u); mpreal& operator-=(const int64_t u); mpreal& operator-=(const uint64_t u); mpreal& operator*=(const int64_t u); mpreal& operator*=(const uint64_t u); mpreal& operator/=(const int64_t u); mpreal& operator/=(const uint64_t u); #endif const mpreal operator+() const; mpreal& operator++ (); const mpreal operator++ (int); // - mpreal& operator-=(const mpreal& v); mpreal& operator-=(const mpz_t v); mpreal& operator-=(const mpq_t v); mpreal& operator-=(const long double u); mpreal& operator-=(const double u); mpreal& operator-=(const unsigned long int u); mpreal& operator-=(const unsigned int u); mpreal& operator-=(const long int u); mpreal& operator-=(const int u); const mpreal operator-() const; friend const mpreal operator-(const unsigned long int b, const mpreal& a); friend const mpreal operator-(const unsigned int b, const mpreal& a); friend const mpreal operator-(const long int b, const mpreal& a); friend const mpreal operator-(const int b, const mpreal& a); friend const mpreal operator-(const double b, const mpreal& a); mpreal& operator-- (); const mpreal operator-- (int); // * mpreal& operator*=(const mpreal& v); mpreal& operator*=(const mpz_t v); mpreal& operator*=(const mpq_t v); mpreal& operator*=(const long double v); mpreal& operator*=(const double v); mpreal& operator*=(const unsigned long int v); mpreal& operator*=(const unsigned int v); mpreal& operator*=(const long int v); mpreal& operator*=(const int v); // / mpreal& operator/=(const mpreal& v); mpreal& operator/=(const mpz_t v); mpreal& operator/=(const mpq_t v); mpreal& operator/=(const long double v); mpreal& operator/=(const double v); mpreal& operator/=(const unsigned long int v); mpreal& operator/=(const unsigned int v); mpreal& operator/=(const long int v); mpreal& operator/=(const int v); friend const mpreal operator/(const unsigned long int b, const mpreal& a); friend const mpreal operator/(const unsigned int b, const mpreal& a); friend const mpreal operator/(const long int b, const mpreal& a); friend const mpreal operator/(const int b, const mpreal& a); friend const mpreal operator/(const double b, const mpreal& a); //<<= Fast Multiplication by 2^u mpreal& operator<<=(const unsigned long int u); mpreal& operator<<=(const unsigned int u); mpreal& operator<<=(const long int u); mpreal& operator<<=(const int u); //>>= Fast Division by 2^u mpreal& operator>>=(const unsigned long int u); mpreal& operator>>=(const unsigned int u); mpreal& operator>>=(const long int u); mpreal& operator>>=(const int u); // Boolean Operators friend bool operator > (const mpreal& a, const mpreal& b); friend bool operator >= (const mpreal& a, const mpreal& b); friend bool operator < (const mpreal& a, const mpreal& b); friend bool operator <= (const mpreal& a, const mpreal& b); friend bool operator == (const mpreal& a, const mpreal& b); friend bool operator != (const mpreal& a, const mpreal& b); // Optimized specializations for boolean operators friend bool operator == (const mpreal& a, const unsigned long int b); friend bool operator == (const mpreal& a, const unsigned int b); friend bool operator == (const mpreal& a, const long int b); friend bool operator == (const mpreal& a, const int b); friend bool operator == (const mpreal& a, const long double b); friend bool operator == (const mpreal& a, const double b); // Type Conversion operators long toLong (mp_rnd_t mode = GMP_RNDZ) const; unsigned long toULong (mp_rnd_t mode = GMP_RNDZ) const; double toDouble (mp_rnd_t mode = GMP_RNDN) const; long double toLDouble (mp_rnd_t mode = GMP_RNDN) const; #if defined (MPREAL_HAVE_INT64_SUPPORT) int64_t toInt64 (mp_rnd_t mode = GMP_RNDZ) const; uint64_t toUInt64 (mp_rnd_t mode = GMP_RNDZ) const; #endif // Get raw pointers so that mpreal can be directly used in raw mpfr_* functions ::mpfr_ptr mpfr_ptr(); ::mpfr_srcptr mpfr_ptr() const; ::mpfr_srcptr mpfr_srcptr() const; // Convert mpreal to string with n significant digits in base b // n = 0 -> convert with the maximum available digits std::string toString(int n = 0, int b = 10, mp_rnd_t mode = mpreal::get_default_rnd()) const; #if (MPFR_VERSION >= MPFR_VERSION_NUM(2,4,0)) std::string toString(const std::string& format) const; #endif // Math Functions friend const mpreal sqr (const mpreal& v, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); friend const mpreal sqrt(const mpreal& v, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); friend const mpreal sqrt(const unsigned long int v, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); friend const mpreal cbrt(const mpreal& v, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); friend const mpreal root(const mpreal& v, unsigned long int k, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); friend const mpreal pow (const mpreal& a, const mpreal& b, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); friend const mpreal pow (const mpreal& a, const mpz_t b, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); friend const mpreal pow (const mpreal& a, const unsigned long int b, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); friend const mpreal pow (const mpreal& a, const long int b, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); friend const mpreal pow (const unsigned long int a, const mpreal& b, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); friend const mpreal pow (const unsigned long int a, const unsigned long int b, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); friend const mpreal fabs(const mpreal& v, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); friend const mpreal abs(const mpreal& v, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); friend const mpreal dim(const mpreal& a, const mpreal& b, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); friend inline const mpreal mul_2ui(const mpreal& v, unsigned long int k, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); friend inline const mpreal mul_2si(const mpreal& v, long int k, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); friend inline const mpreal div_2ui(const mpreal& v, unsigned long int k, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); friend inline const mpreal div_2si(const mpreal& v, long int k, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); friend int cmpabs(const mpreal& a,const mpreal& b); friend const mpreal log (const mpreal& v, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); friend const mpreal log2 (const mpreal& v, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); friend const mpreal log10(const mpreal& v, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); friend const mpreal exp (const mpreal& v, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); friend const mpreal exp2 (const mpreal& v, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); friend const mpreal exp10(const mpreal& v, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); friend const mpreal log1p(const mpreal& v, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); friend const mpreal expm1(const mpreal& v, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); friend const mpreal cos(const mpreal& v, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); friend const mpreal sin(const mpreal& v, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); friend const mpreal tan(const mpreal& v, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); friend const mpreal sec(const mpreal& v, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); friend const mpreal csc(const mpreal& v, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); friend const mpreal cot(const mpreal& v, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); friend int sin_cos(mpreal& s, mpreal& c, const mpreal& v, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); friend const mpreal acos (const mpreal& v, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); friend const mpreal asin (const mpreal& v, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); friend const mpreal atan (const mpreal& v, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); friend const mpreal atan2 (const mpreal& y, const mpreal& x, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); friend const mpreal acot (const mpreal& v, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); friend const mpreal asec (const mpreal& v, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); friend const mpreal acsc (const mpreal& v, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); friend const mpreal cosh (const mpreal& v, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); friend const mpreal sinh (const mpreal& v, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); friend const mpreal tanh (const mpreal& v, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); friend const mpreal sech (const mpreal& v, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); friend const mpreal csch (const mpreal& v, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); friend const mpreal coth (const mpreal& v, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); friend const mpreal acosh (const mpreal& v, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); friend const mpreal asinh (const mpreal& v, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); friend const mpreal atanh (const mpreal& v, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); friend const mpreal acoth (const mpreal& v, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); friend const mpreal asech (const mpreal& v, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); friend const mpreal acsch (const mpreal& v, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); friend const mpreal hypot (const mpreal& x, const mpreal& y, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); friend const mpreal fac_ui (unsigned long int v, mp_prec_t prec = mpreal::get_default_prec(), mp_rnd_t rnd_mode = mpreal::get_default_rnd()); friend const mpreal eint (const mpreal& v, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); friend const mpreal gamma (const mpreal& v, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); friend const mpreal lngamma (const mpreal& v, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); friend const mpreal lgamma (const mpreal& v, int *signp = 0, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); friend const mpreal zeta (const mpreal& v, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); friend const mpreal erf (const mpreal& v, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); friend const mpreal erfc (const mpreal& v, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); friend const mpreal besselj0 (const mpreal& v, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); friend const mpreal besselj1 (const mpreal& v, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); friend const mpreal besseljn (long n, const mpreal& v, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); friend const mpreal bessely0 (const mpreal& v, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); friend const mpreal bessely1 (const mpreal& v, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); friend const mpreal besselyn (long n, const mpreal& v, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); friend const mpreal fma (const mpreal& v1, const mpreal& v2, const mpreal& v3, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); friend const mpreal fms (const mpreal& v1, const mpreal& v2, const mpreal& v3, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); friend const mpreal agm (const mpreal& v1, const mpreal& v2, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); friend const mpreal sum (const mpreal tab[], unsigned long int n, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); friend int sgn(const mpreal& v); // returns -1 or +1 // MPFR 2.4.0 Specifics #if (MPFR_VERSION >= MPFR_VERSION_NUM(2,4,0)) friend int sinh_cosh (mpreal& s, mpreal& c, const mpreal& v, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); friend const mpreal li2 (const mpreal& v, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); friend const mpreal fmod (const mpreal& x, const mpreal& y, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); friend const mpreal rec_sqrt (const mpreal& v, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); // MATLAB's semantic equivalents friend const mpreal rem (const mpreal& x, const mpreal& y, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); // Remainder after division friend const mpreal mod (const mpreal& x, const mpreal& y, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); // Modulus after division #endif // MPFR 3.0.0 Specifics #if (MPFR_VERSION >= MPFR_VERSION_NUM(3,0,0)) friend const mpreal digamma (const mpreal& v, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); friend const mpreal ai (const mpreal& v, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); friend const mpreal urandom (gmp_randstate_t& state, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); // use gmp_randinit_default() to init state, gmp_randclear() to clear friend const mpreal grandom (gmp_randstate_t& state, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); // use gmp_randinit_default() to init state, gmp_randclear() to clear friend const mpreal grandom (unsigned int seed = 0); #endif // Uniformly distributed random number generation in [0,1] using // Mersenne-Twister algorithm by default. // Use parameter to setup seed, e.g.: random((unsigned)time(NULL)) // Check urandom() for more precise control. friend const mpreal random(unsigned int seed = 0); // Exponent and mantissa manipulation friend const mpreal frexp(const mpreal& v, mp_exp_t* exp); friend const mpreal ldexp(const mpreal& v, mp_exp_t exp); // Splits mpreal value into fractional and integer parts. // Returns fractional part and stores integer part in n. friend const mpreal modf(const mpreal& v, mpreal& n); // Constants // don't forget to call mpfr_free_cache() for every thread where you are using const-functions friend const mpreal const_log2 (mp_prec_t prec = mpreal::get_default_prec(), mp_rnd_t rnd_mode = mpreal::get_default_rnd()); friend const mpreal const_pi (mp_prec_t prec = mpreal::get_default_prec(), mp_rnd_t rnd_mode = mpreal::get_default_rnd()); friend const mpreal const_euler (mp_prec_t prec = mpreal::get_default_prec(), mp_rnd_t rnd_mode = mpreal::get_default_rnd()); friend const mpreal const_catalan (mp_prec_t prec = mpreal::get_default_prec(), mp_rnd_t rnd_mode = mpreal::get_default_rnd()); // returns +inf iff sign>=0 otherwise -inf friend const mpreal const_infinity(int sign = 1, mp_prec_t prec = mpreal::get_default_prec(), mp_rnd_t rnd_mode = mpreal::get_default_rnd()); // Output/ Input friend std::ostream& operator<<(std::ostream& os, const mpreal& v); friend std::istream& operator>>(std::istream& is, mpreal& v); // Integer Related Functions friend const mpreal rint (const mpreal& v, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); friend const mpreal ceil (const mpreal& v); friend const mpreal floor(const mpreal& v); friend const mpreal round(const mpreal& v); friend const mpreal trunc(const mpreal& v); friend const mpreal rint_ceil (const mpreal& v, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); friend const mpreal rint_floor (const mpreal& v, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); friend const mpreal rint_round (const mpreal& v, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); friend const mpreal rint_trunc (const mpreal& v, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); friend const mpreal frac (const mpreal& v, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); friend const mpreal remainder ( const mpreal& x, const mpreal& y, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); friend const mpreal remquo (long* q, const mpreal& x, const mpreal& y, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); // Miscellaneous Functions friend const mpreal nexttoward (const mpreal& x, const mpreal& y); friend const mpreal nextabove (const mpreal& x); friend const mpreal nextbelow (const mpreal& x); // use gmp_randinit_default() to init state, gmp_randclear() to clear friend const mpreal urandomb (gmp_randstate_t& state); // MPFR < 2.4.2 Specifics #if (MPFR_VERSION <= MPFR_VERSION_NUM(2,4,2)) friend const mpreal random2 (mp_size_t size, mp_exp_t exp); #endif // Instance Checkers friend bool isnan (const mpreal& v); friend bool isinf (const mpreal& v); friend bool isfinite (const mpreal& v); friend bool isnum (const mpreal& v); friend bool iszero (const mpreal& v); friend bool isint (const mpreal& v); #if (MPFR_VERSION >= MPFR_VERSION_NUM(3,0,0)) friend bool isregular(const mpreal& v); #endif // Set/Get instance properties inline mp_prec_t get_prec() const; inline void set_prec(mp_prec_t prec, mp_rnd_t rnd_mode = get_default_rnd()); // Change precision with rounding mode // Aliases for get_prec(), set_prec() - needed for compatibility with std::complex interface inline mpreal& setPrecision(int Precision, mp_rnd_t RoundingMode = get_default_rnd()); inline int getPrecision() const; // Set mpreal to +/- inf, NaN, +/-0 mpreal& setInf (int Sign = +1); mpreal& setNan (); mpreal& setZero (int Sign = +1); mpreal& setSign (int Sign, mp_rnd_t RoundingMode = get_default_rnd()); //Exponent mp_exp_t get_exp(); int set_exp(mp_exp_t e); int check_range (int t, mp_rnd_t rnd_mode = get_default_rnd()); int subnormalize (int t,mp_rnd_t rnd_mode = get_default_rnd()); // Inexact conversion from float inline bool fits_in_bits(double x, int n); // Set/Get global properties static void set_default_prec(mp_prec_t prec); static void set_default_rnd(mp_rnd_t rnd_mode); static mp_exp_t get_emin (void); static mp_exp_t get_emax (void); static mp_exp_t get_emin_min (void); static mp_exp_t get_emin_max (void); static mp_exp_t get_emax_min (void); static mp_exp_t get_emax_max (void); static int set_emin (mp_exp_t exp); static int set_emax (mp_exp_t exp); // Efficient swapping of two mpreal values - needed for std algorithms friend void swap(mpreal& x, mpreal& y); friend const mpreal fmax(const mpreal& x, const mpreal& y, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); friend const mpreal fmin(const mpreal& x, const mpreal& y, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); private: // Human friendly Debug Preview in Visual Studio. // Put one of these lines: // // mpfr::mpreal= ; Show value only // mpfr::mpreal=, bits ; Show value & precision // // at the beginning of // [Visual Studio Installation Folder]\Common7\Packages\Debugger\autoexp.dat MPREAL_MSVC_DEBUGVIEW_DATA // "Smart" resources deallocation. Checks if instance initialized before deletion. void clear(::mpfr_ptr); }; ////////////////////////////////////////////////////////////////////////// // Exceptions class conversion_overflow : public std::exception { public: std::string why() { return "inexact conversion from floating point"; } }; ////////////////////////////////////////////////////////////////////////// // Constructors & converters // Default constructor: creates mp number and initializes it to 0. inline mpreal::mpreal() { mpfr_init2(mp,mpreal::get_default_prec()); mpfr_set_ui(mp,0,mpreal::get_default_rnd()); MPREAL_MSVC_DEBUGVIEW_CODE; } inline mpreal::mpreal(const mpreal& u) { mpfr_init2(mp,mpfr_get_prec(u.mp)); mpfr_set(mp,u.mp,mpreal::get_default_rnd()); MPREAL_MSVC_DEBUGVIEW_CODE; } #ifdef MPREAL_HAVE_MOVE_SUPPORT inline mpreal::mpreal(mpreal&& other) { mpfr_set_uninitialized(mpfr_ptr()); // make sure "other" holds no pinter to actual data mpfr_swap(mpfr_ptr(), other.mpfr_ptr()); MPREAL_MSVC_DEBUGVIEW_CODE; } inline mpreal& mpreal::operator=(mpreal&& other) { mpfr_swap(mpfr_ptr(), other.mpfr_ptr()); MPREAL_MSVC_DEBUGVIEW_CODE; return *this; } #endif inline mpreal::mpreal(const mpfr_t u, bool shared) { if(shared) { std::memcpy(mp, u, sizeof(mpfr_t)); } else { mpfr_init2(mp, mpfr_get_prec(u)); mpfr_set (mp, u, mpreal::get_default_rnd()); } MPREAL_MSVC_DEBUGVIEW_CODE; } inline mpreal::mpreal(const mpf_t u) { mpfr_init2(mp,(mp_prec_t) mpf_get_prec(u)); // (gmp: mp_bitcnt_t) unsigned long -> long (mpfr: mp_prec_t) mpfr_set_f(mp,u,mpreal::get_default_rnd()); MPREAL_MSVC_DEBUGVIEW_CODE; } inline mpreal::mpreal(const mpz_t u, mp_prec_t prec, mp_rnd_t mode) { mpfr_init2(mp,prec); mpfr_set_z(mp,u,mode); MPREAL_MSVC_DEBUGVIEW_CODE; } inline mpreal::mpreal(const mpq_t u, mp_prec_t prec, mp_rnd_t mode) { mpfr_init2(mp,prec); mpfr_set_q(mp,u,mode); MPREAL_MSVC_DEBUGVIEW_CODE; } inline mpreal::mpreal(const double u, mp_prec_t prec, mp_rnd_t mode) { mpfr_init2(mp, prec); #if (MPREAL_DOUBLE_BITS_OVERFLOW > -1) if(fits_in_bits(u, MPREAL_DOUBLE_BITS_OVERFLOW)) { mpfr_set_d(mp, u, mode); }else throw conversion_overflow(); #else mpfr_set_d(mp, u, mode); #endif MPREAL_MSVC_DEBUGVIEW_CODE; } inline mpreal::mpreal(const long double u, mp_prec_t prec, mp_rnd_t mode) { mpfr_init2(mp,prec); mpfr_set_ld(mp,u,mode); MPREAL_MSVC_DEBUGVIEW_CODE; } inline mpreal::mpreal(const unsigned long int u, mp_prec_t prec, mp_rnd_t mode) { mpfr_init2(mp,prec); mpfr_set_ui(mp,u,mode); MPREAL_MSVC_DEBUGVIEW_CODE; } inline mpreal::mpreal(const unsigned int u, mp_prec_t prec, mp_rnd_t mode) { mpfr_init2(mp,prec); mpfr_set_ui(mp,u,mode); MPREAL_MSVC_DEBUGVIEW_CODE; } inline mpreal::mpreal(const long int u, mp_prec_t prec, mp_rnd_t mode) { mpfr_init2(mp,prec); mpfr_set_si(mp,u,mode); MPREAL_MSVC_DEBUGVIEW_CODE; } inline mpreal::mpreal(const int u, mp_prec_t prec, mp_rnd_t mode) { mpfr_init2(mp,prec); mpfr_set_si(mp,u,mode); MPREAL_MSVC_DEBUGVIEW_CODE; } #if defined (MPREAL_HAVE_INT64_SUPPORT) inline mpreal::mpreal(const uint64_t u, mp_prec_t prec, mp_rnd_t mode) { mpfr_init2(mp,prec); mpfr_set_uj(mp, u, mode); MPREAL_MSVC_DEBUGVIEW_CODE; } inline mpreal::mpreal(const int64_t u, mp_prec_t prec, mp_rnd_t mode) { mpfr_init2(mp,prec); mpfr_set_sj(mp, u, mode); MPREAL_MSVC_DEBUGVIEW_CODE; } #endif inline mpreal::mpreal(const char* s, mp_prec_t prec, int base, mp_rnd_t mode) { mpfr_init2(mp, prec); mpfr_set_str(mp, s, base, mode); MPREAL_MSVC_DEBUGVIEW_CODE; } inline mpreal::mpreal(const std::string& s, mp_prec_t prec, int base, mp_rnd_t mode) { mpfr_init2(mp, prec); mpfr_set_str(mp, s.c_str(), base, mode); MPREAL_MSVC_DEBUGVIEW_CODE; } inline void mpreal::clear(::mpfr_ptr x) { #ifdef MPREAL_HAVE_MOVE_SUPPORT if(mpfr_is_initialized(x)) #endif mpfr_clear(x); } inline mpreal::~mpreal() { clear(mpfr_ptr()); } // internal namespace needed for template magic namespace internal{ // Use SFINAE to restrict arithmetic operations instantiation only for numeric types // This is needed for smooth integration with libraries based on expression templates, like Eigen. // TODO: Do the same for boolean operators. template struct result_type {}; template <> struct result_type {typedef mpreal type;}; template <> struct result_type {typedef mpreal type;}; template <> struct result_type {typedef mpreal type;}; template <> struct result_type {typedef mpreal type;}; template <> struct result_type {typedef mpreal type;}; template <> struct result_type {typedef mpreal type;}; template <> struct result_type {typedef mpreal type;}; template <> struct result_type {typedef mpreal type;}; template <> struct result_type {typedef mpreal type;}; #if defined (MPREAL_HAVE_INT64_SUPPORT) template <> struct result_type {typedef mpreal type;}; template <> struct result_type {typedef mpreal type;}; #endif } // + Addition template inline const typename internal::result_type::type operator+(const mpreal& lhs, const Rhs& rhs){ return mpreal(lhs) += rhs; } template inline const typename internal::result_type::type operator+(const Lhs& lhs, const mpreal& rhs){ return mpreal(rhs) += lhs; } // - Subtraction template inline const typename internal::result_type::type operator-(const mpreal& lhs, const Rhs& rhs){ return mpreal(lhs) -= rhs; } template inline const typename internal::result_type::type operator-(const Lhs& lhs, const mpreal& rhs){ return mpreal(lhs) -= rhs; } // * Multiplication template inline const typename internal::result_type::type operator*(const mpreal& lhs, const Rhs& rhs){ return mpreal(lhs) *= rhs; } template inline const typename internal::result_type::type operator*(const Lhs& lhs, const mpreal& rhs){ return mpreal(rhs) *= lhs; } // / Division template inline const typename internal::result_type::type operator/(const mpreal& lhs, const Rhs& rhs){ return mpreal(lhs) /= rhs; } template inline const typename internal::result_type::type operator/(const Lhs& lhs, const mpreal& rhs){ return mpreal(lhs) /= rhs; } ////////////////////////////////////////////////////////////////////////// // sqrt const mpreal sqrt(const unsigned int v, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); const mpreal sqrt(const long int v, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); const mpreal sqrt(const int v, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); const mpreal sqrt(const long double v, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); const mpreal sqrt(const double v, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); ////////////////////////////////////////////////////////////////////////// // pow const mpreal pow(const mpreal& a, const unsigned int b, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); const mpreal pow(const mpreal& a, const int b, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); const mpreal pow(const mpreal& a, const long double b, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); const mpreal pow(const mpreal& a, const double b, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); const mpreal pow(const unsigned int a, const mpreal& b, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); const mpreal pow(const long int a, const mpreal& b, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); const mpreal pow(const int a, const mpreal& b, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); const mpreal pow(const long double a, const mpreal& b, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); const mpreal pow(const double a, const mpreal& b, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); const mpreal pow(const unsigned long int a, const unsigned int b, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); const mpreal pow(const unsigned long int a, const long int b, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); const mpreal pow(const unsigned long int a, const int b, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); const mpreal pow(const unsigned long int a, const long double b, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); const mpreal pow(const unsigned long int a, const double b, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); const mpreal pow(const unsigned int a, const unsigned long int b, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); const mpreal pow(const unsigned int a, const unsigned int b, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); const mpreal pow(const unsigned int a, const long int b, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); const mpreal pow(const unsigned int a, const int b, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); const mpreal pow(const unsigned int a, const long double b, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); const mpreal pow(const unsigned int a, const double b, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); const mpreal pow(const long int a, const unsigned long int b, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); const mpreal pow(const long int a, const unsigned int b, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); const mpreal pow(const long int a, const long int b, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); const mpreal pow(const long int a, const int b, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); const mpreal pow(const long int a, const long double b, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); const mpreal pow(const long int a, const double b, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); const mpreal pow(const int a, const unsigned long int b, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); const mpreal pow(const int a, const unsigned int b, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); const mpreal pow(const int a, const long int b, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); const mpreal pow(const int a, const int b, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); const mpreal pow(const int a, const long double b, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); const mpreal pow(const int a, const double b, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); const mpreal pow(const long double a, const long double b, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); const mpreal pow(const long double a, const unsigned long int b, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); const mpreal pow(const long double a, const unsigned int b, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); const mpreal pow(const long double a, const long int b, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); const mpreal pow(const long double a, const int b, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); const mpreal pow(const double a, const double b, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); const mpreal pow(const double a, const unsigned long int b, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); const mpreal pow(const double a, const unsigned int b, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); const mpreal pow(const double a, const long int b, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); const mpreal pow(const double a, const int b, mp_rnd_t rnd_mode = mpreal::get_default_rnd()); ////////////////////////////////////////////////////////////////////////// // Estimate machine epsilon for the given precision // Returns smallest eps such that 1.0 + eps != 1.0 inline mpreal machine_epsilon(mp_prec_t prec = mpreal::get_default_prec()); // Returns smallest eps such that x + eps != x (relative machine epsilon) inline mpreal machine_epsilon(const mpreal& x); // Gives max & min values for the required precision, // minval is 'safe' meaning 1 / minval does not overflow // maxval is 'safe' meaning 1 / maxval does not underflow inline mpreal minval(mp_prec_t prec = mpreal::get_default_prec()); inline mpreal maxval(mp_prec_t prec = mpreal::get_default_prec()); // 'Dirty' equality check 1: |a-b| < min{|a|,|b|} * eps inline bool isEqualFuzzy(const mpreal& a, const mpreal& b, const mpreal& eps); // 'Dirty' equality check 2: |a-b| < min{|a|,|b|} * eps( min{|a|,|b|} ) inline bool isEqualFuzzy(const mpreal& a, const mpreal& b); // 'Bitwise' equality check // maxUlps - a and b can be apart by maxUlps binary numbers. inline bool isEqualUlps(const mpreal& a, const mpreal& b, int maxUlps); ////////////////////////////////////////////////////////////////////////// // Convert precision in 'bits' to decimal digits and vice versa. // bits = ceil(digits*log[2](10)) // digits = floor(bits*log[10](2)) inline mp_prec_t digits2bits(int d); inline int bits2digits(mp_prec_t b); ////////////////////////////////////////////////////////////////////////// // min, max const mpreal (max)(const mpreal& x, const mpreal& y); const mpreal (min)(const mpreal& x, const mpreal& y); ////////////////////////////////////////////////////////////////////////// // Implementation ////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////// // Operators - Assignment inline mpreal& mpreal::operator=(const mpreal& v) { if (this != &v) { mp_prec_t tp = mpfr_get_prec(mp); mp_prec_t vp = mpfr_get_prec(v.mp); if(tp != vp){ clear(mpfr_ptr()); mpfr_init2(mpfr_ptr(), vp); } mpfr_set(mp, v.mp, mpreal::get_default_rnd()); MPREAL_MSVC_DEBUGVIEW_CODE; } return *this; } inline mpreal& mpreal::operator=(const mpf_t v) { mpfr_set_f(mp, v, mpreal::get_default_rnd()); MPREAL_MSVC_DEBUGVIEW_CODE; return *this; } inline mpreal& mpreal::operator=(const mpz_t v) { mpfr_set_z(mp, v, mpreal::get_default_rnd()); MPREAL_MSVC_DEBUGVIEW_CODE; return *this; } inline mpreal& mpreal::operator=(const mpq_t v) { mpfr_set_q(mp, v, mpreal::get_default_rnd()); MPREAL_MSVC_DEBUGVIEW_CODE; return *this; } inline mpreal& mpreal::operator=(const long double v) { mpfr_set_ld(mp, v, mpreal::get_default_rnd()); MPREAL_MSVC_DEBUGVIEW_CODE; return *this; } inline mpreal& mpreal::operator=(const double v) { #if (MPREAL_DOUBLE_BITS_OVERFLOW > -1) if(fits_in_bits(v, MPREAL_DOUBLE_BITS_OVERFLOW)) { mpfr_set_d(mp,v,mpreal::get_default_rnd()); }else throw conversion_overflow(); #else mpfr_set_d(mp,v,mpreal::get_default_rnd()); #endif MPREAL_MSVC_DEBUGVIEW_CODE; return *this; } inline mpreal& mpreal::operator=(const unsigned long int v) { mpfr_set_ui(mp, v, mpreal::get_default_rnd()); MPREAL_MSVC_DEBUGVIEW_CODE; return *this; } inline mpreal& mpreal::operator=(const unsigned int v) { mpfr_set_ui(mp, v, mpreal::get_default_rnd()); MPREAL_MSVC_DEBUGVIEW_CODE; return *this; } inline mpreal& mpreal::operator=(const long int v) { mpfr_set_si(mp, v, mpreal::get_default_rnd()); MPREAL_MSVC_DEBUGVIEW_CODE; return *this; } inline mpreal& mpreal::operator=(const int v) { mpfr_set_si(mp, v, mpreal::get_default_rnd()); MPREAL_MSVC_DEBUGVIEW_CODE; return *this; } inline mpreal& mpreal::operator=(const char* s) { // Use other converters for more precise control on base & precision & rounding: // // mpreal(const char* s, mp_prec_t prec, int base, mp_rnd_t mode) // mpreal(const std::string& s,mp_prec_t prec, int base, mp_rnd_t mode) // // Here we assume base = 10 and we use precision of target variable. mpfr_t t; mpfr_init2(t, mpfr_get_prec(mp)); if(0 == mpfr_set_str(t, s, 10, mpreal::get_default_rnd())) { mpfr_set(mp, t, mpreal::get_default_rnd()); MPREAL_MSVC_DEBUGVIEW_CODE; } clear(t); return *this; } inline mpreal& mpreal::operator=(const std::string& s) { // Use other converters for more precise control on base & precision & rounding: // // mpreal(const char* s, mp_prec_t prec, int base, mp_rnd_t mode) // mpreal(const std::string& s,mp_prec_t prec, int base, mp_rnd_t mode) // // Here we assume base = 10 and we use precision of target variable. mpfr_t t; mpfr_init2(t, mpfr_get_prec(mp)); if(0 == mpfr_set_str(t, s.c_str(), 10, mpreal::get_default_rnd())) { mpfr_set(mp, t, mpreal::get_default_rnd()); MPREAL_MSVC_DEBUGVIEW_CODE; } clear(t); return *this; } ////////////////////////////////////////////////////////////////////////// // + Addition inline mpreal& mpreal::operator+=(const mpreal& v) { mpfr_add(mp,mp,v.mp,mpreal::get_default_rnd()); MPREAL_MSVC_DEBUGVIEW_CODE; return *this; } inline mpreal& mpreal::operator+=(const mpf_t u) { *this += mpreal(u); MPREAL_MSVC_DEBUGVIEW_CODE; return *this; } inline mpreal& mpreal::operator+=(const mpz_t u) { mpfr_add_z(mp,mp,u,mpreal::get_default_rnd()); MPREAL_MSVC_DEBUGVIEW_CODE; return *this; } inline mpreal& mpreal::operator+=(const mpq_t u) { mpfr_add_q(mp,mp,u,mpreal::get_default_rnd()); MPREAL_MSVC_DEBUGVIEW_CODE; return *this; } inline mpreal& mpreal::operator+= (const long double u) { *this += mpreal(u); MPREAL_MSVC_DEBUGVIEW_CODE; return *this; } inline mpreal& mpreal::operator+= (const double u) { #if (MPFR_VERSION >= MPFR_VERSION_NUM(2,4,0)) mpfr_add_d(mp,mp,u,mpreal::get_default_rnd()); #else *this += mpreal(u); #endif MPREAL_MSVC_DEBUGVIEW_CODE; return *this; } inline mpreal& mpreal::operator+=(const unsigned long int u) { mpfr_add_ui(mp,mp,u,mpreal::get_default_rnd()); MPREAL_MSVC_DEBUGVIEW_CODE; return *this; } inline mpreal& mpreal::operator+=(const unsigned int u) { mpfr_add_ui(mp,mp,u,mpreal::get_default_rnd()); MPREAL_MSVC_DEBUGVIEW_CODE; return *this; } inline mpreal& mpreal::operator+=(const long int u) { mpfr_add_si(mp,mp,u,mpreal::get_default_rnd()); MPREAL_MSVC_DEBUGVIEW_CODE; return *this; } inline mpreal& mpreal::operator+=(const int u) { mpfr_add_si(mp,mp,u,mpreal::get_default_rnd()); MPREAL_MSVC_DEBUGVIEW_CODE; return *this; } #if defined (MPREAL_HAVE_INT64_SUPPORT) inline mpreal& mpreal::operator+=(const int64_t u){ *this += mpreal(u); MPREAL_MSVC_DEBUGVIEW_CODE; return *this; } inline mpreal& mpreal::operator+=(const uint64_t u){ *this += mpreal(u); MPREAL_MSVC_DEBUGVIEW_CODE; return *this; } inline mpreal& mpreal::operator-=(const int64_t u){ *this -= mpreal(u); MPREAL_MSVC_DEBUGVIEW_CODE; return *this; } inline mpreal& mpreal::operator-=(const uint64_t u){ *this -= mpreal(u); MPREAL_MSVC_DEBUGVIEW_CODE; return *this; } inline mpreal& mpreal::operator*=(const int64_t u){ *this *= mpreal(u); MPREAL_MSVC_DEBUGVIEW_CODE; return *this; } inline mpreal& mpreal::operator*=(const uint64_t u){ *this *= mpreal(u); MPREAL_MSVC_DEBUGVIEW_CODE; return *this; } inline mpreal& mpreal::operator/=(const int64_t u){ *this /= mpreal(u); MPREAL_MSVC_DEBUGVIEW_CODE; return *this; } inline mpreal& mpreal::operator/=(const uint64_t u){ *this /= mpreal(u); MPREAL_MSVC_DEBUGVIEW_CODE; return *this; } #endif inline const mpreal mpreal::operator+()const { return mpreal(*this); } inline const mpreal operator+(const mpreal& a, const mpreal& b) { mpreal c(0, (std::max)(mpfr_get_prec(a.mpfr_ptr()), mpfr_get_prec(b.mpfr_ptr()))); mpfr_add(c.mpfr_ptr(), a.mpfr_srcptr(), b.mpfr_srcptr(), mpreal::get_default_rnd()); return c; } inline mpreal& mpreal::operator++() { return *this += 1; } inline const mpreal mpreal::operator++ (int) { mpreal x(*this); *this += 1; return x; } inline mpreal& mpreal::operator--() { return *this -= 1; } inline const mpreal mpreal::operator-- (int) { mpreal x(*this); *this -= 1; return x; } ////////////////////////////////////////////////////////////////////////// // - Subtraction inline mpreal& mpreal::operator-=(const mpreal& v) { mpfr_sub(mp,mp,v.mp,mpreal::get_default_rnd()); MPREAL_MSVC_DEBUGVIEW_CODE; return *this; } inline mpreal& mpreal::operator-=(const mpz_t v) { mpfr_sub_z(mp,mp,v,mpreal::get_default_rnd()); MPREAL_MSVC_DEBUGVIEW_CODE; return *this; } inline mpreal& mpreal::operator-=(const mpq_t v) { mpfr_sub_q(mp,mp,v,mpreal::get_default_rnd()); MPREAL_MSVC_DEBUGVIEW_CODE; return *this; } inline mpreal& mpreal::operator-=(const long double v) { *this -= mpreal(v); MPREAL_MSVC_DEBUGVIEW_CODE; return *this; } inline mpreal& mpreal::operator-=(const double v) { #if (MPFR_VERSION >= MPFR_VERSION_NUM(2,4,0)) mpfr_sub_d(mp,mp,v,mpreal::get_default_rnd()); #else *this -= mpreal(v); #endif MPREAL_MSVC_DEBUGVIEW_CODE; return *this; } inline mpreal& mpreal::operator-=(const unsigned long int v) { mpfr_sub_ui(mp,mp,v,mpreal::get_default_rnd()); MPREAL_MSVC_DEBUGVIEW_CODE; return *this; } inline mpreal& mpreal::operator-=(const unsigned int v) { mpfr_sub_ui(mp,mp,v,mpreal::get_default_rnd()); MPREAL_MSVC_DEBUGVIEW_CODE; return *this; } inline mpreal& mpreal::operator-=(const long int v) { mpfr_sub_si(mp,mp,v,mpreal::get_default_rnd()); MPREAL_MSVC_DEBUGVIEW_CODE; return *this; } inline mpreal& mpreal::operator-=(const int v) { mpfr_sub_si(mp,mp,v,mpreal::get_default_rnd()); MPREAL_MSVC_DEBUGVIEW_CODE; return *this; } inline const mpreal mpreal::operator-()const { mpreal u(*this); mpfr_neg(u.mp,u.mp,mpreal::get_default_rnd()); return u; } inline const mpreal operator-(const mpreal& a, const mpreal& b) { mpreal c(0, std::max(mpfr_get_prec(a.mpfr_ptr()), mpfr_get_prec(b.mpfr_ptr()))); mpfr_sub(c.mpfr_ptr(), a.mpfr_srcptr(), b.mpfr_srcptr(), mpreal::get_default_rnd()); return c; } inline const mpreal operator-(const double b, const mpreal& a) { #if (MPFR_VERSION >= MPFR_VERSION_NUM(2,4,0)) mpreal x(0, mpfr_get_prec(a.mpfr_ptr())); mpfr_d_sub(x.mpfr_ptr(), b, a.mpfr_srcptr(), mpreal::get_default_rnd()); return x; #else mpreal x(b, mpfr_get_prec(a.mpfr_ptr())); x -= a; return x; #endif } inline const mpreal operator-(const unsigned long int b, const mpreal& a) { mpreal x(0, mpfr_get_prec(a.mpfr_ptr())); mpfr_ui_sub(x.mpfr_ptr(), b, a.mpfr_srcptr(), mpreal::get_default_rnd()); return x; } inline const mpreal operator-(const unsigned int b, const mpreal& a) { mpreal x(0, mpfr_get_prec(a.mpfr_ptr())); mpfr_ui_sub(x.mpfr_ptr(), b, a.mpfr_srcptr(), mpreal::get_default_rnd()); return x; } inline const mpreal operator-(const long int b, const mpreal& a) { mpreal x(0, mpfr_get_prec(a.mpfr_ptr())); mpfr_si_sub(x.mpfr_ptr(), b, a.mpfr_srcptr(), mpreal::get_default_rnd()); return x; } inline const mpreal operator-(const int b, const mpreal& a) { mpreal x(0, mpfr_get_prec(a.mpfr_ptr())); mpfr_si_sub(x.mpfr_ptr(), b, a.mpfr_srcptr(), mpreal::get_default_rnd()); return x; } ////////////////////////////////////////////////////////////////////////// // * Multiplication inline mpreal& mpreal::operator*= (const mpreal& v) { mpfr_mul(mp,mp,v.mp,mpreal::get_default_rnd()); MPREAL_MSVC_DEBUGVIEW_CODE; return *this; } inline mpreal& mpreal::operator*=(const mpz_t v) { mpfr_mul_z(mp,mp,v,mpreal::get_default_rnd()); MPREAL_MSVC_DEBUGVIEW_CODE; return *this; } inline mpreal& mpreal::operator*=(const mpq_t v) { mpfr_mul_q(mp,mp,v,mpreal::get_default_rnd()); MPREAL_MSVC_DEBUGVIEW_CODE; return *this; } inline mpreal& mpreal::operator*=(const long double v) { *this *= mpreal(v); MPREAL_MSVC_DEBUGVIEW_CODE; return *this; } inline mpreal& mpreal::operator*=(const double v) { #if (MPFR_VERSION >= MPFR_VERSION_NUM(2,4,0)) mpfr_mul_d(mp,mp,v,mpreal::get_default_rnd()); #else *this *= mpreal(v); #endif MPREAL_MSVC_DEBUGVIEW_CODE; return *this; } inline mpreal& mpreal::operator*=(const unsigned long int v) { mpfr_mul_ui(mp,mp,v,mpreal::get_default_rnd()); MPREAL_MSVC_DEBUGVIEW_CODE; return *this; } inline mpreal& mpreal::operator*=(const unsigned int v) { mpfr_mul_ui(mp,mp,v,mpreal::get_default_rnd()); MPREAL_MSVC_DEBUGVIEW_CODE; return *this; } inline mpreal& mpreal::operator*=(const long int v) { mpfr_mul_si(mp,mp,v,mpreal::get_default_rnd()); MPREAL_MSVC_DEBUGVIEW_CODE; return *this; } inline mpreal& mpreal::operator*=(const int v) { mpfr_mul_si(mp,mp,v,mpreal::get_default_rnd()); MPREAL_MSVC_DEBUGVIEW_CODE; return *this; } inline const mpreal operator*(const mpreal& a, const mpreal& b) { mpreal c(0, std::max(mpfr_get_prec(a.mpfr_ptr()), mpfr_get_prec(b.mpfr_ptr()))); mpfr_mul(c.mpfr_ptr(), a.mpfr_srcptr(), b.mpfr_srcptr(), mpreal::get_default_rnd()); return c; } ////////////////////////////////////////////////////////////////////////// // / Division inline mpreal& mpreal::operator/=(const mpreal& v) { mpfr_div(mp,mp,v.mp,mpreal::get_default_rnd()); MPREAL_MSVC_DEBUGVIEW_CODE; return *this; } inline mpreal& mpreal::operator/=(const mpz_t v) { mpfr_div_z(mp,mp,v,mpreal::get_default_rnd()); MPREAL_MSVC_DEBUGVIEW_CODE; return *this; } inline mpreal& mpreal::operator/=(const mpq_t v) { mpfr_div_q(mp,mp,v,mpreal::get_default_rnd()); MPREAL_MSVC_DEBUGVIEW_CODE; return *this; } inline mpreal& mpreal::operator/=(const long double v) { *this /= mpreal(v); MPREAL_MSVC_DEBUGVIEW_CODE; return *this; } inline mpreal& mpreal::operator/=(const double v) { #if (MPFR_VERSION >= MPFR_VERSION_NUM(2,4,0)) mpfr_div_d(mp,mp,v,mpreal::get_default_rnd()); #else *this /= mpreal(v); #endif MPREAL_MSVC_DEBUGVIEW_CODE; return *this; } inline mpreal& mpreal::operator/=(const unsigned long int v) { mpfr_div_ui(mp,mp,v,mpreal::get_default_rnd()); MPREAL_MSVC_DEBUGVIEW_CODE; return *this; } inline mpreal& mpreal::operator/=(const unsigned int v) { mpfr_div_ui(mp,mp,v,mpreal::get_default_rnd()); MPREAL_MSVC_DEBUGVIEW_CODE; return *this; } inline mpreal& mpreal::operator/=(const long int v) { mpfr_div_si(mp,mp,v,mpreal::get_default_rnd()); MPREAL_MSVC_DEBUGVIEW_CODE; return *this; } inline mpreal& mpreal::operator/=(const int v) { mpfr_div_si(mp,mp,v,mpreal::get_default_rnd()); MPREAL_MSVC_DEBUGVIEW_CODE; return *this; } inline const mpreal operator/(const mpreal& a, const mpreal& b) { mpreal c(0, std::max(mpfr_get_prec(a.mpfr_ptr()), mpfr_get_prec(b.mpfr_ptr()))); mpfr_div(c.mpfr_ptr(), a.mpfr_srcptr(), b.mpfr_srcptr(), mpreal::get_default_rnd()); return c; } inline const mpreal operator/(const unsigned long int b, const mpreal& a) { mpreal x(0, mpfr_get_prec(a.mpfr_ptr())); mpfr_ui_div(x.mpfr_ptr(), b, a.mpfr_srcptr(), mpreal::get_default_rnd()); return x; } inline const mpreal operator/(const unsigned int b, const mpreal& a) { mpreal x(0, mpfr_get_prec(a.mpfr_ptr())); mpfr_ui_div(x.mpfr_ptr(), b, a.mpfr_srcptr(), mpreal::get_default_rnd()); return x; } inline const mpreal operator/(const long int b, const mpreal& a) { mpreal x(0, mpfr_get_prec(a.mpfr_ptr())); mpfr_si_div(x.mpfr_ptr(), b, a.mpfr_srcptr(),mpreal::get_default_rnd()); return x; } inline const mpreal operator/(const int b, const mpreal& a) { mpreal x(0, mpfr_get_prec(a.mpfr_ptr())); mpfr_si_div(x.mpfr_ptr(), b, a.mpfr_srcptr(),mpreal::get_default_rnd()); return x; } inline const mpreal operator/(const double b, const mpreal& a) { #if (MPFR_VERSION >= MPFR_VERSION_NUM(2,4,0)) mpreal x(0, mpfr_get_prec(a.mpfr_ptr())); mpfr_d_div(x.mpfr_ptr(), b, a.mpfr_srcptr(),mpreal::get_default_rnd()); return x; #else mpreal x(0, mpfr_get_prec(a.mpfr_ptr())); x /= a; return x; #endif } ////////////////////////////////////////////////////////////////////////// // Shifts operators - Multiplication/Division by power of 2 inline mpreal& mpreal::operator<<=(const unsigned long int u) { mpfr_mul_2ui(mp,mp,u,mpreal::get_default_rnd()); MPREAL_MSVC_DEBUGVIEW_CODE; return *this; } inline mpreal& mpreal::operator<<=(const unsigned int u) { mpfr_mul_2ui(mp,mp,static_cast(u),mpreal::get_default_rnd()); MPREAL_MSVC_DEBUGVIEW_CODE; return *this; } inline mpreal& mpreal::operator<<=(const long int u) { mpfr_mul_2si(mp,mp,u,mpreal::get_default_rnd()); MPREAL_MSVC_DEBUGVIEW_CODE; return *this; } inline mpreal& mpreal::operator<<=(const int u) { mpfr_mul_2si(mp,mp,static_cast(u),mpreal::get_default_rnd()); MPREAL_MSVC_DEBUGVIEW_CODE; return *this; } inline mpreal& mpreal::operator>>=(const unsigned long int u) { mpfr_div_2ui(mp,mp,u,mpreal::get_default_rnd()); MPREAL_MSVC_DEBUGVIEW_CODE; return *this; } inline mpreal& mpreal::operator>>=(const unsigned int u) { mpfr_div_2ui(mp,mp,static_cast(u),mpreal::get_default_rnd()); MPREAL_MSVC_DEBUGVIEW_CODE; return *this; } inline mpreal& mpreal::operator>>=(const long int u) { mpfr_div_2si(mp,mp,u,mpreal::get_default_rnd()); MPREAL_MSVC_DEBUGVIEW_CODE; return *this; } inline mpreal& mpreal::operator>>=(const int u) { mpfr_div_2si(mp,mp,static_cast(u),mpreal::get_default_rnd()); MPREAL_MSVC_DEBUGVIEW_CODE; return *this; } inline const mpreal operator<<(const mpreal& v, const unsigned long int k) { return mul_2ui(v,k); } inline const mpreal operator<<(const mpreal& v, const unsigned int k) { return mul_2ui(v,static_cast(k)); } inline const mpreal operator<<(const mpreal& v, const long int k) { return mul_2si(v,k); } inline const mpreal operator<<(const mpreal& v, const int k) { return mul_2si(v,static_cast(k)); } inline const mpreal operator>>(const mpreal& v, const unsigned long int k) { return div_2ui(v,k); } inline const mpreal operator>>(const mpreal& v, const long int k) { return div_2si(v,k); } inline const mpreal operator>>(const mpreal& v, const unsigned int k) { return div_2ui(v,static_cast(k)); } inline const mpreal operator>>(const mpreal& v, const int k) { return div_2si(v,static_cast(k)); } // mul_2ui inline const mpreal mul_2ui(const mpreal& v, unsigned long int k, mp_rnd_t rnd_mode) { mpreal x(v); mpfr_mul_2ui(x.mp,v.mp,k,rnd_mode); return x; } // mul_2si inline const mpreal mul_2si(const mpreal& v, long int k, mp_rnd_t rnd_mode) { mpreal x(v); mpfr_mul_2si(x.mp,v.mp,k,rnd_mode); return x; } inline const mpreal div_2ui(const mpreal& v, unsigned long int k, mp_rnd_t rnd_mode) { mpreal x(v); mpfr_div_2ui(x.mp,v.mp,k,rnd_mode); return x; } inline const mpreal div_2si(const mpreal& v, long int k, mp_rnd_t rnd_mode) { mpreal x(v); mpfr_div_2si(x.mp,v.mp,k,rnd_mode); return x; } ////////////////////////////////////////////////////////////////////////// //Boolean operators inline bool operator > (const mpreal& a, const mpreal& b){ return (mpfr_greater_p(a.mp,b.mp) !=0); } inline bool operator >= (const mpreal& a, const mpreal& b){ return (mpfr_greaterequal_p(a.mp,b.mp) !=0); } inline bool operator < (const mpreal& a, const mpreal& b){ return (mpfr_less_p(a.mp,b.mp) !=0); } inline bool operator <= (const mpreal& a, const mpreal& b){ return (mpfr_lessequal_p(a.mp,b.mp) !=0); } inline bool operator == (const mpreal& a, const mpreal& b){ return (mpfr_equal_p(a.mp,b.mp) !=0); } inline bool operator != (const mpreal& a, const mpreal& b){ return (mpfr_lessgreater_p(a.mp,b.mp) !=0); } inline bool operator == (const mpreal& a, const unsigned long int b ){ return (mpfr_cmp_ui(a.mp,b) == 0); } inline bool operator == (const mpreal& a, const unsigned int b ){ return (mpfr_cmp_ui(a.mp,b) == 0); } inline bool operator == (const mpreal& a, const long int b ){ return (mpfr_cmp_si(a.mp,b) == 0); } inline bool operator == (const mpreal& a, const int b ){ return (mpfr_cmp_si(a.mp,b) == 0); } inline bool operator == (const mpreal& a, const long double b ){ return (mpfr_cmp_ld(a.mp,b) == 0); } inline bool operator == (const mpreal& a, const double b ){ return (mpfr_cmp_d(a.mp,b) == 0); } inline bool isnan (const mpreal& v){ return (mpfr_nan_p(v.mp) != 0); } inline bool isinf (const mpreal& v){ return (mpfr_inf_p(v.mp) != 0); } inline bool isfinite (const mpreal& v){ return (mpfr_number_p(v.mp) != 0); } inline bool iszero (const mpreal& v){ return (mpfr_zero_p(v.mp) != 0); } inline bool isint (const mpreal& v){ return (mpfr_integer_p(v.mp) != 0); } #if (MPFR_VERSION >= MPFR_VERSION_NUM(3,0,0)) inline bool isregular(const mpreal& v){ return (mpfr_regular_p(v.mp));} #endif ////////////////////////////////////////////////////////////////////////// // Type Converters inline long mpreal::toLong (mp_rnd_t mode) const { return mpfr_get_si(mp, mode); } inline unsigned long mpreal::toULong (mp_rnd_t mode) const { return mpfr_get_ui(mp, mode); } inline double mpreal::toDouble (mp_rnd_t mode) const { return mpfr_get_d (mp, mode); } inline long double mpreal::toLDouble(mp_rnd_t mode) const { return mpfr_get_ld(mp, mode); } #if defined (MPREAL_HAVE_INT64_SUPPORT) inline int64_t mpreal::toInt64 (mp_rnd_t mode) const{ return mpfr_get_sj(mp, mode); } inline uint64_t mpreal::toUInt64(mp_rnd_t mode) const{ return mpfr_get_uj(mp, mode); } #endif inline ::mpfr_ptr mpreal::mpfr_ptr() { return mp; } inline ::mpfr_srcptr mpreal::mpfr_ptr() const { return mp; } inline ::mpfr_srcptr mpreal::mpfr_srcptr() const { return mp; } template inline std::string toString(T t, std::ios_base & (*f)(std::ios_base&)) { std::ostringstream oss; oss << f << t; return oss.str(); } #if (MPFR_VERSION >= MPFR_VERSION_NUM(2,4,0)) inline std::string mpreal::toString(const std::string& format) const { char *s = NULL; std::string out; if( !format.empty() ) { if(!(mpfr_asprintf(&s,format.c_str(),mp) < 0)) { out = std::string(s); mpfr_free_str(s); } } return out; } #endif inline std::string mpreal::toString(int n, int b, mp_rnd_t mode) const { (void)b; (void)mode; #if (MPFR_VERSION >= MPFR_VERSION_NUM(2,4,0)) // Use MPFR native function for output char format[128]; int digits; digits = n > 0 ? n : bits2digits(mpfr_get_prec(mp)); sprintf(format,"%%.%dRNg",digits); // Default format return toString(std::string(format)); #else char *s, *ns = NULL; size_t slen, nslen; mp_exp_t exp; std::string out; if(mpfr_inf_p(mp)) { if(mpfr_sgn(mp)>0) return "+Inf"; else return "-Inf"; } if(mpfr_zero_p(mp)) return "0"; if(mpfr_nan_p(mp)) return "NaN"; s = mpfr_get_str(NULL,&exp,b,0,mp,mode); ns = mpfr_get_str(NULL,&exp,b,n,mp,mode); if(s!=NULL && ns!=NULL) { slen = strlen(s); nslen = strlen(ns); if(nslen<=slen) { mpfr_free_str(s); s = ns; slen = nslen; } else { mpfr_free_str(ns); } // Make human eye-friendly formatting if possible if (exp>0 && static_cast(exp)s+exp) ptr--; if(ptr==s+exp) out = std::string(s,exp+1); else out = std::string(s,exp+1)+'.'+std::string(s+exp+1,ptr-(s+exp+1)+1); //out = string(s,exp+1)+'.'+string(s+exp+1); } else { // Remove zeros starting from right end char* ptr = s+slen-1; while (*ptr=='0' && ptr>s+exp-1) ptr--; if(ptr==s+exp-1) out = std::string(s,exp); else out = std::string(s,exp)+'.'+std::string(s+exp,ptr-(s+exp)+1); //out = string(s,exp)+'.'+string(s+exp); } }else{ // exp<0 || exp>slen if(s[0]=='-') { // Remove zeros starting from right end char* ptr = s+slen-1; while (*ptr=='0' && ptr>s+1) ptr--; if(ptr==s+1) out = std::string(s,2); else out = std::string(s,2)+'.'+std::string(s+2,ptr-(s+2)+1); //out = string(s,2)+'.'+string(s+2); } else { // Remove zeros starting from right end char* ptr = s+slen-1; while (*ptr=='0' && ptr>s) ptr--; if(ptr==s) out = std::string(s,1); else out = std::string(s,1)+'.'+std::string(s+1,ptr-(s+1)+1); //out = string(s,1)+'.'+string(s+1); } // Make final string if(--exp) { if(exp>0) out += "e+"+mpfr::toString(exp,std::dec); else out += "e"+mpfr::toString(exp,std::dec); } } mpfr_free_str(s); return out; }else{ return "conversion error!"; } #endif } ////////////////////////////////////////////////////////////////////////// // I/O inline std::ostream& operator<<(std::ostream& os, const mpreal& v) { return os<(os.precision())); } inline std::istream& operator>>(std::istream &is, mpreal& v) { // ToDo, use cout::hexfloat and other flags to setup base std::string tmp; is >> tmp; mpfr_set_str(v.mp, tmp.c_str(), 10, mpreal::get_default_rnd()); return is; } ////////////////////////////////////////////////////////////////////////// // Bits - decimal digits relation // bits = ceil(digits*log[2](10)) // digits = floor(bits*log[10](2)) inline mp_prec_t digits2bits(int d) { const double LOG2_10 = 3.3219280948873624; return (mp_prec_t) std::ceil( d * LOG2_10 ); } inline int bits2digits(mp_prec_t b) { const double LOG10_2 = 0.30102999566398119; return (int) std::floor( b * LOG10_2 ); } ////////////////////////////////////////////////////////////////////////// // Set/Get number properties inline int sgn(const mpreal& v) { int r = mpfr_signbit(v.mp); return (r>0?-1:1); } inline mpreal& mpreal::setSign(int sign, mp_rnd_t RoundingMode) { mpfr_setsign(mp,mp,(sign < 0 ? 1 : 0),RoundingMode); MPREAL_MSVC_DEBUGVIEW_CODE; return *this; } inline int mpreal::getPrecision() const { return mpfr_get_prec(mp); } inline mpreal& mpreal::setPrecision(int Precision, mp_rnd_t RoundingMode) { mpfr_prec_round(mp, Precision, RoundingMode); MPREAL_MSVC_DEBUGVIEW_CODE; return *this; } inline mpreal& mpreal::setInf(int sign) { mpfr_set_inf(mp,sign); MPREAL_MSVC_DEBUGVIEW_CODE; return *this; } inline mpreal& mpreal::setNan() { mpfr_set_nan(mp); MPREAL_MSVC_DEBUGVIEW_CODE; return *this; } inline mpreal& mpreal::setZero(int sign) { #if (MPFR_VERSION >= MPFR_VERSION_NUM(3,0,0)) mpfr_set_zero(mp, sign); #else mpfr_set_si(mp, 0, (mpfr_get_default_rounding_mode)()); setSign(sign); #endif MPREAL_MSVC_DEBUGVIEW_CODE; return *this; } inline mp_prec_t mpreal::get_prec() const { return mpfr_get_prec(mp); } inline void mpreal::set_prec(mp_prec_t prec, mp_rnd_t rnd_mode) { mpfr_prec_round(mp,prec,rnd_mode); MPREAL_MSVC_DEBUGVIEW_CODE; } inline mp_exp_t mpreal::get_exp () { return mpfr_get_exp(mp); } inline int mpreal::set_exp (mp_exp_t e) { int x = mpfr_set_exp(mp, e); MPREAL_MSVC_DEBUGVIEW_CODE; return x; } inline const mpreal frexp(const mpreal& v, mp_exp_t* exp) { mpreal x(v); *exp = x.get_exp(); x.set_exp(0); return x; } inline const mpreal ldexp(const mpreal& v, mp_exp_t exp) { mpreal x(v); // rounding is not important since we just increasing the exponent mpfr_mul_2si(x.mp,x.mp,exp,mpreal::get_default_rnd()); return x; } inline mpreal machine_epsilon(mp_prec_t prec) { /* the smallest eps such that 1 + eps != 1 */ return machine_epsilon(mpreal(1, prec)); } inline mpreal machine_epsilon(const mpreal& x) { /* the smallest eps such that x + eps != x */ if( x < 0) { return nextabove(-x)+x; }else{ return nextabove(x)-x; } } // minval is 'safe' meaning 1 / minval does not overflow inline mpreal minval(mp_prec_t prec) { /* min = 1/2 * 2^emin = 2^(emin - 1) */ return mpreal(1, prec) << mpreal::get_emin()-1; } // maxval is 'safe' meaning 1 / maxval does not underflow inline mpreal maxval(mp_prec_t prec) { /* max = (1 - eps) * 2^emax, eps is machine epsilon */ return (mpreal(1, prec) - machine_epsilon(prec)) << mpreal::get_emax(); } inline bool isEqualUlps(const mpreal& a, const mpreal& b, int maxUlps) { return abs(a - b) <= machine_epsilon((max)(abs(a), abs(b))) * maxUlps; } inline bool isEqualFuzzy(const mpreal& a, const mpreal& b, const mpreal& eps) { return abs(a - b) <= eps; } inline bool isEqualFuzzy(const mpreal& a, const mpreal& b) { return isEqualFuzzy(a, b, machine_epsilon((max)(1, (min)(abs(a), abs(b))))); } inline const mpreal modf(const mpreal& v, mpreal& n) { mpreal frac(v); // rounding is not important since we are using the same number mpfr_frac(frac.mp,frac.mp,mpreal::get_default_rnd()); mpfr_trunc(n.mp,v.mp); return frac; } inline int mpreal::check_range (int t, mp_rnd_t rnd_mode) { return mpfr_check_range(mp,t,rnd_mode); } inline int mpreal::subnormalize (int t,mp_rnd_t rnd_mode) { int r = mpfr_subnormalize(mp,t,rnd_mode); MPREAL_MSVC_DEBUGVIEW_CODE; return r; } inline mp_exp_t mpreal::get_emin (void) { return mpfr_get_emin(); } inline int mpreal::set_emin (mp_exp_t exp) { return mpfr_set_emin(exp); } inline mp_exp_t mpreal::get_emax (void) { return mpfr_get_emax(); } inline int mpreal::set_emax (mp_exp_t exp) { return mpfr_set_emax(exp); } inline mp_exp_t mpreal::get_emin_min (void) { return mpfr_get_emin_min(); } inline mp_exp_t mpreal::get_emin_max (void) { return mpfr_get_emin_max(); } inline mp_exp_t mpreal::get_emax_min (void) { return mpfr_get_emax_min(); } inline mp_exp_t mpreal::get_emax_max (void) { return mpfr_get_emax_max(); } ////////////////////////////////////////////////////////////////////////// // Mathematical Functions ////////////////////////////////////////////////////////////////////////// #define MPREAL_UNARY_MATH_FUNCTION_BODY(f) \ mpreal y(0, mpfr_get_prec(x.mpfr_srcptr())); \ mpfr_##f(y.mpfr_ptr(), x.mpfr_srcptr(), r); \ return y; inline const mpreal sqr (const mpreal& x, mp_rnd_t r) { MPREAL_UNARY_MATH_FUNCTION_BODY(sqr ); } inline const mpreal sqrt (const mpreal& x, mp_rnd_t r) { MPREAL_UNARY_MATH_FUNCTION_BODY(sqrt); } inline const mpreal sqrt(const unsigned long int x, mp_rnd_t r) { mpreal y; mpfr_sqrt_ui(y.mpfr_ptr(), x, r); return y; } inline const mpreal sqrt(const unsigned int v, mp_rnd_t rnd_mode) { return sqrt(static_cast(v),rnd_mode); } inline const mpreal sqrt(const long int v, mp_rnd_t rnd_mode) { if (v>=0) return sqrt(static_cast(v),rnd_mode); else return mpreal().setNan(); // NaN } inline const mpreal sqrt(const int v, mp_rnd_t rnd_mode) { if (v>=0) return sqrt(static_cast(v),rnd_mode); else return mpreal().setNan(); // NaN } inline const mpreal root(const mpreal& x, unsigned long int k, mp_rnd_t r) { mpreal y(0, mpfr_get_prec(x.mpfr_srcptr())); mpfr_root(y.mpfr_ptr(), x.mpfr_srcptr(), k, r); return y; } inline const mpreal dim(const mpreal& a, const mpreal& b, mp_rnd_t r) { mpreal y(0, mpfr_get_prec(a.mpfr_srcptr())); mpfr_dim(y.mpfr_ptr(), a.mpfr_srcptr(), b.mpfr_srcptr(), r); return y; } inline int cmpabs(const mpreal& a,const mpreal& b) { return mpfr_cmpabs(a.mpfr_ptr(), b.mpfr_srcptr()); } inline int sin_cos(mpreal& s, mpreal& c, const mpreal& v, mp_rnd_t rnd_mode) { return mpfr_sin_cos(s.mpfr_ptr(), c.mpfr_ptr(), v.mpfr_srcptr(), rnd_mode); } inline const mpreal sqrt (const long double v, mp_rnd_t rnd_mode) { return sqrt(mpreal(v),rnd_mode); } inline const mpreal sqrt (const double v, mp_rnd_t rnd_mode) { return sqrt(mpreal(v),rnd_mode); } inline const mpreal cbrt (const mpreal& x, mp_rnd_t r) { MPREAL_UNARY_MATH_FUNCTION_BODY(cbrt ); } inline const mpreal fabs (const mpreal& x, mp_rnd_t r) { MPREAL_UNARY_MATH_FUNCTION_BODY(abs ); } inline const mpreal abs (const mpreal& x, mp_rnd_t r) { MPREAL_UNARY_MATH_FUNCTION_BODY(abs ); } inline const mpreal log (const mpreal& x, mp_rnd_t r) { MPREAL_UNARY_MATH_FUNCTION_BODY(log ); } inline const mpreal log2 (const mpreal& x, mp_rnd_t r) { MPREAL_UNARY_MATH_FUNCTION_BODY(log2 ); } inline const mpreal log10 (const mpreal& x, mp_rnd_t r) { MPREAL_UNARY_MATH_FUNCTION_BODY(log10); } inline const mpreal exp (const mpreal& x, mp_rnd_t r) { MPREAL_UNARY_MATH_FUNCTION_BODY(exp ); } inline const mpreal exp2 (const mpreal& x, mp_rnd_t r) { MPREAL_UNARY_MATH_FUNCTION_BODY(exp2 ); } inline const mpreal exp10 (const mpreal& x, mp_rnd_t r) { MPREAL_UNARY_MATH_FUNCTION_BODY(exp10); } inline const mpreal cos (const mpreal& x, mp_rnd_t r) { MPREAL_UNARY_MATH_FUNCTION_BODY(cos ); } inline const mpreal sin (const mpreal& x, mp_rnd_t r) { MPREAL_UNARY_MATH_FUNCTION_BODY(sin ); } inline const mpreal tan (const mpreal& x, mp_rnd_t r) { MPREAL_UNARY_MATH_FUNCTION_BODY(tan ); } inline const mpreal sec (const mpreal& x, mp_rnd_t r) { MPREAL_UNARY_MATH_FUNCTION_BODY(sec ); } inline const mpreal csc (const mpreal& x, mp_rnd_t r) { MPREAL_UNARY_MATH_FUNCTION_BODY(csc ); } inline const mpreal cot (const mpreal& x, mp_rnd_t r) { MPREAL_UNARY_MATH_FUNCTION_BODY(cot ); } inline const mpreal acos (const mpreal& x, mp_rnd_t r) { MPREAL_UNARY_MATH_FUNCTION_BODY(acos ); } inline const mpreal asin (const mpreal& x, mp_rnd_t r) { MPREAL_UNARY_MATH_FUNCTION_BODY(asin ); } inline const mpreal atan (const mpreal& x, mp_rnd_t r) { MPREAL_UNARY_MATH_FUNCTION_BODY(atan ); } inline const mpreal acot (const mpreal& v, mp_rnd_t r) { return atan (1/v, r); } inline const mpreal asec (const mpreal& v, mp_rnd_t r) { return acos (1/v, r); } inline const mpreal acsc (const mpreal& v, mp_rnd_t r) { return asin (1/v, r); } inline const mpreal acoth (const mpreal& v, mp_rnd_t r) { return atanh(1/v, r); } inline const mpreal asech (const mpreal& v, mp_rnd_t r) { return acosh(1/v, r); } inline const mpreal acsch (const mpreal& v, mp_rnd_t r) { return asinh(1/v, r); } inline const mpreal cosh (const mpreal& x, mp_rnd_t r) { MPREAL_UNARY_MATH_FUNCTION_BODY(cosh ); } inline const mpreal sinh (const mpreal& x, mp_rnd_t r) { MPREAL_UNARY_MATH_FUNCTION_BODY(sinh ); } inline const mpreal tanh (const mpreal& x, mp_rnd_t r) { MPREAL_UNARY_MATH_FUNCTION_BODY(tanh ); } inline const mpreal sech (const mpreal& x, mp_rnd_t r) { MPREAL_UNARY_MATH_FUNCTION_BODY(sech ); } inline const mpreal csch (const mpreal& x, mp_rnd_t r) { MPREAL_UNARY_MATH_FUNCTION_BODY(csch ); } inline const mpreal coth (const mpreal& x, mp_rnd_t r) { MPREAL_UNARY_MATH_FUNCTION_BODY(coth ); } inline const mpreal acosh (const mpreal& x, mp_rnd_t r) { MPREAL_UNARY_MATH_FUNCTION_BODY(acosh); } inline const mpreal asinh (const mpreal& x, mp_rnd_t r) { MPREAL_UNARY_MATH_FUNCTION_BODY(asinh); } inline const mpreal atanh (const mpreal& x, mp_rnd_t r) { MPREAL_UNARY_MATH_FUNCTION_BODY(atanh); } inline const mpreal log1p (const mpreal& x, mp_rnd_t r) { MPREAL_UNARY_MATH_FUNCTION_BODY(log1p ); } inline const mpreal expm1 (const mpreal& x, mp_rnd_t r) { MPREAL_UNARY_MATH_FUNCTION_BODY(expm1 ); } inline const mpreal eint (const mpreal& x, mp_rnd_t r) { MPREAL_UNARY_MATH_FUNCTION_BODY(eint ); } inline const mpreal gamma (const mpreal& x, mp_rnd_t r) { MPREAL_UNARY_MATH_FUNCTION_BODY(gamma ); } inline const mpreal lngamma (const mpreal& x, mp_rnd_t r) { MPREAL_UNARY_MATH_FUNCTION_BODY(lngamma); } inline const mpreal zeta (const mpreal& x, mp_rnd_t r) { MPREAL_UNARY_MATH_FUNCTION_BODY(zeta ); } inline const mpreal erf (const mpreal& x, mp_rnd_t r) { MPREAL_UNARY_MATH_FUNCTION_BODY(erf ); } inline const mpreal erfc (const mpreal& x, mp_rnd_t r) { MPREAL_UNARY_MATH_FUNCTION_BODY(erfc ); } inline const mpreal besselj0(const mpreal& x, mp_rnd_t r) { MPREAL_UNARY_MATH_FUNCTION_BODY(j0 ); } inline const mpreal besselj1(const mpreal& x, mp_rnd_t r) { MPREAL_UNARY_MATH_FUNCTION_BODY(j1 ); } inline const mpreal bessely0(const mpreal& x, mp_rnd_t r) { MPREAL_UNARY_MATH_FUNCTION_BODY(y0 ); } inline const mpreal bessely1(const mpreal& x, mp_rnd_t r) { MPREAL_UNARY_MATH_FUNCTION_BODY(y1 ); } inline const mpreal atan2 (const mpreal& y, const mpreal& x, mp_rnd_t rnd_mode) { mpreal a(0,(std::max)(y.getPrecision(), x.getPrecision())); mpfr_atan2(a.mpfr_ptr(), y.mpfr_srcptr(), x.mpfr_srcptr(), rnd_mode); return a; } inline const mpreal hypot (const mpreal& x, const mpreal& y, mp_rnd_t rnd_mode) { mpreal a(0,(std::max)(y.getPrecision(), x.getPrecision())); mpfr_hypot(a.mpfr_ptr(), x.mpfr_srcptr(), y.mpfr_srcptr(), rnd_mode); return a; } inline const mpreal remainder (const mpreal& x, const mpreal& y, mp_rnd_t rnd_mode) { mpreal a(0,(std::max)(y.getPrecision(), x.getPrecision())); mpfr_remainder(a.mpfr_ptr(), x.mpfr_srcptr(), y.mpfr_srcptr(), rnd_mode); return a; } inline const mpreal remquo (long* q, const mpreal& x, const mpreal& y, mp_rnd_t rnd_mode) { mpreal a(0,(std::max)(y.getPrecision(), x.getPrecision())); mpfr_remquo(a.mpfr_ptr(),q, x.mpfr_srcptr(), y.mpfr_srcptr(), rnd_mode); return a; } inline const mpreal fac_ui (unsigned long int v, mp_prec_t prec, mp_rnd_t rnd_mode) { mpreal x(0, prec); mpfr_fac_ui(x.mpfr_ptr(),v,rnd_mode); return x; } inline const mpreal lgamma (const mpreal& v, int *signp, mp_rnd_t rnd_mode) { mpreal x(v); int tsignp; if(signp) mpfr_lgamma(x.mp, signp,v.mp,rnd_mode); else mpfr_lgamma(x.mp,&tsignp,v.mp,rnd_mode); return x; } inline const mpreal besseljn (long n, const mpreal& x, mp_rnd_t r) { mpreal y(0, mpfr_get_prec(x.mpfr_srcptr())); mpfr_jn(y.mpfr_ptr(), n, x.mpfr_srcptr(), r); return y; } inline const mpreal besselyn (long n, const mpreal& x, mp_rnd_t r) { mpreal y(0, mpfr_get_prec(x.mpfr_srcptr())); mpfr_yn(y.mpfr_ptr(), n, x.mpfr_srcptr(), r); return y; } inline const mpreal fma (const mpreal& v1, const mpreal& v2, const mpreal& v3, mp_rnd_t rnd_mode) { mpreal a; mp_prec_t p1, p2, p3; p1 = v1.get_prec(); p2 = v2.get_prec(); p3 = v3.get_prec(); a.set_prec(p3>p2?(p3>p1?p3:p1):(p2>p1?p2:p1)); mpfr_fma(a.mp,v1.mp,v2.mp,v3.mp,rnd_mode); return a; } inline const mpreal fms (const mpreal& v1, const mpreal& v2, const mpreal& v3, mp_rnd_t rnd_mode) { mpreal a; mp_prec_t p1, p2, p3; p1 = v1.get_prec(); p2 = v2.get_prec(); p3 = v3.get_prec(); a.set_prec(p3>p2?(p3>p1?p3:p1):(p2>p1?p2:p1)); mpfr_fms(a.mp,v1.mp,v2.mp,v3.mp,rnd_mode); return a; } inline const mpreal agm (const mpreal& v1, const mpreal& v2, mp_rnd_t rnd_mode) { mpreal a; mp_prec_t p1, p2; p1 = v1.get_prec(); p2 = v2.get_prec(); a.set_prec(p1>p2?p1:p2); mpfr_agm(a.mp, v1.mp, v2.mp, rnd_mode); return a; } inline const mpreal sum (const mpreal tab[], unsigned long int n, mp_rnd_t rnd_mode) { mpreal x; mpfr_ptr* t; unsigned long int i; t = new mpfr_ptr[n]; for (i=0;i= MPFR_VERSION_NUM(2,4,0)) inline int sinh_cosh(mpreal& s, mpreal& c, const mpreal& v, mp_rnd_t rnd_mode) { return mpfr_sinh_cosh(s.mp,c.mp,v.mp,rnd_mode); } inline const mpreal li2 (const mpreal& x, mp_rnd_t r) { MPREAL_UNARY_MATH_FUNCTION_BODY(li2); } inline const mpreal rem (const mpreal& x, const mpreal& y, mp_rnd_t rnd_mode) { /* R = rem(X,Y) if Y != 0, returns X - n * Y where n = trunc(X/Y). */ return fmod(x, y, rnd_mode); } inline const mpreal mod (const mpreal& x, const mpreal& y, mp_rnd_t rnd_mode) { (void)rnd_mode; /* m = mod(x,y) if y != 0, returns x - n*y where n = floor(x/y) The following are true by convention: - mod(x,0) is x - mod(x,x) is 0 - mod(x,y) for x != y and y != 0 has the same sign as y. */ if(iszero(y)) return x; if(x == y) return 0; mpreal m = x - floor(x / y) * y; m.setSign(sgn(y)); // make sure result has the same sign as Y return m; } inline const mpreal fmod (const mpreal& x, const mpreal& y, mp_rnd_t rnd_mode) { mpreal a; mp_prec_t yp, xp; yp = y.get_prec(); xp = x.get_prec(); a.set_prec(yp>xp?yp:xp); mpfr_fmod(a.mp, x.mp, y.mp, rnd_mode); return a; } inline const mpreal rec_sqrt(const mpreal& v, mp_rnd_t rnd_mode) { mpreal x(v); mpfr_rec_sqrt(x.mp,v.mp,rnd_mode); return x; } #endif // MPFR 2.4.0 Specifics ////////////////////////////////////////////////////////////////////////// // MPFR 3.0.0 Specifics #if (MPFR_VERSION >= MPFR_VERSION_NUM(3,0,0)) inline const mpreal digamma (const mpreal& x, mp_rnd_t r) { MPREAL_UNARY_MATH_FUNCTION_BODY(digamma); } inline const mpreal ai (const mpreal& x, mp_rnd_t r) { MPREAL_UNARY_MATH_FUNCTION_BODY(ai); } #endif // MPFR 3.0.0 Specifics ////////////////////////////////////////////////////////////////////////// // Constants inline const mpreal const_log2 (mp_prec_t p, mp_rnd_t r) { mpreal x(0, p); mpfr_const_log2(x.mpfr_ptr(), r); return x; } inline const mpreal const_pi (mp_prec_t p, mp_rnd_t r) { mpreal x(0, p); mpfr_const_pi(x.mpfr_ptr(), r); return x; } inline const mpreal const_euler (mp_prec_t p, mp_rnd_t r) { mpreal x(0, p); mpfr_const_euler(x.mpfr_ptr(), r); return x; } inline const mpreal const_catalan (mp_prec_t p, mp_rnd_t r) { mpreal x(0, p); mpfr_const_catalan(x.mpfr_ptr(), r); return x; } inline const mpreal const_infinity (int sign, mp_prec_t p, mp_rnd_t r) { mpreal x(0, p); mpfr_set_inf(x.mpfr_ptr(), sign); return x; } ////////////////////////////////////////////////////////////////////////// // Integer Related Functions inline const mpreal ceil(const mpreal& v) { mpreal x(v); mpfr_ceil(x.mp,v.mp); return x; } inline const mpreal floor(const mpreal& v) { mpreal x(v); mpfr_floor(x.mp,v.mp); return x; } inline const mpreal round(const mpreal& v) { mpreal x(v); mpfr_round(x.mp,v.mp); return x; } inline const mpreal trunc(const mpreal& v) { mpreal x(v); mpfr_trunc(x.mp,v.mp); return x; } inline const mpreal rint (const mpreal& x, mp_rnd_t r) { MPREAL_UNARY_MATH_FUNCTION_BODY(rint ); } inline const mpreal rint_ceil (const mpreal& x, mp_rnd_t r) { MPREAL_UNARY_MATH_FUNCTION_BODY(rint_ceil ); } inline const mpreal rint_floor (const mpreal& x, mp_rnd_t r) { MPREAL_UNARY_MATH_FUNCTION_BODY(rint_floor); } inline const mpreal rint_round (const mpreal& x, mp_rnd_t r) { MPREAL_UNARY_MATH_FUNCTION_BODY(rint_round); } inline const mpreal rint_trunc (const mpreal& x, mp_rnd_t r) { MPREAL_UNARY_MATH_FUNCTION_BODY(rint_trunc); } inline const mpreal frac (const mpreal& x, mp_rnd_t r) { MPREAL_UNARY_MATH_FUNCTION_BODY(frac ); } ////////////////////////////////////////////////////////////////////////// // Miscellaneous Functions inline void swap (mpreal& a, mpreal& b) { mpfr_swap(a.mp,b.mp); } inline const mpreal (max)(const mpreal& x, const mpreal& y){ return (x>y?x:y); } inline const mpreal (min)(const mpreal& x, const mpreal& y){ return (x= MPFR_VERSION_NUM(3,0,0)) // use gmp_randinit_default() to init state, gmp_randclear() to clear inline const mpreal urandom (gmp_randstate_t& state, mp_rnd_t rnd_mode) { mpreal x; mpfr_urandom(x.mp,state,rnd_mode); return x; } inline const mpreal grandom (gmp_randstate_t& state, mp_rnd_t rnd_mode) { mpreal x; mpfr_grandom(x.mp, NULL, state, rnd_mode); return x; } #endif #if (MPFR_VERSION <= MPFR_VERSION_NUM(2,4,2)) inline const mpreal random2 (mp_size_t size, mp_exp_t exp) { mpreal x; mpfr_random2(x.mp,size,exp); return x; } #endif // Uniformly distributed random number generation // a = random(seed); <- initialization & first random number generation // a = random(); <- next random numbers generation // seed != 0 inline const mpreal random(unsigned int seed) { #if (MPFR_VERSION >= MPFR_VERSION_NUM(3,0,0)) static gmp_randstate_t state; static bool isFirstTime = true; if(isFirstTime) { gmp_randinit_default(state); gmp_randseed_ui(state,0); isFirstTime = false; } if(seed != 0) gmp_randseed_ui(state,seed); return mpfr::urandom(state); #else if(seed != 0) std::srand(seed); return mpfr::mpreal(std::rand()/(double)RAND_MAX); #endif } #if (MPFR_VERSION >= MPFR_VERSION_NUM(3,0,0)) inline const mpreal grandom(unsigned int seed) { static gmp_randstate_t state; static bool isFirstTime = true; if(isFirstTime) { gmp_randinit_default(state); gmp_randseed_ui(state,0); isFirstTime = false; } if(seed != 0) gmp_randseed_ui(state,seed); return mpfr::grandom(state); } #endif ////////////////////////////////////////////////////////////////////////// // Set/Get global properties inline void mpreal::set_default_prec(mp_prec_t prec) { mpfr_set_default_prec(prec); } inline void mpreal::set_default_rnd(mp_rnd_t rnd_mode) { mpfr_set_default_rounding_mode(rnd_mode); } inline bool mpreal::fits_in_bits(double x, int n) { int i; double t; return IsInf(x) || (std::modf ( std::ldexp ( std::frexp ( x, &i ), n ), &t ) == 0.0); } inline const mpreal pow(const mpreal& a, const mpreal& b, mp_rnd_t rnd_mode) { mpreal x(a); mpfr_pow(x.mp,x.mp,b.mp,rnd_mode); return x; } inline const mpreal pow(const mpreal& a, const mpz_t b, mp_rnd_t rnd_mode) { mpreal x(a); mpfr_pow_z(x.mp,x.mp,b,rnd_mode); return x; } inline const mpreal pow(const mpreal& a, const unsigned long int b, mp_rnd_t rnd_mode) { mpreal x(a); mpfr_pow_ui(x.mp,x.mp,b,rnd_mode); return x; } inline const mpreal pow(const mpreal& a, const unsigned int b, mp_rnd_t rnd_mode) { return pow(a,static_cast(b),rnd_mode); } inline const mpreal pow(const mpreal& a, const long int b, mp_rnd_t rnd_mode) { mpreal x(a); mpfr_pow_si(x.mp,x.mp,b,rnd_mode); return x; } inline const mpreal pow(const mpreal& a, const int b, mp_rnd_t rnd_mode) { return pow(a,static_cast(b),rnd_mode); } inline const mpreal pow(const mpreal& a, const long double b, mp_rnd_t rnd_mode) { return pow(a,mpreal(b),rnd_mode); } inline const mpreal pow(const mpreal& a, const double b, mp_rnd_t rnd_mode) { return pow(a,mpreal(b),rnd_mode); } inline const mpreal pow(const unsigned long int a, const mpreal& b, mp_rnd_t rnd_mode) { mpreal x(a); mpfr_ui_pow(x.mp,a,b.mp,rnd_mode); return x; } inline const mpreal pow(const unsigned int a, const mpreal& b, mp_rnd_t rnd_mode) { return pow(static_cast(a),b,rnd_mode); } inline const mpreal pow(const long int a, const mpreal& b, mp_rnd_t rnd_mode) { if (a>=0) return pow(static_cast(a),b,rnd_mode); else return pow(mpreal(a),b,rnd_mode); } inline const mpreal pow(const int a, const mpreal& b, mp_rnd_t rnd_mode) { if (a>=0) return pow(static_cast(a),b,rnd_mode); else return pow(mpreal(a),b,rnd_mode); } inline const mpreal pow(const long double a, const mpreal& b, mp_rnd_t rnd_mode) { return pow(mpreal(a),b,rnd_mode); } inline const mpreal pow(const double a, const mpreal& b, mp_rnd_t rnd_mode) { return pow(mpreal(a),b,rnd_mode); } // pow unsigned long int inline const mpreal pow(const unsigned long int a, const unsigned long int b, mp_rnd_t rnd_mode) { mpreal x(a); mpfr_ui_pow_ui(x.mp,a,b,rnd_mode); return x; } inline const mpreal pow(const unsigned long int a, const unsigned int b, mp_rnd_t rnd_mode) { return pow(a,static_cast(b),rnd_mode); //mpfr_ui_pow_ui } inline const mpreal pow(const unsigned long int a, const long int b, mp_rnd_t rnd_mode) { if(b>0) return pow(a,static_cast(b),rnd_mode); //mpfr_ui_pow_ui else return pow(a,mpreal(b),rnd_mode); //mpfr_ui_pow } inline const mpreal pow(const unsigned long int a, const int b, mp_rnd_t rnd_mode) { if(b>0) return pow(a,static_cast(b),rnd_mode); //mpfr_ui_pow_ui else return pow(a,mpreal(b),rnd_mode); //mpfr_ui_pow } inline const mpreal pow(const unsigned long int a, const long double b, mp_rnd_t rnd_mode) { return pow(a,mpreal(b),rnd_mode); //mpfr_ui_pow } inline const mpreal pow(const unsigned long int a, const double b, mp_rnd_t rnd_mode) { return pow(a,mpreal(b),rnd_mode); //mpfr_ui_pow } // pow unsigned int inline const mpreal pow(const unsigned int a, const unsigned long int b, mp_rnd_t rnd_mode) { return pow(static_cast(a),b,rnd_mode); //mpfr_ui_pow_ui } inline const mpreal pow(const unsigned int a, const unsigned int b, mp_rnd_t rnd_mode) { return pow(static_cast(a),static_cast(b),rnd_mode); //mpfr_ui_pow_ui } inline const mpreal pow(const unsigned int a, const long int b, mp_rnd_t rnd_mode) { if(b>0) return pow(static_cast(a),static_cast(b),rnd_mode); //mpfr_ui_pow_ui else return pow(static_cast(a),mpreal(b),rnd_mode); //mpfr_ui_pow } inline const mpreal pow(const unsigned int a, const int b, mp_rnd_t rnd_mode) { if(b>0) return pow(static_cast(a),static_cast(b),rnd_mode); //mpfr_ui_pow_ui else return pow(static_cast(a),mpreal(b),rnd_mode); //mpfr_ui_pow } inline const mpreal pow(const unsigned int a, const long double b, mp_rnd_t rnd_mode) { return pow(static_cast(a),mpreal(b),rnd_mode); //mpfr_ui_pow } inline const mpreal pow(const unsigned int a, const double b, mp_rnd_t rnd_mode) { return pow(static_cast(a),mpreal(b),rnd_mode); //mpfr_ui_pow } // pow long int inline const mpreal pow(const long int a, const unsigned long int b, mp_rnd_t rnd_mode) { if (a>0) return pow(static_cast(a),b,rnd_mode); //mpfr_ui_pow_ui else return pow(mpreal(a),b,rnd_mode); //mpfr_pow_ui } inline const mpreal pow(const long int a, const unsigned int b, mp_rnd_t rnd_mode) { if (a>0) return pow(static_cast(a),static_cast(b),rnd_mode); //mpfr_ui_pow_ui else return pow(mpreal(a),static_cast(b),rnd_mode); //mpfr_pow_ui } inline const mpreal pow(const long int a, const long int b, mp_rnd_t rnd_mode) { if (a>0) { if(b>0) return pow(static_cast(a),static_cast(b),rnd_mode); //mpfr_ui_pow_ui else return pow(static_cast(a),mpreal(b),rnd_mode); //mpfr_ui_pow }else{ return pow(mpreal(a),b,rnd_mode); // mpfr_pow_si } } inline const mpreal pow(const long int a, const int b, mp_rnd_t rnd_mode) { if (a>0) { if(b>0) return pow(static_cast(a),static_cast(b),rnd_mode); //mpfr_ui_pow_ui else return pow(static_cast(a),mpreal(b),rnd_mode); //mpfr_ui_pow }else{ return pow(mpreal(a),static_cast(b),rnd_mode); // mpfr_pow_si } } inline const mpreal pow(const long int a, const long double b, mp_rnd_t rnd_mode) { if (a>=0) return pow(static_cast(a),mpreal(b),rnd_mode); //mpfr_ui_pow else return pow(mpreal(a),mpreal(b),rnd_mode); //mpfr_pow } inline const mpreal pow(const long int a, const double b, mp_rnd_t rnd_mode) { if (a>=0) return pow(static_cast(a),mpreal(b),rnd_mode); //mpfr_ui_pow else return pow(mpreal(a),mpreal(b),rnd_mode); //mpfr_pow } // pow int inline const mpreal pow(const int a, const unsigned long int b, mp_rnd_t rnd_mode) { if (a>0) return pow(static_cast(a),b,rnd_mode); //mpfr_ui_pow_ui else return pow(mpreal(a),b,rnd_mode); //mpfr_pow_ui } inline const mpreal pow(const int a, const unsigned int b, mp_rnd_t rnd_mode) { if (a>0) return pow(static_cast(a),static_cast(b),rnd_mode); //mpfr_ui_pow_ui else return pow(mpreal(a),static_cast(b),rnd_mode); //mpfr_pow_ui } inline const mpreal pow(const int a, const long int b, mp_rnd_t rnd_mode) { if (a>0) { if(b>0) return pow(static_cast(a),static_cast(b),rnd_mode); //mpfr_ui_pow_ui else return pow(static_cast(a),mpreal(b),rnd_mode); //mpfr_ui_pow }else{ return pow(mpreal(a),b,rnd_mode); // mpfr_pow_si } } inline const mpreal pow(const int a, const int b, mp_rnd_t rnd_mode) { if (a>0) { if(b>0) return pow(static_cast(a),static_cast(b),rnd_mode); //mpfr_ui_pow_ui else return pow(static_cast(a),mpreal(b),rnd_mode); //mpfr_ui_pow }else{ return pow(mpreal(a),static_cast(b),rnd_mode); // mpfr_pow_si } } inline const mpreal pow(const int a, const long double b, mp_rnd_t rnd_mode) { if (a>=0) return pow(static_cast(a),mpreal(b),rnd_mode); //mpfr_ui_pow else return pow(mpreal(a),mpreal(b),rnd_mode); //mpfr_pow } inline const mpreal pow(const int a, const double b, mp_rnd_t rnd_mode) { if (a>=0) return pow(static_cast(a),mpreal(b),rnd_mode); //mpfr_ui_pow else return pow(mpreal(a),mpreal(b),rnd_mode); //mpfr_pow } // pow long double inline const mpreal pow(const long double a, const long double b, mp_rnd_t rnd_mode) { return pow(mpreal(a),mpreal(b),rnd_mode); } inline const mpreal pow(const long double a, const unsigned long int b, mp_rnd_t rnd_mode) { return pow(mpreal(a),b,rnd_mode); //mpfr_pow_ui } inline const mpreal pow(const long double a, const unsigned int b, mp_rnd_t rnd_mode) { return pow(mpreal(a),static_cast(b),rnd_mode); //mpfr_pow_ui } inline const mpreal pow(const long double a, const long int b, mp_rnd_t rnd_mode) { return pow(mpreal(a),b,rnd_mode); // mpfr_pow_si } inline const mpreal pow(const long double a, const int b, mp_rnd_t rnd_mode) { return pow(mpreal(a),static_cast(b),rnd_mode); // mpfr_pow_si } inline const mpreal pow(const double a, const double b, mp_rnd_t rnd_mode) { return pow(mpreal(a),mpreal(b),rnd_mode); } inline const mpreal pow(const double a, const unsigned long int b, mp_rnd_t rnd_mode) { return pow(mpreal(a),b,rnd_mode); // mpfr_pow_ui } inline const mpreal pow(const double a, const unsigned int b, mp_rnd_t rnd_mode) { return pow(mpreal(a),static_cast(b),rnd_mode); // mpfr_pow_ui } inline const mpreal pow(const double a, const long int b, mp_rnd_t rnd_mode) { return pow(mpreal(a),b,rnd_mode); // mpfr_pow_si } inline const mpreal pow(const double a, const int b, mp_rnd_t rnd_mode) { return pow(mpreal(a),static_cast(b),rnd_mode); // mpfr_pow_si } } // End of mpfr namespace // Explicit specialization of std::swap for mpreal numbers // Thus standard algorithms will use efficient version of swap (due to Koenig lookup) // Non-throwing swap C++ idiom: http://en.wikibooks.org/wiki/More_C%2B%2B_Idioms/Non-throwing_swap namespace std { // only allowed to extend namespace std with specializations template <> inline void swap(mpfr::mpreal& x, mpfr::mpreal& y) { return mpfr::swap(x, y); } template<> class numeric_limits { public: static const bool is_specialized = true; static const bool is_signed = true; static const bool is_integer = false; static const bool is_exact = false; static const int radix = 2; static const bool has_infinity = true; static const bool has_quiet_NaN = true; static const bool has_signaling_NaN = true; static const bool is_iec559 = true; // = IEEE 754 static const bool is_bounded = true; static const bool is_modulo = false; static const bool traps = true; static const bool tinyness_before = true; static const float_denorm_style has_denorm = denorm_absent; inline static float_round_style round_style() { mp_rnd_t r = mpfr::mpreal::get_default_rnd(); switch (r) { case GMP_RNDN: return round_to_nearest; case GMP_RNDZ: return round_toward_zero; case GMP_RNDU: return round_toward_infinity; case GMP_RNDD: return round_toward_neg_infinity; default: return round_indeterminate; } } inline static mpfr::mpreal (min) (mp_prec_t precision = mpfr::mpreal::get_default_prec()) { return mpfr::minval(precision); } inline static mpfr::mpreal (max) (mp_prec_t precision = mpfr::mpreal::get_default_prec()) { return mpfr::maxval(precision); } inline static mpfr::mpreal lowest (mp_prec_t precision = mpfr::mpreal::get_default_prec()) { return -mpfr::maxval(precision); } // Returns smallest eps such that 1 + eps != 1 (classic machine epsilon) inline static mpfr::mpreal epsilon(mp_prec_t precision = mpfr::mpreal::get_default_prec()) { return mpfr::machine_epsilon(precision); } // Returns smallest eps such that x + eps != x (relative machine epsilon) inline static mpfr::mpreal epsilon(const mpfr::mpreal& x) { return mpfr::machine_epsilon(x); } inline static mpfr::mpreal round_error(mp_prec_t precision = mpfr::mpreal::get_default_prec()) { mp_rnd_t r = mpfr::mpreal::get_default_rnd(); if(r == GMP_RNDN) return mpfr::mpreal(0.5, precision); else return mpfr::mpreal(1.0, precision); } inline static const mpfr::mpreal infinity() { return mpfr::const_infinity(); } inline static const mpfr::mpreal quiet_NaN() { return mpfr::mpreal().setNan(); } inline static const mpfr::mpreal signaling_NaN() { return mpfr::mpreal().setNan(); } inline static const mpfr::mpreal denorm_min() { return (min)(); } // Please note, exponent range is not fixed in MPFR static const int min_exponent = MPFR_EMIN_DEFAULT; static const int max_exponent = MPFR_EMAX_DEFAULT; MPREAL_PERMISSIVE_EXPR static const int min_exponent10 = (int) (MPFR_EMIN_DEFAULT * 0.3010299956639811); MPREAL_PERMISSIVE_EXPR static const int max_exponent10 = (int) (MPFR_EMAX_DEFAULT * 0.3010299956639811); // Should be constant according to standard, but 'digits' depends on precision in MPFR inline static int digits() { return mpfr::mpreal::get_default_prec(); } inline static int digits(const mpfr::mpreal& x) { return x.getPrecision(); } inline static int digits10(mp_prec_t precision = mpfr::mpreal::get_default_prec()) { return mpfr::bits2digits(precision); } inline static int digits10(const mpfr::mpreal& x) { return mpfr::bits2digits(x.getPrecision()); } inline static int max_digits10(mp_prec_t precision = mpfr::mpreal::get_default_prec()) { return digits10(precision); } }; } #endif /* __MPREAL_H__ */