|
1 <html lang="en"> |
|
2 <head> |
|
3 <title>MPFR 2.3.2</title> |
|
4 <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1"> |
|
5 <meta name="description" content="How to install and use MPFR, a library for reliable multiple precision floating-point arithmetic, version 2.3.2."> |
|
6 <meta name="generator" content="makeinfo 4.11"> |
|
7 <link title="Top" rel="top" href="#Top"> |
|
8 <link href="http://www.gnu.org/software/texinfo/" rel="generator-home" title="Texinfo Homepage"> |
|
9 <!-- |
|
10 This manual documents how to install and use the Multiple Precision |
|
11 Floating-Point Reliable Library, version 2.3.2. |
|
12 |
|
13 Copyright 1991, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc. |
|
14 |
|
15 Permission is granted to copy, distribute and/or modify this document under |
|
16 the terms of the GNU Free Documentation License, Version 1.2 or any later |
|
17 version published by the Free Software Foundation; with no Invariant Sections, |
|
18 with no Front-Cover Texts, and with no Back-Cover Texts. A copy of the |
|
19 license is included in *note GNU Free Documentation License::.--> |
|
20 <meta http-equiv="Content-Style-Type" content="text/css"> |
|
21 <style type="text/css"><!-- |
|
22 pre.display { font-family:inherit } |
|
23 pre.format { font-family:inherit } |
|
24 pre.smalldisplay { font-family:inherit; font-size:smaller } |
|
25 pre.smallformat { font-family:inherit; font-size:smaller } |
|
26 pre.smallexample { font-size:smaller } |
|
27 pre.smalllisp { font-size:smaller } |
|
28 span.sc { font-variant:small-caps } |
|
29 span.roman { font-family:serif; font-weight:normal; } |
|
30 span.sansserif { font-family:sans-serif; font-weight:normal; } |
|
31 --></style> |
|
32 </head> |
|
33 <body> |
|
34 <div class="node"> |
|
35 <p><hr> |
|
36 <a name="Top"></a> |
|
37 Next: <a rel="next" accesskey="n" href="#Copying">Copying</a>, |
|
38 Previous: <a rel="previous" accesskey="p" href="#dir">(dir)</a>, |
|
39 Up: <a rel="up" accesskey="u" href="#dir">(dir)</a> |
|
40 |
|
41 </div> |
|
42 |
|
43 <h2 class="unnumbered">MPFR</h2> |
|
44 |
|
45 <p>This manual documents how to install and use the Multiple Precision |
|
46 Floating-Point Reliable Library, version 2.3.2. |
|
47 |
|
48 <p>Copyright 1991, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc. |
|
49 |
|
50 <p>Permission is granted to copy, distribute and/or modify this document under |
|
51 the terms of the GNU Free Documentation License, Version 1.2 or any later |
|
52 version published by the Free Software Foundation; with no Invariant Sections, |
|
53 with no Front-Cover Texts, and with no Back-Cover Texts. A copy of the |
|
54 license is included in <a href="#GNU-Free-Documentation-License">GNU Free Documentation License</a>. |
|
55 <pre class="sp"> |
|
56 |
|
57 </pre> |
|
58 |
|
59 <!-- Don't bother with contents for html, the menus seem adequate. --> |
|
60 <ul class="menu"> |
|
61 <li><a accesskey="1" href="#Copying">Copying</a>: MPFR Copying Conditions (LGPL). |
|
62 <li><a accesskey="2" href="#Introduction-to-MPFR">Introduction to MPFR</a>: Brief introduction to MPFR. |
|
63 <li><a accesskey="3" href="#Installing-MPFR">Installing MPFR</a>: How to configure and compile the MPFR library. |
|
64 <li><a accesskey="4" href="#Reporting-Bugs">Reporting Bugs</a>: How to usefully report bugs. |
|
65 <li><a accesskey="5" href="#MPFR-Basics">MPFR Basics</a>: What every MPFR user should now. |
|
66 <li><a accesskey="6" href="#MPFR-Interface">MPFR Interface</a>: MPFR functions and macros. |
|
67 <li><a accesskey="7" href="#Contributors">Contributors</a> |
|
68 <li><a accesskey="8" href="#References">References</a> |
|
69 <li><a accesskey="9" href="#GNU-Free-Documentation-License">GNU Free Documentation License</a> |
|
70 <li><a href="#Concept-Index">Concept Index</a> |
|
71 <li><a href="#Function-Index">Function Index</a> |
|
72 </ul> |
|
73 |
|
74 <!-- @m{T,N} is $T$ in tex or @math{N} otherwise. This is an easy way to give --> |
|
75 <!-- different forms for math in tex and info. Commas in N or T don't work, --> |
|
76 <!-- but @C{} can be used instead. \, works in info but not in tex. --> |
|
77 <!-- Usage: @GMPabs{x} --> |
|
78 <!-- Give either |x| in tex, or abs(x) in info or html. --> |
|
79 <!-- Usage: @GMPtimes{} --> |
|
80 <!-- Give either \times or the word "times". --> |
|
81 <!-- New math operators. --> |
|
82 <!-- @abs{} can be used in both tex and info, or just \abs in tex. --> |
|
83 <!-- @times{} made available as a "*" in info and html (already works in tex). --> |
|
84 <!-- Math operators already available in tex, made available in info too. --> |
|
85 <!-- For example @log{} can be used in both tex and info. --> |
|
86 <!-- @pom{} definition --> |
|
87 <!-- The following macro have been copied from gmp.texi --> |
|
88 <!-- Usage: @MPFRpxreftop{info,title} --> |
|
89 <!-- Like @pxref{}, but designed for a reference to the top of a document, not --> |
|
90 <!-- a particular section. --> |
|
91 <!-- The texinfo manual recommends putting a likely section name in references --> |
|
92 <!-- like this, eg. "Introduction", but it seems better to just give the title. --> |
|
93 <div class="node"> |
|
94 <p><hr> |
|
95 <a name="Copying"></a> |
|
96 Next: <a rel="next" accesskey="n" href="#Introduction-to-MPFR">Introduction to MPFR</a>, |
|
97 Previous: <a rel="previous" accesskey="p" href="#Top">Top</a>, |
|
98 Up: <a rel="up" accesskey="u" href="#Top">Top</a> |
|
99 |
|
100 </div> |
|
101 |
|
102 <!-- node-name, next, previous, up --> |
|
103 <h2 class="unnumbered">MPFR Copying Conditions</h2> |
|
104 |
|
105 <p><a name="index-Copying-conditions-1"></a><a name="index-Conditions-for-copying-MPFR-2"></a> |
|
106 This library is <dfn>free</dfn>; this means that everyone is free to use it and |
|
107 free to redistribute it on a free basis. The library is not in the public |
|
108 domain; it is copyrighted and there are restrictions on its distribution, but |
|
109 these restrictions are designed to permit everything that a good cooperating |
|
110 citizen would want to do. What is not allowed is to try to prevent others |
|
111 from further sharing any version of this library that they might get from |
|
112 you. |
|
113 |
|
114 <p>Specifically, we want to make sure that you have the right to give away copies |
|
115 of the library, that you receive source code or else can get it if you want |
|
116 it, that you can change this library or use pieces of it in new free programs, |
|
117 and that you know you can do these things. |
|
118 |
|
119 <p>To make sure that everyone has such rights, we have to forbid you to deprive |
|
120 anyone else of these rights. For example, if you distribute copies of the |
|
121 MPFR library, you must give the recipients all the rights that you have. You |
|
122 must make sure that they, too, receive or can get the source code. And you |
|
123 must tell them their rights. |
|
124 |
|
125 <p>Also, for our own protection, we must make certain that everyone finds out |
|
126 that there is no warranty for the MPFR library. If it is modified by |
|
127 someone else and passed on, we want their recipients to know that what they |
|
128 have is not what we distributed, so that any problems introduced by others |
|
129 will not reflect on our reputation. |
|
130 |
|
131 <p>The precise conditions of the license for the MPFR library are found in the |
|
132 Lesser General Public License that accompanies the source code. |
|
133 See the file COPYING.LIB. |
|
134 |
|
135 <div class="node"> |
|
136 <p><hr> |
|
137 <a name="Introduction-to-MPFR"></a> |
|
138 Next: <a rel="next" accesskey="n" href="#Installing-MPFR">Installing MPFR</a>, |
|
139 Previous: <a rel="previous" accesskey="p" href="#Copying">Copying</a>, |
|
140 Up: <a rel="up" accesskey="u" href="#Top">Top</a> |
|
141 |
|
142 </div> |
|
143 |
|
144 <!-- node-name, next, previous, up --> |
|
145 <h2 class="chapter">1 Introduction to MPFR</h2> |
|
146 |
|
147 <p>MPFR is a portable library written in C for arbitrary precision arithmetic |
|
148 on floating-point numbers. It is based on the GNU MP library. |
|
149 It aims to extend the class of floating-point numbers provided by the |
|
150 GNU MP library by a precise semantics. The main differences |
|
151 with the <code>mpf</code> class from GNU MP are: |
|
152 |
|
153 <ul> |
|
154 <li>the MPFR code is portable, i.e. the result of any operation |
|
155 does not depend (or should not) on the machine word size |
|
156 <code>mp_bits_per_limb</code> (32 or 64 on most machines); |
|
157 <li>the precision in bits can be set exactly to any valid value |
|
158 for each variable (including very small precision); |
|
159 <li>MPFR provides the four rounding modes from the IEEE 754-1985 |
|
160 standard. |
|
161 </ul> |
|
162 |
|
163 <p>In particular, with a precision of 53 bits, MPFR should be able to |
|
164 exactly reproduce all computations with double-precision machine |
|
165 floating-point numbers (e.g., <code>double</code> type in C, with a C |
|
166 implementation that rigorously follows Annex F of the ISO C99 standard |
|
167 and <code>FP_CONTRACT</code> pragma set to <code>OFF</code>) on the four arithmetic |
|
168 operations and the square root, except the default exponent range is much |
|
169 wider and subnormal numbers are not implemented (but can be emulated). |
|
170 |
|
171 <p>This version of MPFR is released under the GNU Lesser General Public |
|
172 License, Version 2.1 or any later version. |
|
173 It is permitted to link MPFR to most non-free programs, as long as when |
|
174 distributing them the MPFR source code and a means to re-link with a |
|
175 modified MPFR library is provided. |
|
176 |
|
177 <h3 class="section">1.1 How to Use This Manual</h3> |
|
178 |
|
179 <p>Everyone should read <a href="#MPFR-Basics">MPFR Basics</a>. If you need to install the library |
|
180 yourself, you need to read <a href="#Installing-MPFR">Installing MPFR</a>, too. |
|
181 |
|
182 <p>The rest of the manual can be used for later reference, although it is |
|
183 probably a good idea to glance through it. |
|
184 |
|
185 <div class="node"> |
|
186 <p><hr> |
|
187 <a name="Installing-MPFR"></a> |
|
188 Next: <a rel="next" accesskey="n" href="#Reporting-Bugs">Reporting Bugs</a>, |
|
189 Previous: <a rel="previous" accesskey="p" href="#Introduction-to-MPFR">Introduction to MPFR</a>, |
|
190 Up: <a rel="up" accesskey="u" href="#Top">Top</a> |
|
191 |
|
192 </div> |
|
193 |
|
194 <!-- node-name, next, previous, up --> |
|
195 <h2 class="chapter">2 Installing MPFR</h2> |
|
196 |
|
197 <p><a name="index-Installation-3"></a> |
|
198 |
|
199 <h3 class="section">2.1 How to Install</h3> |
|
200 |
|
201 <p>Here are the steps needed to install the library on Unix systems |
|
202 (more details are provided in the <samp><span class="file">INSTALL</span></samp> file): |
|
203 |
|
204 <ol type=1 start=1> |
|
205 <li>To build MPFR, you first have to install GNU MP |
|
206 (version 4.1 or higher) on your computer. |
|
207 You need a C compiler, preferably GCC, but any reasonable compiler should |
|
208 work. And you need a standard Unix ‘<samp><span class="samp">make</span></samp>’ program, plus some other |
|
209 standard Unix utility programs. |
|
210 |
|
211 <li>In the MPFR build directory, type |
|
212 ‘<samp><span class="samp">./configure</span></samp>’ |
|
213 |
|
214 <p>This will prepare the build and setup the options according to your system. |
|
215 If you get error messages, you might check that you use the same compiler |
|
216 and compile options as for GNU MP (see the <samp><span class="file">INSTALL</span></samp> file). |
|
217 |
|
218 <li>‘<samp><span class="samp">make</span></samp>’ |
|
219 |
|
220 <p>This will compile MPFR, and create a library archive file <samp><span class="file">libmpfr.a</span></samp>. |
|
221 A dynamic library may be produced too (see configure). |
|
222 |
|
223 <li>‘<samp><span class="samp">make check</span></samp>’ |
|
224 |
|
225 <p>This will make sure MPFR was built correctly. |
|
226 If you get error messages, please |
|
227 report this to ‘<samp><span class="samp">[email protected]</span></samp>’. (See <a href="#Reporting-Bugs">Reporting Bugs</a>, for |
|
228 information on what to include in useful bug reports.) |
|
229 |
|
230 <li>‘<samp><span class="samp">make install</span></samp>’ |
|
231 |
|
232 <p>This will copy the files <samp><span class="file">mpfr.h</span></samp> and <samp><span class="file">mpf2mpfr.h</span></samp> to the directory |
|
233 <samp><span class="file">/usr/local/include</span></samp>, the file <samp><span class="file">libmpfr.a</span></samp> to the directory |
|
234 <samp><span class="file">/usr/local/lib</span></samp>, and the file <samp><span class="file">mpfr.info</span></samp> to the directory |
|
235 <samp><span class="file">/usr/local/share/info</span></samp> (or if you passed the ‘<samp><span class="samp">--prefix</span></samp>’ option to |
|
236 <samp><span class="file">configure</span></samp>, using the prefix directory given as argument to |
|
237 ‘<samp><span class="samp">--prefix</span></samp>’ instead of <samp><span class="file">/usr/local</span></samp>). |
|
238 </ol> |
|
239 |
|
240 <h3 class="section">2.2 Other `make' Targets</h3> |
|
241 |
|
242 <p>There are some other useful make targets: |
|
243 |
|
244 <ul> |
|
245 <li>‘<samp><span class="samp">mpfr.info</span></samp>’ or ‘<samp><span class="samp">info</span></samp>’ |
|
246 |
|
247 <p>Create an info version of the manual, in <samp><span class="file">mpfr.info</span></samp>. |
|
248 |
|
249 <li>‘<samp><span class="samp">mpfr.pdf</span></samp>’ or ‘<samp><span class="samp">pdf</span></samp>’ |
|
250 |
|
251 <p>Create a PDF version of the manual, in <samp><span class="file">mpfr.pdf</span></samp>. |
|
252 |
|
253 <li>‘<samp><span class="samp">mpfr.dvi</span></samp>’ or ‘<samp><span class="samp">dvi</span></samp>’ |
|
254 |
|
255 <p>Create a DVI version of the manual, in <samp><span class="file">mpfr.dvi</span></samp>. |
|
256 |
|
257 <li>‘<samp><span class="samp">mpfr.ps</span></samp>’ or ‘<samp><span class="samp">ps</span></samp>’ |
|
258 |
|
259 <p>Create a Postscript version of the manual, in <samp><span class="file">mpfr.ps</span></samp>. |
|
260 |
|
261 <li>‘<samp><span class="samp">mpfr.html</span></samp>’ or ‘<samp><span class="samp">html</span></samp>’ |
|
262 |
|
263 <p>Create a HTML version of the manual, in several pages in the directory |
|
264 <samp><span class="file">mpfr.html</span></samp>; if you want only one output HTML file, then type |
|
265 ‘<samp><span class="samp">makeinfo --html --no-split mpfr.texi</span></samp>’ instead. |
|
266 |
|
267 <li>‘<samp><span class="samp">clean</span></samp>’ |
|
268 |
|
269 <p>Delete all object files and archive files, but not the configuration files. |
|
270 |
|
271 <li>‘<samp><span class="samp">distclean</span></samp>’ |
|
272 |
|
273 <p>Delete all files not included in the distribution. |
|
274 |
|
275 <li>‘<samp><span class="samp">uninstall</span></samp>’ |
|
276 |
|
277 <p>Delete all files copied by ‘<samp><span class="samp">make install</span></samp>’. |
|
278 </ul> |
|
279 |
|
280 <h3 class="section">2.3 Build Problems</h3> |
|
281 |
|
282 <p>In case of problem, please read the <samp><span class="file">INSTALL</span></samp> file carefully |
|
283 before reporting a bug, in particular section “In case of problem”. |
|
284 Some problems are due to bad configuration on the user side (not |
|
285 specific to MPFR). Problems are also mentioned in the FAQ |
|
286 <a href="http://www.mpfr.org/faq.html">http://www.mpfr.org/faq.html</a>. |
|
287 |
|
288 <!-- Warning! Do not split "MPFR ... @url{...}" across several lines --> |
|
289 <!-- as this needs to be updated with update-version. --> |
|
290 <p>Please report problems to ‘<samp><span class="samp">[email protected]</span></samp>’. |
|
291 See <a href="#Reporting-Bugs">Reporting Bugs</a>. |
|
292 Some bug fixes are available on the |
|
293 MPFR 2.3.2 web page <a href="http://www.mpfr.org/mpfr-2.3.2/">http://www.mpfr.org/mpfr-2.3.2/</a>. |
|
294 |
|
295 <h3 class="section">2.4 Getting the Latest Version of MPFR</h3> |
|
296 |
|
297 <p>The latest version of MPFR is available from <a href="http://www.mpfr.org/">http://www.mpfr.org/</a>. |
|
298 |
|
299 <div class="node"> |
|
300 <p><hr> |
|
301 <a name="Reporting-Bugs"></a> |
|
302 Next: <a rel="next" accesskey="n" href="#MPFR-Basics">MPFR Basics</a>, |
|
303 Previous: <a rel="previous" accesskey="p" href="#Installing-MPFR">Installing MPFR</a>, |
|
304 Up: <a rel="up" accesskey="u" href="#Top">Top</a> |
|
305 |
|
306 </div> |
|
307 |
|
308 <!-- node-name, next, previous, up --> |
|
309 <h2 class="chapter">3 Reporting Bugs</h2> |
|
310 |
|
311 <p><a name="index-Reporting-bugs-4"></a> |
|
312 <!-- Warning! Do not split "MPFR ... @url{...}" across several lines --> |
|
313 <!-- as this needs to be updated with update-version. --> |
|
314 If you think you have found a bug in the MPFR library, first have a look |
|
315 on the MPFR 2.3.2 web page <a href="http://www.mpfr.org/mpfr-2.3.2/">http://www.mpfr.org/mpfr-2.3.2/</a> and the |
|
316 FAQ <a href="http://www.mpfr.org/faq.html">http://www.mpfr.org/faq.html</a>: |
|
317 perhaps this bug is already known, in which case you may find there |
|
318 a workaround for it. Otherwise, please investigate and report it. |
|
319 We have made this library available to you, and it is not to ask too |
|
320 much from you, to ask you to report the bugs that you find. |
|
321 |
|
322 <p>There are a few things you should think about when you put your bug report |
|
323 together. |
|
324 |
|
325 <p>You have to send us a test case that makes it possible for us to reproduce the |
|
326 bug. Include instructions on how to run the test case. |
|
327 |
|
328 <p>You also have to explain what is wrong; if you get a crash, or if the results |
|
329 printed are incorrect and in that case, in what way. |
|
330 |
|
331 <p>Please include compiler version information in your bug report. This can |
|
332 be extracted using ‘<samp><span class="samp">cc -V</span></samp>’ on some machines, or, if you're using gcc, |
|
333 ‘<samp><span class="samp">gcc -v</span></samp>’. Also, include the output from ‘<samp><span class="samp">uname -a</span></samp>’ and the MPFR |
|
334 version (the GMP version may be useful too). |
|
335 |
|
336 <p>If your bug report is good, we will do our best to help you to get a corrected |
|
337 version of the library; if the bug report is poor, we won't do anything about |
|
338 it (aside of chiding you to send better bug reports). |
|
339 |
|
340 <p>Send your bug report to: ‘<samp><span class="samp">[email protected]</span></samp>’. |
|
341 |
|
342 <p>If you think something in this manual is unclear, or downright incorrect, or if |
|
343 the language needs to be improved, please send a note to the same address. |
|
344 |
|
345 <div class="node"> |
|
346 <p><hr> |
|
347 <a name="MPFR-Basics"></a> |
|
348 Next: <a rel="next" accesskey="n" href="#MPFR-Interface">MPFR Interface</a>, |
|
349 Previous: <a rel="previous" accesskey="p" href="#Reporting-Bugs">Reporting Bugs</a>, |
|
350 Up: <a rel="up" accesskey="u" href="#Top">Top</a> |
|
351 |
|
352 </div> |
|
353 |
|
354 <!-- node-name, next, previous, up --> |
|
355 <h2 class="chapter">4 MPFR Basics</h2> |
|
356 |
|
357 <h3 class="section">4.1 Headers and Libraries</h3> |
|
358 |
|
359 <p><a name="index-g_t_0040file_007bmpfr_002eh_007d-5"></a>All declarations needed to use MPFR are collected in the include file |
|
360 <samp><span class="file">mpfr.h</span></samp>. It is designed to work with both C and C++ compilers. |
|
361 You should include that file in any program using the MPFR library: |
|
362 |
|
363 <pre class="example"> #include <mpfr.h> |
|
364 </pre> |
|
365 <p><a name="index-g_t_0040code_007bstdio_002eh_007d-6"></a>Note however that prototypes for MPFR functions with <code>FILE *</code> parameters |
|
366 are provided only if <code><stdio.h></code> is included too (before <samp><span class="file">mpfr.h</span></samp>). |
|
367 |
|
368 <pre class="example"> #include <stdio.h> |
|
369 #include <mpfr.h> |
|
370 </pre> |
|
371 <p>You can avoid the use of MPFR macros encapsulating functions by defining |
|
372 the ‘<samp><span class="samp">MPFR_USE_NO_MACRO</span></samp>’ macro before <samp><span class="file">mpfr.h</span></samp> is included. In |
|
373 general this should not be necessary, but this can be useful when debugging |
|
374 user code: with some macros, the compiler may emit spurious warnings with |
|
375 some warning options, and macros can prevent some prototype checking. |
|
376 |
|
377 <p><a name="index-Libraries-7"></a><a name="index-Linking-8"></a><a name="index-g_t_0040code_007blibmpfr_007d-9"></a>All programs using MPFR must link against both <samp><span class="file">libmpfr</span></samp> and |
|
378 <samp><span class="file">libgmp</span></samp> libraries. On a typical Unix-like system this can be |
|
379 done with ‘<samp><span class="samp">-lmpfr -lgmp</span></samp>’ (in that order), for example |
|
380 |
|
381 <pre class="example"> gcc myprogram.c -lmpfr -lgmp |
|
382 </pre> |
|
383 <p><a name="index-Libtool-10"></a>MPFR is built using Libtool and an application can use that to link if |
|
384 desired, see <cite>GNU Libtool</cite>. |
|
385 <!-- Note: Do not try the above cross reference without moving mpfr.info --> |
|
386 <!-- into some "safe" place first. Due to a poor design, "info" will not --> |
|
387 <!-- find the correct libtool info file because of the "libtool" script --> |
|
388 <!-- in MPFR's directory! --> |
|
389 |
|
390 <p>If MPFR has been installed to a non-standard location, then it may be |
|
391 necessary to set up environment variables such as ‘<samp><span class="samp">C_INCLUDE_PATH</span></samp>’ |
|
392 and ‘<samp><span class="samp">LIBRARY_PATH</span></samp>’, or use ‘<samp><span class="samp">-I</span></samp>’ and ‘<samp><span class="samp">-L</span></samp>’ compiler options, |
|
393 in order to point to the right directories. For a shared library, it may |
|
394 also be necessary to set up some sort of run-time library path (e.g., |
|
395 ‘<samp><span class="samp">LD_LIBRARY_PATH</span></samp>’) on some systems. Please read the <samp><span class="file">INSTALL</span></samp> |
|
396 file for additional information. |
|
397 |
|
398 <h3 class="section">4.2 Nomenclature and Types</h3> |
|
399 |
|
400 <p><a name="index-Floating_002dpoint-number-11"></a><a name="index-g_t_0040code_007bmpfr_005ft_007d-12"></a>A <dfn>floating-point number</dfn> or <dfn>float</dfn> for short, is an arbitrary |
|
401 precision significand (also called mantissa) with a limited precision |
|
402 exponent. The C data type |
|
403 for such objects is <code>mpfr_t</code> (internally defined as a one-element |
|
404 array of a structure, and <code>mpfr_ptr</code> is the C data type representing |
|
405 a pointer to this structure). A floating-point number can have |
|
406 three special values: Not-a-Number (NaN) or plus or minus Infinity. NaN |
|
407 represents an uninitialized object, the result of an invalid operation |
|
408 (like 0 divided by 0), or a value that cannot be determined (like |
|
409 +Infinity minus +Infinity). Moreover, like in the IEEE 754-1985 standard, |
|
410 zero is signed, i.e. there are both +0 and −0; the behavior |
|
411 is the same as in the IEEE 754-1985 standard and it is generalized to |
|
412 the other functions supported by MPFR. |
|
413 |
|
414 <p><a name="index-Precision-13"></a><a name="index-g_t_0040code_007bmp_005fprec_005ft_007d-14"></a>The <dfn>precision</dfn> is the number of bits used to represent the significand |
|
415 of a floating-point number; |
|
416 the corresponding C data type is <code>mp_prec_t</code>. |
|
417 The precision can be any integer between <code>MPFR_PREC_MIN</code> and |
|
418 <code>MPFR_PREC_MAX</code>. In the current implementation, <code>MPFR_PREC_MIN</code> |
|
419 is equal to 2. |
|
420 |
|
421 <p>Warning! MPFR needs to increase the precision internally, in order to |
|
422 provide accurate results (and in particular, correct rounding). Do not |
|
423 attempt to set the precision to any value near <code>MPFR_PREC_MAX</code>, |
|
424 otherwise MPFR will abort due to an assertion failure. Moreover, you |
|
425 may reach some memory limit on your platform, in which case the program |
|
426 may abort, crash or have undefined behavior (depending on your C |
|
427 implementation). |
|
428 |
|
429 <p><a name="index-Rounding-Modes-15"></a><a name="index-g_t_0040code_007bmp_005frnd_005ft_007d-16"></a>The <dfn>rounding mode</dfn> specifies the way to round the result of a |
|
430 floating-point operation, in case the exact result can not be represented |
|
431 exactly in the destination significand; |
|
432 the corresponding C data type is <code>mp_rnd_t</code>. |
|
433 |
|
434 <p><a name="index-Limb-17"></a><!-- @tindex @code{mp_limb_t} --> |
|
435 A <dfn>limb</dfn> means the part of a multi-precision number that fits in a single |
|
436 word. (We chose this word because a limb of the human body is analogous to a |
|
437 digit, only larger, and containing several digits.) Normally a limb contains |
|
438 32 or 64 bits. The C data type for a limb is <code>mp_limb_t</code>. |
|
439 |
|
440 <h3 class="section">4.3 Function Classes</h3> |
|
441 |
|
442 <p>There is only one class of functions in the MPFR library: |
|
443 |
|
444 <ol type=1 start=1> |
|
445 <li>Functions for floating-point arithmetic, with names beginning with |
|
446 <code>mpfr_</code>. The associated type is <code>mpfr_t</code>. |
|
447 </ol> |
|
448 |
|
449 <h3 class="section">4.4 MPFR Variable Conventions</h3> |
|
450 |
|
451 <p>As a general rule, all MPFR functions expect output arguments before input |
|
452 arguments. This notation is based on an analogy with the assignment operator. |
|
453 |
|
454 <p>MPFR allows you to use the same variable for both input and output in the same |
|
455 expression. For example, the main function for floating-point multiplication, |
|
456 <code>mpfr_mul</code>, can be used like this: <code>mpfr_mul (x, x, x, rnd_mode)</code>. |
|
457 This |
|
458 computes the square of <var>x</var> with rounding mode <code>rnd_mode</code> |
|
459 and puts the result back in <var>x</var>. |
|
460 |
|
461 <p>Before you can assign to an MPFR variable, you need to initialize it by calling |
|
462 one of the special initialization functions. When you're done with a |
|
463 variable, you need to clear it out, using one of the functions for that |
|
464 purpose. |
|
465 |
|
466 <p>A variable should only be initialized once, or at least cleared out between |
|
467 each initialization. After a variable has been initialized, it may be |
|
468 assigned to any number of times. |
|
469 |
|
470 <p>For efficiency reasons, avoid to initialize and clear out a variable in loops. |
|
471 Instead, initialize it before entering the loop, and clear it out after the |
|
472 loop has exited. |
|
473 |
|
474 <p>You don't need to be concerned about allocating additional space for MPFR |
|
475 variables, since any variable has a significand of fixed size. |
|
476 Hence unless you change its precision, or clear and reinitialize it, |
|
477 a floating-point variable will have the same allocated space during all its |
|
478 life. |
|
479 |
|
480 <h3 class="section">4.5 Rounding Modes</h3> |
|
481 |
|
482 <p>The following four rounding modes are supported: |
|
483 |
|
484 <ul> |
|
485 <li><code>GMP_RNDN</code>: round to nearest |
|
486 <li><code>GMP_RNDZ</code>: round toward zero |
|
487 <li><code>GMP_RNDU</code>: round toward plus infinity |
|
488 <li><code>GMP_RNDD</code>: round toward minus infinity |
|
489 </ul> |
|
490 |
|
491 <p>The ‘<samp><span class="samp">round to nearest</span></samp>’ mode works as in the IEEE 754-1985 standard: in |
|
492 case the number to be rounded lies exactly in the middle of two representable |
|
493 numbers, it is rounded to the one with the least significant bit set to zero. |
|
494 For example, the number 5/2, which is represented by (10.1) in binary, is |
|
495 rounded to (10.0)=2 with a precision of two bits, and not to (11.0)=3. |
|
496 This rule avoids the <dfn>drift</dfn> phenomenon mentioned by Knuth in volume 2 |
|
497 of The Art of Computer Programming (Section 4.2.2). |
|
498 |
|
499 <p>Most MPFR functions take as first argument the destination variable, as |
|
500 second and following arguments the input variables, as last argument a |
|
501 rounding mode, and have a return value of type <code>int</code>, called the |
|
502 <dfn>ternary value</dfn>. The value stored in the destination variable is |
|
503 correctly rounded, i.e. MPFR behaves as if it computed the result with |
|
504 an infinite precision, then rounded it to the precision of this variable. |
|
505 The input variables are regarded as exact (in particular, their precision |
|
506 does not affect the result). |
|
507 |
|
508 <p>As a consequence, in case of a non-zero real rounded result, the error |
|
509 on the result is less or equal to 1/2 ulp (unit in the last place) of |
|
510 the target in the rounding to nearest mode, and less than 1 ulp of the |
|
511 target in the directed rounding modes (a ulp is the weight of the least |
|
512 significant represented bit of the target after rounding). |
|
513 <!-- Since subnormals are not supported, we must take into account the ulp of --> |
|
514 <!-- the rounded result, not the one of the exact result, for full generality. --> |
|
515 |
|
516 <p>Unless documented otherwise, functions returning an <code>int</code> return |
|
517 a ternary value. |
|
518 If the ternary value is zero, it means that the value stored in the |
|
519 destination variable is the exact result of the corresponding mathematical |
|
520 function. If the ternary value is positive (resp. negative), it means |
|
521 the value stored in the destination variable is greater (resp. lower) |
|
522 than the exact result. For example with the <code>GMP_RNDU</code> rounding mode, |
|
523 the ternary value is usually positive, except when the result is exact, in |
|
524 which case it is zero. In the case of an infinite result, it is considered |
|
525 as inexact when it was obtained by overflow, and exact otherwise. A NaN |
|
526 result (Not-a-Number) always corresponds to an exact return value. |
|
527 The opposite of a returned ternary value is guaranteed to be representable |
|
528 in an <code>int</code>. |
|
529 |
|
530 <p>Unless documented otherwise, functions returning a <code>1</code> |
|
531 (or any other value specified in this manual) |
|
532 for special cases (like <code>acos(0)</code>) should return an overflow or |
|
533 an underflow if <code>1</code> is not representable in the current exponent range. |
|
534 |
|
535 <h3 class="section">4.6 Floating-Point Values on Special Numbers</h3> |
|
536 |
|
537 <p>This section specifies the floating-point values (of type <code>mpfr_t</code>) |
|
538 returned by MPFR functions. For functions returning several values (like |
|
539 <code>mpfr_sin_cos</code>), the rules apply to each result separately. |
|
540 |
|
541 <p>Functions can have one or several input arguments. An input point is |
|
542 a mapping from these input arguments to the set of the MPFR numbers. |
|
543 When none of its components are NaN, an input point can also be seen |
|
544 as a tuple in the extended real numbers (the set of the real numbers |
|
545 with both infinities). |
|
546 |
|
547 <p>When the input point is in the domain of the mathematical function, the |
|
548 result is rounded as described in Section “Rounding Modes” (but see |
|
549 below for the specification of the sign of an exact zero). Otherwise |
|
550 the general rules from this section apply unless stated otherwise in |
|
551 the description of the MPFR function (<a href="#MPFR-Interface">MPFR Interface</a>). |
|
552 |
|
553 <p>When the input point is not in the domain of the mathematical function |
|
554 but is in its closure in the extended real numbers and the function can |
|
555 be extended by continuity, the result is the obtained limit. |
|
556 Examples: <code>mpfr_hypot</code> on (+Inf,0) gives +Inf. But <code>mpfr_pow</code> |
|
557 cannot be defined on (1,+Inf) using this rule, as one can find |
|
558 sequences (<var>x</var>_<var>n</var>,<var>y</var>_<var>n</var>) such that |
|
559 <var>x</var>_<var>n</var> goes to 1, <var>y</var>_<var>n</var> goes to +Inf |
|
560 and <var>x</var>_<var>n</var> to the <var>y</var>_<var>n</var> goes to any |
|
561 positive value when <var>n</var> goes to the infinity. |
|
562 |
|
563 <p>When the input point is in the closure of the domain of the mathematical |
|
564 function and an input argument is +0 (resp. −0), one considers |
|
565 the limit when the corresponding argument approaches 0 from above |
|
566 (resp. below). If the limit is not defined (e.g., <code>mpfr_log</code> on |
|
567 −0), the behavior must be specified in the description of the |
|
568 MPFR function. |
|
569 |
|
570 <p>When the result is equal to 0, its sign is determined by considering the |
|
571 limit as if the input point were not in the domain: If one approaches 0 |
|
572 from above (resp. below), the result is +0 (resp. −0). In the |
|
573 other cases, the sign must be specified in the description of the MPFR |
|
574 function. Example: <code>mpfr_sin</code> on +0 gives +0. |
|
575 |
|
576 <p>When the input point is not in the closure of the domain of the function, |
|
577 the result is NaN. Example: <code>mpfr_sqrt</code> on −17 gives NaN. |
|
578 |
|
579 <p>When an input argument is NaN, the result is NaN, possibly except when |
|
580 a partial function is constant on the finite floating-point numbers; |
|
581 such a case is always explicitly specified in <a href="#MPFR-Interface">MPFR Interface</a>. |
|
582 <!-- Said otherwise, if such a case is not specified, this is a bug, thus --> |
|
583 <!-- we may change the returned value after documenting it without having --> |
|
584 <!-- to change the libtool interface number (this would have more drawbacks --> |
|
585 <!-- that advantages in practice), like for any bug fix. --> |
|
586 Example: <code>mpfr_hypot</code> on (NaN,0) gives NaN, but <code>mpfr_hypot</code> |
|
587 on (NaN,+Inf) gives +Inf (as specified in <a href="#Special-Functions">Special Functions</a>), |
|
588 since for any finite input <var>x</var>, <code>mpfr_hypot</code> on (<var>x</var>,+Inf) |
|
589 gives +Inf. |
|
590 |
|
591 <h3 class="section">4.7 Exceptions</h3> |
|
592 |
|
593 <p>MPFR supports 5 exception types: |
|
594 |
|
595 <ul> |
|
596 <li>Underflow: |
|
597 An underflow occurs when the exact result of a function is a non-zero |
|
598 real number and the result obtained after the rounding, assuming an |
|
599 unbounded exponent range (for the rounding), has an exponent smaller |
|
600 than the minimum exponent of the current range. In the round-to-nearest |
|
601 mode, the halfway case is rounded toward zero. |
|
602 |
|
603 <p>Note: This is not the single definition of the underflow. MPFR chooses |
|
604 to consider the underflow after rounding. The underflow before rounding |
|
605 can also be defined. For instance, consider a function that has the |
|
606 exact result 7 multiplied by two to the power |
|
607 <var>e</var>−4, where <var>e</var> is the smallest exponent (for a |
|
608 significand between 1/2 and 1) in the current |
|
609 range, with a 2-bit target precision and rounding toward plus infinity. |
|
610 The exact result has the exponent <var>e</var>−1. With the underflow |
|
611 before rounding, such a function call would yield an underflow, as |
|
612 <var>e</var>−1 is outside the current exponent range. However, MPFR |
|
613 first considers the rounded result assuming an unbounded exponent range. |
|
614 The exact result cannot be represented exactly in precision 2, and here, |
|
615 it is rounded to 0.5 times 2 to <var>e</var>, which is |
|
616 representable in the current exponent range. As a consequence, this will |
|
617 not yield an underflow in MPFR. |
|
618 |
|
619 <li>Overflow: |
|
620 An overflow occurs when the exact result of a function is a non-zero |
|
621 real number and the result obtained after the rounding, assuming an |
|
622 unbounded exponent range (for the rounding), has an exponent larger |
|
623 than the maximum exponent of the current range. In the round-to-nearest |
|
624 mode, the result is infinite. |
|
625 |
|
626 <li>NaN: |
|
627 A NaN exception occurs when the result of a function is a NaN. |
|
628 <!-- NaN is defined above. So, we don't say anything more. --> |
|
629 |
|
630 <li>Inexact: |
|
631 An inexact exception occurs when the result of a function cannot be |
|
632 represented exactly and must be rounded. |
|
633 |
|
634 <li>Range error: |
|
635 A range exception occurs when a function that does not return a MPFR |
|
636 number (such as comparisons and conversions to an integer) has an |
|
637 invalid result (e.g. an argument is NaN in <code>mpfr_cmp</code> or in a |
|
638 conversion to an integer). |
|
639 |
|
640 </ul> |
|
641 |
|
642 <p>MPFR has a global flag for each exception, which can be cleared, set |
|
643 or tested by functions described in <a href="#Exception-Related-Functions">Exception Related Functions</a>. |
|
644 |
|
645 <p>Differences with the ISO C99 standard: |
|
646 |
|
647 <ul> |
|
648 <li>In C, only quiet NaNs are specified, and a NaN propagation does not |
|
649 raise an invalid exception. Unless explicitly stated otherwise, MPFR sets |
|
650 the NaN flag whenever a NaN is generated, even when a NaN is propagated |
|
651 (e.g. in NaN + NaN), as if all NaNs were signaling. |
|
652 |
|
653 <li>An invalid exception in C corresponds to either a NaN exception or |
|
654 a range error in MPFR. |
|
655 |
|
656 </ul> |
|
657 |
|
658 <h3 class="section">4.8 Memory Handling</h3> |
|
659 |
|
660 <p>MPFR functions may create caches, e.g. when computing constants such |
|
661 as Pi, either because the user has called a function like |
|
662 <code>mpfr_const_pi</code> directly or because such a function was called |
|
663 internally by the MPFR library itself to compute some other function. |
|
664 |
|
665 <p>At any time, the user can free the various caches with |
|
666 <code>mpfr_free_cache</code>. It is strongly advised to do that before |
|
667 terminating a thread, or before exiting when using tools like |
|
668 ‘<samp><span class="samp">valgrind</span></samp>’ (to avoid memory leaks being reported). |
|
669 |
|
670 <p>MPFR internal data such as flags, the exponent range, the default |
|
671 precision and rounding mode, and caches (i.e., data that are not |
|
672 accessed via parameters) are either global (if MPFR has not been |
|
673 compiled as thread safe) or per-thread (thread local storage). |
|
674 |
|
675 <div class="node"> |
|
676 <p><hr> |
|
677 <a name="MPFR-Interface"></a> |
|
678 Next: <a rel="next" accesskey="n" href="#Contributors">Contributors</a>, |
|
679 Previous: <a rel="previous" accesskey="p" href="#MPFR-Basics">MPFR Basics</a>, |
|
680 Up: <a rel="up" accesskey="u" href="#Top">Top</a> |
|
681 |
|
682 </div> |
|
683 |
|
684 <!-- node-name, next, previous, up --> |
|
685 <h2 class="chapter">5 MPFR Interface</h2> |
|
686 |
|
687 <p><a name="index-Floating_002dpoint-functions-18"></a><a name="index-Float-functions-19"></a> |
|
688 The floating-point functions expect arguments of type <code>mpfr_t</code>. |
|
689 |
|
690 <p>The MPFR floating-point functions have an interface that is similar to the |
|
691 GNU MP |
|
692 integer functions. The function prefix for floating-point operations is |
|
693 <code>mpfr_</code>. |
|
694 |
|
695 <p>There is one significant characteristic of floating-point numbers that has |
|
696 motivated a difference between this function class and other GNU MP function |
|
697 classes: the inherent inexactness of floating-point arithmetic. The user has |
|
698 to specify the precision for each variable. A computation that assigns a |
|
699 variable will take place with the precision of the assigned variable; the |
|
700 cost of that computation should not depend from the |
|
701 precision of variables used as input (on average). |
|
702 |
|
703 <p><a name="index-Precision-20"></a>The semantics of a calculation in MPFR is specified as follows: Compute the |
|
704 requested operation exactly (with “infinite accuracy”), and round the result |
|
705 to the precision of the destination variable, with the given rounding mode. |
|
706 The MPFR floating-point functions are intended to be a smooth extension |
|
707 of the IEEE 754-1985 arithmetic. The results obtained on one computer should |
|
708 not differ from the results obtained on a computer with a different word size. |
|
709 |
|
710 <p><a name="index-Accuracy-21"></a>MPFR does not keep track of the accuracy of a computation. This is left |
|
711 to the user or to a higher layer. |
|
712 As a consequence, if two variables are used to store |
|
713 only a few significant bits, and their product is stored in a variable with large |
|
714 precision, then MPFR will still compute the result with full precision. |
|
715 |
|
716 <p>The value of the standard C macro <code>errno</code> may be set to non-zero by |
|
717 any MPFR function or macro, whether or not there is an error. |
|
718 |
|
719 <ul class="menu"> |
|
720 <li><a accesskey="1" href="#Initialization-Functions">Initialization Functions</a> |
|
721 <li><a accesskey="2" href="#Assignment-Functions">Assignment Functions</a> |
|
722 <li><a accesskey="3" href="#Combined-Initialization-and-Assignment-Functions">Combined Initialization and Assignment Functions</a> |
|
723 <li><a accesskey="4" href="#Conversion-Functions">Conversion Functions</a> |
|
724 <li><a accesskey="5" href="#Basic-Arithmetic-Functions">Basic Arithmetic Functions</a> |
|
725 <li><a accesskey="6" href="#Comparison-Functions">Comparison Functions</a> |
|
726 <li><a accesskey="7" href="#Special-Functions">Special Functions</a> |
|
727 <li><a accesskey="8" href="#Input-and-Output-Functions">Input and Output Functions</a> |
|
728 <li><a accesskey="9" href="#Integer-Related-Functions">Integer Related Functions</a> |
|
729 <li><a href="#Miscellaneous-Functions">Miscellaneous Functions</a> |
|
730 <li><a href="#Rounding-Mode-Related-Functions">Rounding Mode Related Functions</a> |
|
731 <li><a href="#Exception-Related-Functions">Exception Related Functions</a> |
|
732 <li><a href="#Advanced-Functions">Advanced Functions</a> |
|
733 <li><a href="#Compatibility-with-MPF">Compatibility with MPF</a> |
|
734 <li><a href="#Custom-Interface">Custom Interface</a> |
|
735 <li><a href="#Internals">Internals</a> |
|
736 </ul> |
|
737 |
|
738 <div class="node"> |
|
739 <p><hr> |
|
740 <a name="Initialization-Functions"></a> |
|
741 Next: <a rel="next" accesskey="n" href="#Assignment-Functions">Assignment Functions</a>, |
|
742 Previous: <a rel="previous" accesskey="p" href="#MPFR-Interface">MPFR Interface</a>, |
|
743 Up: <a rel="up" accesskey="u" href="#MPFR-Interface">MPFR Interface</a> |
|
744 |
|
745 </div> |
|
746 |
|
747 <!-- node-name, next, previous, up --> |
|
748 <p><a name="index-Initialization-functions-22"></a> |
|
749 |
|
750 <h3 class="section">5.1 Initialization Functions</h3> |
|
751 |
|
752 <p>An <code>mpfr_t</code> object must be initialized before storing the first value in |
|
753 it. The functions <code>mpfr_init</code> and <code>mpfr_init2</code> are used for that |
|
754 purpose. |
|
755 |
|
756 <div class="defun"> |
|
757 — Function: void <b>mpfr_init2</b> (<var>mpfr_t x, mp_prec_t prec</var>)<var><a name="index-mpfr_005finit2-23"></a></var><br> |
|
758 <blockquote><p>Initialize <var>x</var>, set its precision to be <strong>exactly</strong> |
|
759 <var>prec</var> bits and its value to NaN. (Warning: the corresponding |
|
760 <code>mpf</code> functions initialize to zero instead.) |
|
761 |
|
762 <p>Normally, a variable should be initialized once only or at |
|
763 least be cleared, using <code>mpfr_clear</code>, between initializations. |
|
764 To change the precision of a variable which has already been initialized, |
|
765 use <code>mpfr_set_prec</code>. |
|
766 The precision <var>prec</var> must be an integer between <code>MPFR_PREC_MIN</code> and |
|
767 <code>MPFR_PREC_MAX</code> (otherwise the behavior is undefined). |
|
768 </p></blockquote></div> |
|
769 |
|
770 <div class="defun"> |
|
771 — Function: void <b>mpfr_clear</b> (<var>mpfr_t x</var>)<var><a name="index-mpfr_005fclear-24"></a></var><br> |
|
772 <blockquote><p>Free the space occupied by <var>x</var>. Make sure to call this function for all |
|
773 <code>mpfr_t</code> variables when you are done with them. |
|
774 </p></blockquote></div> |
|
775 |
|
776 <div class="defun"> |
|
777 — Function: void <b>mpfr_init</b> (<var>mpfr_t x</var>)<var><a name="index-mpfr_005finit-25"></a></var><br> |
|
778 <blockquote><p>Initialize <var>x</var> and set its value to NaN. |
|
779 |
|
780 <p>Normally, a variable should be initialized once only |
|
781 or at least be cleared, using <code>mpfr_clear</code>, between initializations. The |
|
782 precision of <var>x</var> is the default precision, which can be changed |
|
783 by a call to <code>mpfr_set_default_prec</code>. |
|
784 </p></blockquote></div> |
|
785 |
|
786 <div class="defun"> |
|
787 — Function: void <b>mpfr_set_default_prec</b> (<var>mp_prec_t prec</var>)<var><a name="index-mpfr_005fset_005fdefault_005fprec-26"></a></var><br> |
|
788 <blockquote><p>Set the default precision to be <strong>exactly</strong> <var>prec</var> bits. The |
|
789 precision of a variable means the number of bits used to store its significand. |
|
790 All |
|
791 subsequent calls to <code>mpfr_init</code> will use this precision, but previously |
|
792 initialized variables are unaffected. |
|
793 This default precision is set to 53 bits initially. |
|
794 The precision can be any integer between <code>MPFR_PREC_MIN</code> and |
|
795 <code>MPFR_PREC_MAX</code>. |
|
796 </p></blockquote></div> |
|
797 |
|
798 <div class="defun"> |
|
799 — Function: mp_prec_t <b>mpfr_get_default_prec</b> (<var>void</var>)<var><a name="index-mpfr_005fget_005fdefault_005fprec-27"></a></var><br> |
|
800 <blockquote><p>Return the default MPFR precision in bits. |
|
801 </p></blockquote></div> |
|
802 |
|
803 <p>Here is an example on how to initialize floating-point variables: |
|
804 |
|
805 <pre class="example"> { |
|
806 mpfr_t x, y; |
|
807 mpfr_init (x); /* use default precision */ |
|
808 mpfr_init2 (y, 256); /* precision <em>exactly</em> 256 bits */ |
|
809 ... |
|
810 /* When the program is about to exit, do ... */ |
|
811 mpfr_clear (x); |
|
812 mpfr_clear (y); |
|
813 mpfr_free_cache (); |
|
814 } |
|
815 </pre> |
|
816 <p>The following functions are useful for changing the precision during a |
|
817 calculation. A typical use would be for adjusting the precision gradually in |
|
818 iterative algorithms like Newton-Raphson, making the computation precision |
|
819 closely match the actual accurate part of the numbers. |
|
820 |
|
821 <div class="defun"> |
|
822 — Function: void <b>mpfr_set_prec</b> (<var>mpfr_t x, mp_prec_t prec</var>)<var><a name="index-mpfr_005fset_005fprec-28"></a></var><br> |
|
823 <blockquote><p>Reset the precision of <var>x</var> to be <strong>exactly</strong> <var>prec</var> bits, |
|
824 and set its value to NaN. |
|
825 The previous value stored in <var>x</var> is lost. It is equivalent to |
|
826 a call to <code>mpfr_clear(x)</code> followed by a call to |
|
827 <code>mpfr_init2(x, prec)</code>, but more efficient as no allocation is done in |
|
828 case the current allocated space for the significand of <var>x</var> is enough. |
|
829 The precision <var>prec</var> can be any integer between <code>MPFR_PREC_MIN</code> and |
|
830 <code>MPFR_PREC_MAX</code>. |
|
831 |
|
832 <p>In case you want to keep the previous value stored in <var>x</var>, |
|
833 use <code>mpfr_prec_round</code> instead. |
|
834 </p></blockquote></div> |
|
835 |
|
836 <div class="defun"> |
|
837 — Function: mp_prec_t <b>mpfr_get_prec</b> (<var>mpfr_t x</var>)<var><a name="index-mpfr_005fget_005fprec-29"></a></var><br> |
|
838 <blockquote><p>Return the precision actually used for assignments of <var>x</var>, i.e. the |
|
839 number of bits used to store its significand. |
|
840 </p></blockquote></div> |
|
841 |
|
842 <div class="node"> |
|
843 <p><hr> |
|
844 <a name="Assignment-Functions"></a> |
|
845 Next: <a rel="next" accesskey="n" href="#Combined-Initialization-and-Assignment-Functions">Combined Initialization and Assignment Functions</a>, |
|
846 Previous: <a rel="previous" accesskey="p" href="#Initialization-Functions">Initialization Functions</a>, |
|
847 Up: <a rel="up" accesskey="u" href="#MPFR-Interface">MPFR Interface</a> |
|
848 |
|
849 </div> |
|
850 |
|
851 <!-- node-name, next, previous, up --> |
|
852 <p><a name="index-Assignment-functions-30"></a> |
|
853 |
|
854 <h3 class="section">5.2 Assignment Functions</h3> |
|
855 |
|
856 <p>These functions assign new values to already initialized floats |
|
857 (see <a href="#Initialization-Functions">Initialization Functions</a>). When using any functions using |
|
858 <code>intmax_t</code>, you must include <code><stdint.h></code> or <code><inttypes.h></code> |
|
859 before <samp><span class="file">mpfr.h</span></samp>, to allow <samp><span class="file">mpfr.h</span></samp> to define prototypes for |
|
860 these functions. |
|
861 |
|
862 <div class="defun"> |
|
863 — Function: int <b>mpfr_set</b> (<var>mpfr_t rop, mpfr_t op, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fset-31"></a></var><br> |
|
864 — Function: int <b>mpfr_set_ui</b> (<var>mpfr_t rop, unsigned long int op, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fset_005fui-32"></a></var><br> |
|
865 — Function: int <b>mpfr_set_si</b> (<var>mpfr_t rop, long int op, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fset_005fsi-33"></a></var><br> |
|
866 — Function: int <b>mpfr_set_uj</b> (<var>mpfr_t rop, uintmax_t op, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fset_005fuj-34"></a></var><br> |
|
867 — Function: int <b>mpfr_set_sj</b> (<var>mpfr_t rop, intmax_t op, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fset_005fsj-35"></a></var><br> |
|
868 — Function: int <b>mpfr_set_d</b> (<var>mpfr_t rop, double op, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fset_005fd-36"></a></var><br> |
|
869 — Function: int <b>mpfr_set_ld</b> (<var>mpfr_t rop, long double op, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fset_005fld-37"></a></var><br> |
|
870 — Function: int <b>mpfr_set_decimal64</b> (<var>mpfr_t rop, _Decimal64 op, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fset_005fdecimal64-38"></a></var><br> |
|
871 — Function: int <b>mpfr_set_z</b> (<var>mpfr_t rop, mpz_t op, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fset_005fz-39"></a></var><br> |
|
872 — Function: int <b>mpfr_set_q</b> (<var>mpfr_t rop, mpq_t op, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fset_005fq-40"></a></var><br> |
|
873 — Function: int <b>mpfr_set_f</b> (<var>mpfr_t rop, mpf_t op, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fset_005ff-41"></a></var><br> |
|
874 <blockquote><p>Set the value of <var>rop</var> from <var>op</var>, rounded |
|
875 toward the given direction <var>rnd</var>. |
|
876 Note that the input 0 is converted to +0 by <code>mpfr_set_ui</code>, |
|
877 <code>mpfr_set_si</code>, <code>mpfr_set_sj</code>, <code>mpfr_set_uj</code>, |
|
878 <code>mpfr_set_z</code>, <code>mpfr_set_q</code> and |
|
879 <code>mpfr_set_f</code>, regardless of the rounding mode. |
|
880 If the system doesn't support the IEEE-754 standard, <code>mpfr_set_d</code>, |
|
881 <code>mpfr_set_ld</code> and |
|
882 <code>mpfr_set_decimal64</code> might not preserve the signed zeros. |
|
883 The <code>mpfr_set_decimal64</code> function is built only with the configure |
|
884 option ‘<samp><span class="samp">--enable-decimal-float</span></samp>’, which also requires |
|
885 ‘<samp><span class="samp">--with-gmp-build</span></samp>’, and when the compiler or |
|
886 system provides the ‘<samp><span class="samp">_Decimal64</span></samp>’ data type |
|
887 (GCC version 4.2.0 is known to support this data type, |
|
888 but only when configured with ‘<samp><span class="samp">--enable-decimal-float</span></samp>’ too). |
|
889 <code>mpfr_set_q</code> might not be able to work if the numerator (or the |
|
890 denominator) can not be representable as a <code>mpfr_t</code>. |
|
891 |
|
892 <p>Note: If you want to store a floating-point constant to a <code>mpfr_t</code>, |
|
893 you should use <code>mpfr_set_str</code> (or one of the MPFR constant functions, |
|
894 such as <code>mpfr_const_pi</code> for Pi) instead of <code>mpfr_set_d</code>, |
|
895 <code>mpfr_set_ld</code> or <code>mpfr_set_decimal64</code>. |
|
896 Otherwise the floating-point constant will be first |
|
897 converted into a reduced-precision (e.g., 53-bit) binary number before |
|
898 MPFR can work with it. |
|
899 </p></blockquote></div> |
|
900 |
|
901 <div class="defun"> |
|
902 — Function: int <b>mpfr_set_ui_2exp</b> (<var>mpfr_t rop, unsigned long int op, mp_exp_t e, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fset_005fui_005f2exp-42"></a></var><br> |
|
903 — Function: int <b>mpfr_set_si_2exp</b> (<var>mpfr_t rop, long int op, mp_exp_t e, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fset_005fsi_005f2exp-43"></a></var><br> |
|
904 — Function: int <b>mpfr_set_uj_2exp</b> (<var>mpfr_t rop, uintmax_t op, intmax_t e, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fset_005fuj_005f2exp-44"></a></var><br> |
|
905 — Function: int <b>mpfr_set_sj_2exp</b> (<var>mpfr_t rop, intmax_t op, intmax_t e, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fset_005fsj_005f2exp-45"></a></var><br> |
|
906 <blockquote><p>Set the value of <var>rop</var> from <var>op</var> multiplied by |
|
907 two to the power <var>e</var>, rounded toward the given direction <var>rnd</var>. |
|
908 Note that the input 0 is converted to +0. |
|
909 </p></blockquote></div> |
|
910 |
|
911 <div class="defun"> |
|
912 — Function: int <b>mpfr_set_str</b> (<var>mpfr_t rop, const char *s, int base, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fset_005fstr-46"></a></var><br> |
|
913 <blockquote><p>Set <var>rop</var> to the value of the whole string <var>s</var> in base <var>base</var>, |
|
914 rounded in the direction <var>rnd</var>. |
|
915 See the documentation of <code>mpfr_strtofr</code> for a detailed description |
|
916 of the valid string formats. |
|
917 <!-- Additionally, special values --> |
|
918 <!-- @code{@@NaN@@}, @code{@@Inf@@}, @code{+@@Inf@@} and @code{-@@Inf@@}, --> |
|
919 <!-- all case insensitive, without leading whitespace and possibly followed by --> |
|
920 <!-- other characters, are accepted too (it may change). --> |
|
921 This function returns 0 if the entire string up to the final null character |
|
922 is a valid number in base <var>base</var>; otherwise it returns −1, and |
|
923 <var>rop</var> may have changed. |
|
924 </p></blockquote></div> |
|
925 |
|
926 <div class="defun"> |
|
927 — Function: int <b>mpfr_strtofr</b> (<var>mpfr_t rop, const char *nptr, char **endptr, int base, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fstrtofr-47"></a></var><br> |
|
928 <blockquote> |
|
929 <p>Read a floating-point number from a string <var>nptr</var> in base <var>base</var>, |
|
930 rounded in the direction <var>rnd</var>; <var>base</var> must be either 0 (to |
|
931 detect the base, as described below) or a number from 2 to 36 (otherwise |
|
932 the behavior is undefined). If <var>nptr</var> starts with valid data, the |
|
933 result is stored in <var>rop</var> and <code>*</code><var>endptr</var> points to the |
|
934 character just after the valid data (if <var>endptr</var> is not a null pointer); |
|
935 otherwise <var>rop</var> is set to zero and the value of <var>nptr</var> is stored |
|
936 in the location referenced by <var>endptr</var> (if <var>endptr</var> is not a null |
|
937 pointer). The usual ternary value is returned. |
|
938 |
|
939 <p>Parsing follows the standard C <code>strtod</code> function with some extensions. |
|
940 Case is ignored. After optional leading whitespace, one has a subject |
|
941 sequence consisting of an optional sign (<code>+</code> or <code>-</code>), and either |
|
942 numeric data or special data. The subject sequence is defined as the |
|
943 longest initial subsequence of the input string, starting with the first |
|
944 non-whitespace character, that is of the expected form. |
|
945 |
|
946 <p>The form of numeric data is a non-empty sequence of significand digits |
|
947 with an optional decimal point, and an optional exponent consisting of |
|
948 an exponent prefix followed by an optional sign and a non-empty sequence |
|
949 of decimal digits. A significand digit is either a decimal digit or a |
|
950 Latin letter (62 possible characters), with <code>a</code> = 10, <code>b</code> = 11, |
|
951 <small class="dots">...</small>, <code>z</code> = 36; its value must be strictly less than the base. |
|
952 The decimal point can be either the one defined by the current locale or |
|
953 the period (the first one is accepted for consistency with the C standard |
|
954 and the practice, the second one is accepted to allow the programmer to |
|
955 provide MPFR numbers from strings in a way that does not depend on the |
|
956 current locale). |
|
957 The exponent prefix can be <code>e</code> or <code>E</code> for bases up to 10, or |
|
958 <code>@</code> in any base; it indicates a multiplication by a power of the |
|
959 base. In bases 2 and 16, the exponent prefix can also be <code>p</code> or |
|
960 <code>P</code>, in which case it introduces a binary exponent: it indicates a |
|
961 multiplication by a power of 2 (there is a difference only for base 16). |
|
962 The value of an exponent is always written in base 10. |
|
963 In base 2, the significand can start with <code>0b</code> or <code>0B</code>, and |
|
964 in base 16, it can start with <code>0x</code> or <code>0X</code>. |
|
965 |
|
966 <p>If the argument <var>base</var> is 0, then the base is automatically detected |
|
967 as follows. If the significand starts with <code>0b</code> or <code>0B</code>, base 2 |
|
968 is assumed. If the significand starts with <code>0x</code> or <code>0X</code>, base 16 |
|
969 is assumed. Otherwise base 10 is assumed. |
|
970 |
|
971 <p>Note: The exponent must contain at least a digit. Otherwise the possible |
|
972 exponent prefix and sign are not part of the number (which ends with the |
|
973 significand). Similarly, if <code>0b</code>, <code>0B</code>, <code>0x</code> or <code>0X</code> |
|
974 is not followed by a binary/hexadecimal digit, then the subject sequence |
|
975 stops at the character <code>0</code>. |
|
976 |
|
977 <p>Special data (for infinities and NaN) can be <code>@inf@</code> or |
|
978 <code>@nan@(n-char-sequence)</code>, and if <var>base</var> <= 16, |
|
979 it can also be <code>infinity</code>, <code>inf</code>, <code>nan</code> or |
|
980 <code>nan(n-char-sequence)</code>, all case insensitive. |
|
981 A <code>n-char-sequence</code> is a non-empty string containing only digits, |
|
982 Latin letters and the underscore (0, 1, 2, <small class="dots">...</small>, 9, a, b, <small class="dots">...</small>, z, |
|
983 A, B, <small class="dots">...</small>, Z, _). Note: one has an optional sign for all data, even |
|
984 NaN. |
|
985 |
|
986 </blockquote></div> |
|
987 |
|
988 <div class="defun"> |
|
989 — Function: void <b>mpfr_set_inf</b> (<var>mpfr_t x, int sign</var>)<var><a name="index-mpfr_005fset_005finf-48"></a></var><br> |
|
990 — Function: void <b>mpfr_set_nan</b> (<var>mpfr_t x</var>)<var><a name="index-mpfr_005fset_005fnan-49"></a></var><br> |
|
991 <blockquote><p>Set the variable <var>x</var> to infinity or NaN (Not-a-Number) respectively. |
|
992 In <code>mpfr_set_inf</code>, <var>x</var> is set to plus infinity iff <var>sign</var> is |
|
993 nonnegative. |
|
994 </p></blockquote></div> |
|
995 |
|
996 <div class="defun"> |
|
997 — Function: void <b>mpfr_swap</b> (<var>mpfr_t x, mpfr_t y</var>)<var><a name="index-mpfr_005fswap-50"></a></var><br> |
|
998 <blockquote><p>Swap the values <var>x</var> and <var>y</var> efficiently. Warning: the |
|
999 precisions are exchanged too; in case the precisions are different, |
|
1000 <code>mpfr_swap</code> is thus not equivalent to three <code>mpfr_set</code> calls |
|
1001 using a third auxiliary variable. |
|
1002 </p></blockquote></div> |
|
1003 |
|
1004 <div class="node"> |
|
1005 <p><hr> |
|
1006 <a name="Combined-Initialization-and-Assignment-Functions"></a> |
|
1007 Next: <a rel="next" accesskey="n" href="#Conversion-Functions">Conversion Functions</a>, |
|
1008 Previous: <a rel="previous" accesskey="p" href="#Assignment-Functions">Assignment Functions</a>, |
|
1009 Up: <a rel="up" accesskey="u" href="#MPFR-Interface">MPFR Interface</a> |
|
1010 |
|
1011 </div> |
|
1012 |
|
1013 <!-- node-name, next, previous, up --> |
|
1014 <p><a name="index-Combined-initialization-and-assignment-functions-51"></a> |
|
1015 |
|
1016 <h3 class="section">5.3 Combined Initialization and Assignment Functions</h3> |
|
1017 |
|
1018 <div class="defun"> |
|
1019 — Macro: int <b>mpfr_init_set</b> (<var>mpfr_t rop, mpfr_t op, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005finit_005fset-52"></a></var><br> |
|
1020 — Macro: int <b>mpfr_init_set_ui</b> (<var>mpfr_t rop, unsigned long int op, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005finit_005fset_005fui-53"></a></var><br> |
|
1021 — Macro: int <b>mpfr_init_set_si</b> (<var>mpfr_t rop, signed long int op, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005finit_005fset_005fsi-54"></a></var><br> |
|
1022 — Macro: int <b>mpfr_init_set_d</b> (<var>mpfr_t rop, double op, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005finit_005fset_005fd-55"></a></var><br> |
|
1023 — Macro: int <b>mpfr_init_set_ld</b> (<var>mpfr_t rop, long double op, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005finit_005fset_005fld-56"></a></var><br> |
|
1024 — Macro: int <b>mpfr_init_set_z</b> (<var>mpfr_t rop, mpz_t op, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005finit_005fset_005fz-57"></a></var><br> |
|
1025 — Macro: int <b>mpfr_init_set_q</b> (<var>mpfr_t rop, mpq_t op, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005finit_005fset_005fq-58"></a></var><br> |
|
1026 — Macro: int <b>mpfr_init_set_f</b> (<var>mpfr_t rop, mpf_t op, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005finit_005fset_005ff-59"></a></var><br> |
|
1027 <blockquote><p>Initialize <var>rop</var> and set its value from <var>op</var>, rounded in the direction |
|
1028 <var>rnd</var>. |
|
1029 The precision of <var>rop</var> will be taken from the active default precision, |
|
1030 as set by <code>mpfr_set_default_prec</code>. |
|
1031 </p></blockquote></div> |
|
1032 |
|
1033 <div class="defun"> |
|
1034 — Function: int <b>mpfr_init_set_str</b> (<var>mpfr_t x, const char *s, int base, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005finit_005fset_005fstr-60"></a></var><br> |
|
1035 <blockquote><p>Initialize <var>x</var> and set its value from |
|
1036 the string <var>s</var> in base <var>base</var>, |
|
1037 rounded in the direction <var>rnd</var>. |
|
1038 See <code>mpfr_set_str</code>. |
|
1039 </p></blockquote></div> |
|
1040 |
|
1041 <div class="node"> |
|
1042 <p><hr> |
|
1043 <a name="Conversion-Functions"></a> |
|
1044 Next: <a rel="next" accesskey="n" href="#Basic-Arithmetic-Functions">Basic Arithmetic Functions</a>, |
|
1045 Previous: <a rel="previous" accesskey="p" href="#Combined-Initialization-and-Assignment-Functions">Combined Initialization and Assignment Functions</a>, |
|
1046 Up: <a rel="up" accesskey="u" href="#MPFR-Interface">MPFR Interface</a> |
|
1047 |
|
1048 </div> |
|
1049 |
|
1050 <!-- node-name, next, previous, up --> |
|
1051 <p><a name="index-Conversion-functions-61"></a> |
|
1052 |
|
1053 <h3 class="section">5.4 Conversion Functions</h3> |
|
1054 |
|
1055 <div class="defun"> |
|
1056 — Function: double <b>mpfr_get_d</b> (<var>mpfr_t op, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fget_005fd-62"></a></var><br> |
|
1057 — Function: long double <b>mpfr_get_ld</b> (<var>mpfr_t op, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fget_005fld-63"></a></var><br> |
|
1058 — Function: _Decimal64 <b>mpfr_get_decimal64</b> (<var>mpfr_t op, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fget_005fdecimal64-64"></a></var><br> |
|
1059 <blockquote><p>Convert <var>op</var> to a <code>double</code> (respectively <code>_Decimal64</code> or |
|
1060 <code>long double</code>), using the rounding mode <var>rnd</var>. |
|
1061 If <var>op</var> is NaN, some fixed NaN (either quiet or signaling) or the result |
|
1062 of 0.0/0.0 is returned. If <var>op</var> is �Inf, an infinity of the same |
|
1063 sign or the result of �1.0/0.0 is returned. If <var>op</var> is zero, these |
|
1064 functions return a zero, trying to preserve its sign, if possible. |
|
1065 The <code>mpfr_get_decimal64</code> function is built only under some conditions: |
|
1066 see the documentation of <code>mpfr_set_decimal64</code>. |
|
1067 </p></blockquote></div> |
|
1068 |
|
1069 <div class="defun"> |
|
1070 — Function: double <b>mpfr_get_d_2exp</b> (<var>long *exp, mpfr_t op, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fget_005fd_005f2exp-65"></a></var><br> |
|
1071 — Function: long double <b>mpfr_get_ld_2exp</b> (<var>long *exp, mpfr_t op, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fget_005fld_005f2exp-66"></a></var><br> |
|
1072 <blockquote><p>Return <var>d</var> and set <var>exp</var> such that 0.5<=abs(<var>d</var>)<1 |
|
1073 and <var>d</var> times 2 raised to <var>exp</var> equals |
|
1074 <var>op</var> rounded to double (resp. long double) |
|
1075 precision, using the given rounding mode. |
|
1076 <!-- See ISO C standard, frexp function. --> |
|
1077 If <var>op</var> is zero, then a zero of the same sign (or an unsigned zero, |
|
1078 if the implementation does not have signed zeros) is returned, and |
|
1079 <var>exp</var> is set to 0. |
|
1080 If <var>op</var> is NaN or an infinity, then the corresponding double precision |
|
1081 (resp. long-double precision) |
|
1082 value is returned, and <var>exp</var> is undefined. |
|
1083 </p></blockquote></div> |
|
1084 |
|
1085 <div class="defun"> |
|
1086 — Function: long <b>mpfr_get_si</b> (<var>mpfr_t op, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fget_005fsi-67"></a></var><br> |
|
1087 — Function: unsigned long <b>mpfr_get_ui</b> (<var>mpfr_t op, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fget_005fui-68"></a></var><br> |
|
1088 — Function: intmax_t <b>mpfr_get_sj</b> (<var>mpfr_t op, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fget_005fsj-69"></a></var><br> |
|
1089 — Function: uintmax_t <b>mpfr_get_uj</b> (<var>mpfr_t op, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fget_005fuj-70"></a></var><br> |
|
1090 <blockquote><p>Convert <var>op</var> to a <code>long</code>, an <code>unsigned long</code>, |
|
1091 an <code>intmax_t</code> or an <code>uintmax_t</code> (respectively) after rounding |
|
1092 it with respect to <var>rnd</var>. |
|
1093 If <var>op</var> is NaN, the result is undefined. |
|
1094 If <var>op</var> is too big for the return type, it returns the maximum |
|
1095 or the minimum of the corresponding C type, depending on the direction |
|
1096 of the overflow. The flag erange is set too. |
|
1097 See also <code>mpfr_fits_slong_p</code>, <code>mpfr_fits_ulong_p</code>, |
|
1098 <code>mpfr_fits_intmax_p</code> and <code>mpfr_fits_uintmax_p</code>. |
|
1099 </p></blockquote></div> |
|
1100 |
|
1101 <div class="defun"> |
|
1102 — Function: mp_exp_t <b>mpfr_get_z_exp</b> (<var>mpz_t rop, mpfr_t op</var>)<var><a name="index-mpfr_005fget_005fz_005fexp-71"></a></var><br> |
|
1103 <blockquote><p>Put the scaled significand of <var>op</var> (regarded as an integer, with the |
|
1104 precision of <var>op</var>) into <var>rop</var>, and return the exponent <var>exp</var> |
|
1105 (which may be outside the current exponent range) such that <var>op</var> |
|
1106 exactly equals |
|
1107 <var>rop</var> multiplied by two exponent <var>exp</var>. |
|
1108 If the exponent is not representable in the <code>mp_exp_t</code> type, the |
|
1109 behavior is undefined. |
|
1110 </p></blockquote></div> |
|
1111 |
|
1112 <div class="defun"> |
|
1113 — Function: void <b>mpfr_get_z</b> (<var>mpz_t rop, mpfr_t op, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fget_005fz-72"></a></var><br> |
|
1114 <blockquote><p>Convert <var>op</var> to a <code>mpz_t</code>, after rounding it with respect to |
|
1115 <var>rnd</var>. If <var>op</var> is NaN or Inf, the result is undefined. |
|
1116 </p></blockquote></div> |
|
1117 |
|
1118 <div class="defun"> |
|
1119 — Function: int <b>mpfr_get_f</b> (<var>mpf_t rop, mpfr_t op, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fget_005ff-73"></a></var><br> |
|
1120 <blockquote><p>Convert <var>op</var> to a <code>mpf_t</code>, after rounding it with respect to |
|
1121 <var>rnd</var>. Return zero iff no error occurred, |
|
1122 in particular a non-zero value is returned if |
|
1123 <var>op</var> is NaN or Inf, which do not exist in <code>mpf</code>. |
|
1124 </p></blockquote></div> |
|
1125 |
|
1126 <div class="defun"> |
|
1127 — Function: char * <b>mpfr_get_str</b> (<var>char *str, mp_exp_t *expptr, int b, size_t n, mpfr_t op, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fget_005fstr-74"></a></var><br> |
|
1128 <blockquote><p>Convert <var>op</var> to a string of digits in base <var>b</var>, with rounding in |
|
1129 the direction <var>rnd</var>, where <var>n</var> is either zero (see below) or the |
|
1130 number of significant digits; in the latter case, <var>n</var> must be greater |
|
1131 or equal to 2. The base may vary from 2 to 36. |
|
1132 |
|
1133 <p>The generated string is a fraction, with an implicit radix point immediately |
|
1134 to the left of the first digit. For example, the number −3.1416 would |
|
1135 be returned as "−31416" in the string and 1 written at <var>expptr</var>. |
|
1136 If <var>rnd</var> is to nearest, and <var>op</var> is exactly in the middle of two |
|
1137 possible outputs, the one with an even last digit is chosen |
|
1138 (for an odd base, this may not correspond to an even significand). |
|
1139 |
|
1140 <p>If <var>n</var> is zero, the number of digits of the significand is chosen |
|
1141 large enough so that re-reading the printed value with the same precision, |
|
1142 assuming both output and input use rounding to nearest, will recover |
|
1143 the original value of <var>op</var>. |
|
1144 More precisely, in most cases, the chosen precision of <var>str</var> is |
|
1145 the minimal precision depending on <var>n</var> and <var>b</var> only that |
|
1146 satisfies the above property, i.e., |
|
1147 m = 1 + ceil(<var>n</var>*log(2)/log(<var>b</var>)), |
|
1148 but in some very rare cases, it might be m+1. |
|
1149 |
|
1150 <p>If <var>str</var> is a null pointer, space for the significand is allocated using |
|
1151 the current allocation function, and a pointer to the string is returned. |
|
1152 To free the returned string, you must use <code>mpfr_free_str</code>. |
|
1153 |
|
1154 <p>If <var>str</var> is not a null pointer, it should point to a block of storage |
|
1155 large enough for the significand, i.e., at least <code>max(</code><var>n</var><code> + 2, 7)</code>. |
|
1156 The extra two bytes are for a possible minus sign, and for the terminating null |
|
1157 character. |
|
1158 |
|
1159 <p>If the input number is an ordinary number, the exponent is written through |
|
1160 the pointer <var>expptr</var> (the current minimal exponent for 0). |
|
1161 |
|
1162 <p>A pointer to the string is returned, unless there is an error, in which |
|
1163 case a null pointer is returned. |
|
1164 </p></blockquote></div> |
|
1165 |
|
1166 <div class="defun"> |
|
1167 — Function: void <b>mpfr_free_str</b> (<var>char *str</var>)<var><a name="index-mpfr_005ffree_005fstr-75"></a></var><br> |
|
1168 <blockquote><p>Free a string allocated by <code>mpfr_get_str</code> using the current unallocation |
|
1169 function (preliminary interface). |
|
1170 The block is assumed to be <code>strlen(</code><var>str</var><code>)+1</code> bytes. |
|
1171 For more information about how it is done: |
|
1172 see section “Custom Allocation” in <cite>GNU MP</cite>. |
|
1173 </p></blockquote></div> |
|
1174 |
|
1175 <div class="defun"> |
|
1176 — Function: int <b>mpfr_fits_ulong_p</b> (<var>mpfr_t op, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005ffits_005fulong_005fp-76"></a></var><br> |
|
1177 — Function: int <b>mpfr_fits_slong_p</b> (<var>mpfr_t op, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005ffits_005fslong_005fp-77"></a></var><br> |
|
1178 — Function: int <b>mpfr_fits_uint_p</b> (<var>mpfr_t op, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005ffits_005fuint_005fp-78"></a></var><br> |
|
1179 — Function: int <b>mpfr_fits_sint_p</b> (<var>mpfr_t op, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005ffits_005fsint_005fp-79"></a></var><br> |
|
1180 — Function: int <b>mpfr_fits_ushort_p</b> (<var>mpfr_t op, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005ffits_005fushort_005fp-80"></a></var><br> |
|
1181 — Function: int <b>mpfr_fits_sshort_p</b> (<var>mpfr_t op, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005ffits_005fsshort_005fp-81"></a></var><br> |
|
1182 — Function: int <b>mpfr_fits_intmax_p</b> (<var>mpfr_t op, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005ffits_005fintmax_005fp-82"></a></var><br> |
|
1183 — Function: int <b>mpfr_fits_uintmax_p</b> (<var>mpfr_t op, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005ffits_005fuintmax_005fp-83"></a></var><br> |
|
1184 <blockquote><p>Return non-zero if <var>op</var> would fit in the respective C data type, when |
|
1185 rounded to an integer in the direction <var>rnd</var>. |
|
1186 </p></blockquote></div> |
|
1187 |
|
1188 <div class="node"> |
|
1189 <p><hr> |
|
1190 <a name="Basic-Arithmetic-Functions"></a> |
|
1191 Next: <a rel="next" accesskey="n" href="#Comparison-Functions">Comparison Functions</a>, |
|
1192 Previous: <a rel="previous" accesskey="p" href="#Conversion-Functions">Conversion Functions</a>, |
|
1193 Up: <a rel="up" accesskey="u" href="#MPFR-Interface">MPFR Interface</a> |
|
1194 |
|
1195 </div> |
|
1196 |
|
1197 <!-- node-name, next, previous, up --> |
|
1198 <p><a name="index-Basic-arithmetic-functions-84"></a><a name="index-Float-arithmetic-functions-85"></a><a name="index-Arithmetic-functions-86"></a> |
|
1199 |
|
1200 <h3 class="section">5.5 Basic Arithmetic Functions</h3> |
|
1201 |
|
1202 <div class="defun"> |
|
1203 — Function: int <b>mpfr_add</b> (<var>mpfr_t rop, mpfr_t op1, mpfr_t op2, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fadd-87"></a></var><br> |
|
1204 — Function: int <b>mpfr_add_ui</b> (<var>mpfr_t rop, mpfr_t op1, unsigned long int op2, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fadd_005fui-88"></a></var><br> |
|
1205 — Function: int <b>mpfr_add_si</b> (<var>mpfr_t rop, mpfr_t op1, long int op2, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fadd_005fsi-89"></a></var><br> |
|
1206 — Function: int <b>mpfr_add_z</b> (<var>mpfr_t rop, mpfr_t op1, mpz_t op2, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fadd_005fz-90"></a></var><br> |
|
1207 — Function: int <b>mpfr_add_q</b> (<var>mpfr_t rop, mpfr_t op1, mpq_t op2, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fadd_005fq-91"></a></var><br> |
|
1208 <blockquote><p>Set <var>rop</var> to <var>op1</var> + <var>op2</var> rounded in the direction |
|
1209 <var>rnd</var>. For types having no signed zero, it is considered unsigned |
|
1210 (i.e. (+0) + 0 = (+0) and (−0) + 0 = (−0)). |
|
1211 </p></blockquote></div> |
|
1212 |
|
1213 <div class="defun"> |
|
1214 — Function: int <b>mpfr_sub</b> (<var>mpfr_t rop, mpfr_t op1, mpfr_t op2, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fsub-92"></a></var><br> |
|
1215 — Function: int <b>mpfr_ui_sub</b> (<var>mpfr_t rop, unsigned long int op1, mpfr_t op2, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fui_005fsub-93"></a></var><br> |
|
1216 — Function: int <b>mpfr_sub_ui</b> (<var>mpfr_t rop, mpfr_t op1, unsigned long int op2, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fsub_005fui-94"></a></var><br> |
|
1217 — Function: int <b>mpfr_si_sub</b> (<var>mpfr_t rop, long int op1, mpfr_t op2, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fsi_005fsub-95"></a></var><br> |
|
1218 — Function: int <b>mpfr_sub_si</b> (<var>mpfr_t rop, mpfr_t op1, long int op2, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fsub_005fsi-96"></a></var><br> |
|
1219 — Function: int <b>mpfr_sub_z</b> (<var>mpfr_t rop, mpfr_t op1, mpz_t op2, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fsub_005fz-97"></a></var><br> |
|
1220 — Function: int <b>mpfr_sub_q</b> (<var>mpfr_t rop, mpfr_t op1, mpq_t op2, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fsub_005fq-98"></a></var><br> |
|
1221 <blockquote><p>Set <var>rop</var> to <var>op1</var> - <var>op2</var> rounded in the direction |
|
1222 <var>rnd</var>. For types having no signed zero, it is considered unsigned |
|
1223 (i.e. (+0) − 0 = (+0), (−0) − 0 = (−0), |
|
1224 0 − (+0) = (−0) and 0 − (−0) = (+0)). |
|
1225 </p></blockquote></div> |
|
1226 |
|
1227 <div class="defun"> |
|
1228 — Function: int <b>mpfr_mul</b> (<var>mpfr_t rop, mpfr_t op1, mpfr_t op2, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fmul-99"></a></var><br> |
|
1229 — Function: int <b>mpfr_mul_ui</b> (<var>mpfr_t rop, mpfr_t op1, unsigned long int op2, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fmul_005fui-100"></a></var><br> |
|
1230 — Function: int <b>mpfr_mul_si</b> (<var>mpfr_t rop, mpfr_t op1, long int op2, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fmul_005fsi-101"></a></var><br> |
|
1231 — Function: int <b>mpfr_mul_z</b> (<var>mpfr_t rop, mpfr_t op1, mpz_t op2, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fmul_005fz-102"></a></var><br> |
|
1232 — Function: int <b>mpfr_mul_q</b> (<var>mpfr_t rop, mpfr_t op1, mpq_t op2, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fmul_005fq-103"></a></var><br> |
|
1233 <blockquote><p>Set <var>rop</var> to <var>op1</var> times <var>op2</var> rounded in the |
|
1234 direction <var>rnd</var>. |
|
1235 When a result is zero, its sign is the product of the signs of the operands |
|
1236 (for types having no signed zero, it is considered positive). |
|
1237 </p></blockquote></div> |
|
1238 |
|
1239 <div class="defun"> |
|
1240 — Function: int <b>mpfr_sqr</b> (<var>mpfr_t rop, mpfr_t op, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fsqr-104"></a></var><br> |
|
1241 <blockquote><p>Set <var>rop</var> to the square of <var>op</var> |
|
1242 rounded in the direction <var>rnd</var>. |
|
1243 </p></blockquote></div> |
|
1244 |
|
1245 <div class="defun"> |
|
1246 — Function: int <b>mpfr_div</b> (<var>mpfr_t rop, mpfr_t op1, mpfr_t op2, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fdiv-105"></a></var><br> |
|
1247 — Function: int <b>mpfr_ui_div</b> (<var>mpfr_t rop, unsigned long int op1, mpfr_t op2, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fui_005fdiv-106"></a></var><br> |
|
1248 — Function: int <b>mpfr_div_ui</b> (<var>mpfr_t rop, mpfr_t op1, unsigned long int op2, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fdiv_005fui-107"></a></var><br> |
|
1249 — Function: int <b>mpfr_si_div</b> (<var>mpfr_t rop, long int op1, mpfr_t op2, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fsi_005fdiv-108"></a></var><br> |
|
1250 — Function: int <b>mpfr_div_si</b> (<var>mpfr_t rop, mpfr_t op1, long int op2, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fdiv_005fsi-109"></a></var><br> |
|
1251 — Function: int <b>mpfr_div_z</b> (<var>mpfr_t rop, mpfr_t op1, mpz_t op2, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fdiv_005fz-110"></a></var><br> |
|
1252 — Function: int <b>mpfr_div_q</b> (<var>mpfr_t rop, mpfr_t op1, mpq_t op2, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fdiv_005fq-111"></a></var><br> |
|
1253 <blockquote><p>Set <var>rop</var> to <var>op1</var>/<var>op2</var> rounded in the direction <var>rnd</var>. |
|
1254 When a result is zero, its sign is the product of the signs of the operands |
|
1255 (for types having no signed zero, it is considered positive). |
|
1256 </p></blockquote></div> |
|
1257 |
|
1258 <div class="defun"> |
|
1259 — Function: int <b>mpfr_sqrt</b> (<var>mpfr_t rop, mpfr_t op, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fsqrt-112"></a></var><br> |
|
1260 — Function: int <b>mpfr_sqrt_ui</b> (<var>mpfr_t rop, unsigned long int op, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fsqrt_005fui-113"></a></var><br> |
|
1261 <blockquote><p>Set <var>rop</var> to the square root of <var>op</var> |
|
1262 rounded in the direction <var>rnd</var>. Return −0 if <var>op</var> is |
|
1263 −0 (to be consistent with the IEEE 754-1985 standard). |
|
1264 Set <var>rop</var> to NaN if <var>op</var> is negative. |
|
1265 </p></blockquote></div> |
|
1266 |
|
1267 <div class="defun"> |
|
1268 — Function: int <b>mpfr_cbrt</b> (<var>mpfr_t rop, mpfr_t op, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fcbrt-114"></a></var><br> |
|
1269 — Function: int <b>mpfr_root</b> (<var>mpfr_t rop, mpfr_t op, unsigned long int k, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005froot-115"></a></var><br> |
|
1270 <blockquote><p>Set <var>rop</var> to the cubic root (resp. the <var>k</var>th root) |
|
1271 of <var>op</var> rounded in the direction <var>rnd</var>. |
|
1272 An odd (resp. even) root of a negative number (including −Inf) |
|
1273 returns a negative number (resp. NaN). |
|
1274 The <var>k</var>th root of −0 is defined to be −0, |
|
1275 whatever the parity of <var>k</var>. |
|
1276 </p></blockquote></div> |
|
1277 |
|
1278 <div class="defun"> |
|
1279 — Function: int <b>mpfr_pow</b> (<var>mpfr_t rop, mpfr_t op1, mpfr_t op2, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fpow-116"></a></var><br> |
|
1280 — Function: int <b>mpfr_pow_ui</b> (<var>mpfr_t rop, mpfr_t op1, unsigned long int op2, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fpow_005fui-117"></a></var><br> |
|
1281 — Function: int <b>mpfr_pow_si</b> (<var>mpfr_t rop, mpfr_t op1, long int op2, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fpow_005fsi-118"></a></var><br> |
|
1282 — Function: int <b>mpfr_pow_z</b> (<var>mpfr_t rop, mpfr_t op1, mpz_t op2, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fpow_005fz-119"></a></var><br> |
|
1283 — Function: int <b>mpfr_ui_pow_ui</b> (<var>mpfr_t rop, unsigned long int op1, unsigned long int op2, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fui_005fpow_005fui-120"></a></var><br> |
|
1284 — Function: int <b>mpfr_ui_pow</b> (<var>mpfr_t rop, unsigned long int op1, mpfr_t op2, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fui_005fpow-121"></a></var><br> |
|
1285 <blockquote><p>Set <var>rop</var> to <var>op1</var> raised to <var>op2</var>, |
|
1286 rounded in the direction <var>rnd</var>. |
|
1287 Special values are currently handled as described in the ISO C99 standard |
|
1288 for the <code>pow</code> function (note this may change in future versions): |
|
1289 <ul> |
|
1290 <li><code>pow(�0, </code><var>y</var><code>)</code> returns plus or minus infinity for <var>y</var> a negative odd integer. |
|
1291 <li><code>pow(�0, </code><var>y</var><code>)</code> returns plus infinity for <var>y</var> negative and not an odd integer. |
|
1292 <li><code>pow(�0, </code><var>y</var><code>)</code> returns plus or minus zero for <var>y</var> a positive odd integer. |
|
1293 <li><code>pow(�0, </code><var>y</var><code>)</code> returns plus zero for <var>y</var> positive and not an odd integer. |
|
1294 <li><code>pow(-1, �Inf)</code> returns 1. |
|
1295 <li><code>pow(+1, </code><var>y</var><code>)</code> returns 1 for any <var>y</var>, even a NaN. |
|
1296 <li><code>pow(</code><var>x</var><code>, �0)</code> returns 1 for any <var>x</var>, even a NaN. |
|
1297 <li><code>pow(</code><var>x</var><code>, </code><var>y</var><code>)</code> returns NaN for finite negative <var>x</var> and finite non-integer <var>y</var>. |
|
1298 <li><code>pow(</code><var>x</var><code>, -Inf)</code> returns plus infinity for 0 < abs(x) < 1, and plus zero for abs(x) > 1. |
|
1299 <li><code>pow(</code><var>x</var><code>, +Inf)</code> returns plus zero for 0 < abs(x) < 1, and plus infinity for abs(x) > 1. |
|
1300 <li><code>pow(-Inf, </code><var>y</var><code>)</code> returns minus zero for <var>y</var> a negative odd integer. |
|
1301 <li><code>pow(-Inf, </code><var>y</var><code>)</code> returns plus zero for <var>y</var> negative and not an odd integer. |
|
1302 <li><code>pow(-Inf, </code><var>y</var><code>)</code> returns minus infinity for <var>y</var> a positive odd integer. |
|
1303 <li><code>pow(-Inf, </code><var>y</var><code>)</code> returns plus infinity for <var>y</var> positive and not an odd integer. |
|
1304 <li><code>pow(+Inf, </code><var>y</var><code>)</code> returns plus zero for <var>y</var> negative, and plus infinity for <var>y</var> positive. |
|
1305 </ul> |
|
1306 </p></blockquote></div> |
|
1307 |
|
1308 <div class="defun"> |
|
1309 — Function: int <b>mpfr_neg</b> (<var>mpfr_t rop, mpfr_t op, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fneg-122"></a></var><br> |
|
1310 <blockquote><p>Set <var>rop</var> to -<var>op</var> rounded in the direction <var>rnd</var>. |
|
1311 Just changes the sign if <var>rop</var> and <var>op</var> are the same variable. |
|
1312 </p></blockquote></div> |
|
1313 |
|
1314 <div class="defun"> |
|
1315 — Function: int <b>mpfr_abs</b> (<var>mpfr_t rop, mpfr_t op, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fabs-123"></a></var><br> |
|
1316 <blockquote><p>Set <var>rop</var> to the absolute value of <var>op</var>, |
|
1317 rounded in the direction <var>rnd</var>. |
|
1318 Just changes the sign if <var>rop</var> and <var>op</var> are the same variable. |
|
1319 </p></blockquote></div> |
|
1320 |
|
1321 <div class="defun"> |
|
1322 — Function: int <b>mpfr_dim</b> (<var>mpfr_t rop, mpfr_t op1, mpfr_t op2, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fdim-124"></a></var><br> |
|
1323 <blockquote><p>Set <var>rop</var> to the positive difference of <var>op1</var> and <var>op2</var>, i.e., |
|
1324 <var>op1</var> - <var>op2</var> rounded in the direction <var>rnd</var> |
|
1325 if <var>op1</var> > <var>op2</var>, and +0 otherwise. |
|
1326 Returns NaN when <var>op1</var> or <var>op2</var> is NaN. |
|
1327 </p></blockquote></div> |
|
1328 |
|
1329 <div class="defun"> |
|
1330 — Function: int <b>mpfr_mul_2ui</b> (<var>mpfr_t rop, mpfr_t op1, unsigned long int op2, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fmul_005f2ui-125"></a></var><br> |
|
1331 — Function: int <b>mpfr_mul_2si</b> (<var>mpfr_t rop, mpfr_t op1, long int op2, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fmul_005f2si-126"></a></var><br> |
|
1332 <blockquote><p>Set <var>rop</var> to <var>op1</var> times 2 raised |
|
1333 to <var>op2</var> |
|
1334 rounded in the direction <var>rnd</var>. Just increases the exponent by <var>op2</var> |
|
1335 when <var>rop</var> and <var>op1</var> are identical. |
|
1336 </p></blockquote></div> |
|
1337 |
|
1338 <div class="defun"> |
|
1339 — Function: int <b>mpfr_div_2ui</b> (<var>mpfr_t rop, mpfr_t op1, unsigned long int op2, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fdiv_005f2ui-127"></a></var><br> |
|
1340 — Function: int <b>mpfr_div_2si</b> (<var>mpfr_t rop, mpfr_t op1, long int op2, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fdiv_005f2si-128"></a></var><br> |
|
1341 <blockquote><p>Set <var>rop</var> to <var>op1</var> divided by 2 raised |
|
1342 to <var>op2</var> |
|
1343 rounded in the direction <var>rnd</var>. Just decreases the exponent by <var>op2</var> |
|
1344 when <var>rop</var> and <var>op1</var> are identical. |
|
1345 </p></blockquote></div> |
|
1346 |
|
1347 <div class="node"> |
|
1348 <p><hr> |
|
1349 <a name="Comparison-Functions"></a> |
|
1350 Next: <a rel="next" accesskey="n" href="#Special-Functions">Special Functions</a>, |
|
1351 Previous: <a rel="previous" accesskey="p" href="#Basic-Arithmetic-Functions">Basic Arithmetic Functions</a>, |
|
1352 Up: <a rel="up" accesskey="u" href="#MPFR-Interface">MPFR Interface</a> |
|
1353 |
|
1354 </div> |
|
1355 |
|
1356 <!-- node-name, next, previous, up --> |
|
1357 <p><a name="index-Float-comparisons-functions-129"></a><a name="index-Comparison-functions-130"></a> |
|
1358 |
|
1359 <h3 class="section">5.6 Comparison Functions</h3> |
|
1360 |
|
1361 <div class="defun"> |
|
1362 — Function: int <b>mpfr_cmp</b> (<var>mpfr_t op1, mpfr_t op2</var>)<var><a name="index-mpfr_005fcmp-131"></a></var><br> |
|
1363 — Function: int <b>mpfr_cmp_ui</b> (<var>mpfr_t op1, unsigned long int op2</var>)<var><a name="index-mpfr_005fcmp_005fui-132"></a></var><br> |
|
1364 — Function: int <b>mpfr_cmp_si</b> (<var>mpfr_t op1, signed long int op2</var>)<var><a name="index-mpfr_005fcmp_005fsi-133"></a></var><br> |
|
1365 — Function: int <b>mpfr_cmp_d</b> (<var>mpfr_t op1, double op2</var>)<var><a name="index-mpfr_005fcmp_005fd-134"></a></var><br> |
|
1366 — Function: int <b>mpfr_cmp_ld</b> (<var>mpfr_t op1, long double op2</var>)<var><a name="index-mpfr_005fcmp_005fld-135"></a></var><br> |
|
1367 — Function: int <b>mpfr_cmp_z</b> (<var>mpfr_t op1, mpz_t op2</var>)<var><a name="index-mpfr_005fcmp_005fz-136"></a></var><br> |
|
1368 — Function: int <b>mpfr_cmp_q</b> (<var>mpfr_t op1, mpq_t op2</var>)<var><a name="index-mpfr_005fcmp_005fq-137"></a></var><br> |
|
1369 — Function: int <b>mpfr_cmp_f</b> (<var>mpfr_t op1, mpf_t op2</var>)<var><a name="index-mpfr_005fcmp_005ff-138"></a></var><br> |
|
1370 <blockquote><p>Compare <var>op1</var> and <var>op2</var>. Return a positive value if <var>op1</var> > |
|
1371 <var>op2</var>, zero if <var>op1</var> = <var>op2</var>, and a negative value if |
|
1372 <var>op1</var> < <var>op2</var>. |
|
1373 Both <var>op1</var> and <var>op2</var> are considered to their full own precision, |
|
1374 which may differ. |
|
1375 If one of the operands is NaN, set the erange flag and return zero. |
|
1376 |
|
1377 <p>Note: These functions may be useful to distinguish the three possible cases. |
|
1378 If you need to distinguish two cases only, it is recommended to use the |
|
1379 predicate functions (e.g., <code>mpfr_equal_p</code> for the equality) described |
|
1380 below; they behave like the IEEE-754 comparisons, in particular when one |
|
1381 or both arguments are NaN. But only floating-point numbers can be compared |
|
1382 (you may need to do a conversion first). |
|
1383 </p></blockquote></div> |
|
1384 |
|
1385 <div class="defun"> |
|
1386 — Function: int <b>mpfr_cmp_ui_2exp</b> (<var>mpfr_t op1, unsigned long int op2, mp_exp_t e</var>)<var><a name="index-mpfr_005fcmp_005fui_005f2exp-139"></a></var><br> |
|
1387 — Function: int <b>mpfr_cmp_si_2exp</b> (<var>mpfr_t op1, long int op2, mp_exp_t e</var>)<var><a name="index-mpfr_005fcmp_005fsi_005f2exp-140"></a></var><br> |
|
1388 <blockquote><p>Compare <var>op1</var> and <var>op2</var> multiplied by two to |
|
1389 the power <var>e</var>. Similar as above. |
|
1390 </p></blockquote></div> |
|
1391 |
|
1392 <div class="defun"> |
|
1393 — Function: int <b>mpfr_cmpabs</b> (<var>mpfr_t op1, mpfr_t op2</var>)<var><a name="index-mpfr_005fcmpabs-141"></a></var><br> |
|
1394 <blockquote><p>Compare |<var>op1</var>| and |<var>op2</var>|. Return a positive value if |
|
1395 |<var>op1</var>| > |<var>op2</var>|, zero if |<var>op1</var>| = |<var>op2</var>|, and |
|
1396 a negative value if |<var>op1</var>| < |<var>op2</var>|. |
|
1397 If one of the operands is NaN, set the erange flag and return zero. |
|
1398 </p></blockquote></div> |
|
1399 |
|
1400 <div class="defun"> |
|
1401 — Function: int <b>mpfr_nan_p</b> (<var>mpfr_t op</var>)<var><a name="index-mpfr_005fnan_005fp-142"></a></var><br> |
|
1402 — Function: int <b>mpfr_inf_p</b> (<var>mpfr_t op</var>)<var><a name="index-mpfr_005finf_005fp-143"></a></var><br> |
|
1403 — Function: int <b>mpfr_number_p</b> (<var>mpfr_t op</var>)<var><a name="index-mpfr_005fnumber_005fp-144"></a></var><br> |
|
1404 — Function: int <b>mpfr_zero_p</b> (<var>mpfr_t op</var>)<var><a name="index-mpfr_005fzero_005fp-145"></a></var><br> |
|
1405 <blockquote><p>Return non-zero if <var>op</var> is respectively NaN, an infinity, an ordinary |
|
1406 number (i.e. neither NaN nor an infinity) or zero. Return zero otherwise. |
|
1407 </p></blockquote></div> |
|
1408 |
|
1409 <div class="defun"> |
|
1410 — Macro: int <b>mpfr_sgn</b> (<var>mpfr_t op</var>)<var><a name="index-mpfr_005fsgn-146"></a></var><br> |
|
1411 <blockquote><p>Return a positive value if <var>op</var> > 0, zero if <var>op</var> = 0, |
|
1412 and a negative value if <var>op</var> < 0. |
|
1413 If the operand is NaN, set the erange flag and return zero. |
|
1414 </p></blockquote></div> |
|
1415 |
|
1416 <div class="defun"> |
|
1417 — Function: int <b>mpfr_greater_p</b> (<var>mpfr_t op1, mpfr_t op2</var>)<var><a name="index-mpfr_005fgreater_005fp-147"></a></var><br> |
|
1418 <blockquote><p>Return non-zero if <var>op1</var> > <var>op2</var>, zero otherwise. |
|
1419 </p></blockquote></div> |
|
1420 |
|
1421 <div class="defun"> |
|
1422 — Function: int <b>mpfr_greaterequal_p</b> (<var>mpfr_t op1, mpfr_t op2</var>)<var><a name="index-mpfr_005fgreaterequal_005fp-148"></a></var><br> |
|
1423 <blockquote><p>Return non-zero if <var>op1</var> >= <var>op2</var>, zero otherwise. |
|
1424 </p></blockquote></div> |
|
1425 |
|
1426 <div class="defun"> |
|
1427 — Function: int <b>mpfr_less_p</b> (<var>mpfr_t op1, mpfr_t op2</var>)<var><a name="index-mpfr_005fless_005fp-149"></a></var><br> |
|
1428 <blockquote><p>Return non-zero if <var>op1</var> < <var>op2</var>, zero otherwise. |
|
1429 </p></blockquote></div> |
|
1430 |
|
1431 <div class="defun"> |
|
1432 — Function: int <b>mpfr_lessequal_p</b> (<var>mpfr_t op1, mpfr_t op2</var>)<var><a name="index-mpfr_005flessequal_005fp-150"></a></var><br> |
|
1433 <blockquote><p>Return non-zero if <var>op1</var> <= <var>op2</var>, zero otherwise. |
|
1434 </p></blockquote></div> |
|
1435 |
|
1436 <div class="defun"> |
|
1437 — Function: int <b>mpfr_lessgreater_p</b> (<var>mpfr_t op1, mpfr_t op2</var>)<var><a name="index-mpfr_005flessgreater_005fp-151"></a></var><br> |
|
1438 <blockquote><p>Return non-zero if <var>op1</var> < <var>op2</var> or |
|
1439 <var>op1</var> > <var>op2</var> (i.e. neither <var>op1</var>, nor <var>op2</var> is |
|
1440 NaN, and <var>op1</var> <> <var>op2</var>), zero otherwise (i.e. <var>op1</var> |
|
1441 and/or <var>op2</var> are NaN, or <var>op1</var> = <var>op2</var>). |
|
1442 </p></blockquote></div> |
|
1443 |
|
1444 <div class="defun"> |
|
1445 — Function: int <b>mpfr_equal_p</b> (<var>mpfr_t op1, mpfr_t op2</var>)<var><a name="index-mpfr_005fequal_005fp-152"></a></var><br> |
|
1446 <blockquote><p>Return non-zero if <var>op1</var> = <var>op2</var>, zero otherwise |
|
1447 (i.e. <var>op1</var> and/or <var>op2</var> are NaN, or |
|
1448 <var>op1</var> <> <var>op2</var>). |
|
1449 </p></blockquote></div> |
|
1450 |
|
1451 <div class="defun"> |
|
1452 — Function: int <b>mpfr_unordered_p</b> (<var>mpfr_t op1, mpfr_t op2</var>)<var><a name="index-mpfr_005funordered_005fp-153"></a></var><br> |
|
1453 <blockquote><p>Return non-zero if <var>op1</var> or <var>op2</var> is a NaN (i.e. they cannot be |
|
1454 compared), zero otherwise. |
|
1455 </p></blockquote></div> |
|
1456 |
|
1457 <div class="node"> |
|
1458 <p><hr> |
|
1459 <a name="Special-Functions"></a> |
|
1460 Next: <a rel="next" accesskey="n" href="#Input-and-Output-Functions">Input and Output Functions</a>, |
|
1461 Previous: <a rel="previous" accesskey="p" href="#Comparison-Functions">Comparison Functions</a>, |
|
1462 Up: <a rel="up" accesskey="u" href="#MPFR-Interface">MPFR Interface</a> |
|
1463 |
|
1464 </div> |
|
1465 |
|
1466 <p><a name="index-Special-functions-154"></a> |
|
1467 |
|
1468 <h3 class="section">5.7 Special Functions</h3> |
|
1469 |
|
1470 <p>All those functions, except explicitly stated, return zero for an |
|
1471 exact return value, a positive value for a return value larger than the |
|
1472 exact result, and a negative value otherwise. |
|
1473 |
|
1474 <p>Important note: in some domains, computing special functions (either with |
|
1475 correct or incorrect rounding) is expensive, even for small precision, |
|
1476 for example the trigonometric and Bessel functions for large argument. |
|
1477 |
|
1478 <div class="defun"> |
|
1479 — Function: int <b>mpfr_log</b> (<var>mpfr_t rop, mpfr_t op, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005flog-155"></a></var><br> |
|
1480 — Function: int <b>mpfr_log2</b> (<var>mpfr_t rop, mpfr_t op, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005flog2-156"></a></var><br> |
|
1481 — Function: int <b>mpfr_log10</b> (<var>mpfr_t rop, mpfr_t op, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005flog10-157"></a></var><br> |
|
1482 <blockquote><p>Set <var>rop</var> to the natural logarithm of <var>op</var>, |
|
1483 log2(<var>op</var>) or |
|
1484 log10(<var>op</var>), respectively, |
|
1485 rounded in the direction <var>rnd</var>. |
|
1486 Return −Inf if <var>op</var> is −0 (i.e. the sign of the zero |
|
1487 has no influence on the result). |
|
1488 </p></blockquote></div> |
|
1489 |
|
1490 <div class="defun"> |
|
1491 — Function: int <b>mpfr_exp</b> (<var>mpfr_t rop, mpfr_t op, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fexp-158"></a></var><br> |
|
1492 — Function: int <b>mpfr_exp2</b> (<var>mpfr_t rop, mpfr_t op, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fexp2-159"></a></var><br> |
|
1493 — Function: int <b>mpfr_exp10</b> (<var>mpfr_t rop, mpfr_t op, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fexp10-160"></a></var><br> |
|
1494 <blockquote><p>Set <var>rop</var> to the exponential of <var>op</var>, |
|
1495 to 2 power of <var>op</var> |
|
1496 or to 10 power of <var>op</var>, respectively, |
|
1497 rounded in the direction <var>rnd</var>. |
|
1498 </p></blockquote></div> |
|
1499 |
|
1500 <div class="defun"> |
|
1501 — Function: int <b>mpfr_cos</b> (<var>mpfr_t rop, mpfr_t op, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fcos-161"></a></var><br> |
|
1502 — Function: int <b>mpfr_sin</b> (<var>mpfr_t rop, mpfr_t op, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fsin-162"></a></var><br> |
|
1503 — Function: int <b>mpfr_tan</b> (<var>mpfr_t rop, mpfr_t op, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005ftan-163"></a></var><br> |
|
1504 <blockquote><p>Set <var>rop</var> to the cosine of <var>op</var>, sine of <var>op</var>, |
|
1505 tangent of <var>op</var>, rounded in the direction <var>rnd</var>. |
|
1506 </p></blockquote></div> |
|
1507 |
|
1508 <div class="defun"> |
|
1509 — Function: int <b>mpfr_sec</b> (<var>mpfr_t rop, mpfr_t op, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fsec-164"></a></var><br> |
|
1510 — Function: int <b>mpfr_csc</b> (<var>mpfr_t rop, mpfr_t op, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fcsc-165"></a></var><br> |
|
1511 — Function: int <b>mpfr_cot</b> (<var>mpfr_t rop, mpfr_t op, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fcot-166"></a></var><br> |
|
1512 <blockquote><p>Set <var>rop</var> to the secant of <var>op</var>, cosecant of <var>op</var>, |
|
1513 cotangent of <var>op</var>, rounded in the direction <var>rnd</var>. |
|
1514 </p></blockquote></div> |
|
1515 |
|
1516 <div class="defun"> |
|
1517 — Function: int <b>mpfr_sin_cos</b> (<var>mpfr_t sop, mpfr_t cop, mpfr_t op, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fsin_005fcos-167"></a></var><br> |
|
1518 <blockquote><p>Set simultaneously <var>sop</var> to the sine of <var>op</var> and |
|
1519 <var>cop</var> to the cosine of <var>op</var>, |
|
1520 rounded in the direction <var>rnd</var> with the corresponding precisions of |
|
1521 <var>sop</var> and <var>cop</var>, which must be different variables. |
|
1522 Return 0 iff both results are exact. |
|
1523 </p></blockquote></div> |
|
1524 |
|
1525 <div class="defun"> |
|
1526 — Function: int <b>mpfr_acos</b> (<var>mpfr_t rop, mpfr_t op, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005facos-168"></a></var><br> |
|
1527 — Function: int <b>mpfr_asin</b> (<var>mpfr_t rop, mpfr_t op, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fasin-169"></a></var><br> |
|
1528 — Function: int <b>mpfr_atan</b> (<var>mpfr_t rop, mpfr_t op, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fatan-170"></a></var><br> |
|
1529 <blockquote><p>Set <var>rop</var> to the arc-cosine, arc-sine or arc-tangent of <var>op</var>, |
|
1530 rounded in the direction <var>rnd</var>. |
|
1531 Note that since <code>acos(-1)</code> returns the floating-point number closest to |
|
1532 Pi according to the given rounding mode, this number might not be |
|
1533 in the output range 0 <= <var>rop</var> < \pi |
|
1534 of the arc-cosine function; |
|
1535 still, the result lies in the image of the output range |
|
1536 by the rounding function. |
|
1537 The same holds for <code>asin(-1)</code>, <code>asin(1)</code>, <code>atan(-Inf)</code>, |
|
1538 <code>atan(+Inf)</code>. |
|
1539 </p></blockquote></div> |
|
1540 |
|
1541 <div class="defun"> |
|
1542 — Function: int <b>mpfr_atan2</b> (<var>mpfr_t rop, mpfr_t y, mpfr_t x, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fatan2-171"></a></var><br> |
|
1543 <blockquote><p>Set <var>rop</var> to the arc-tangent2 of <var>y</var> and <var>x</var>, |
|
1544 rounded in the direction <var>rnd</var>: |
|
1545 if <code>x > 0</code>, <code>atan2(y, x) = atan (y/x)</code>; |
|
1546 if <code>x < 0</code>, <code>atan2(y, x) = sign(y)*(Pi - atan (abs(y/x)))</code>. |
|
1547 As for <code>atan</code>, in case the exact mathematical result is +Pi or |
|
1548 -Pi, its rounded result might be outside the function output range. |
|
1549 |
|
1550 <p><code>atan2(y, 0)</code> does not raise any floating-point exception. |
|
1551 Special values are currently handled as described in the ISO C99 standard |
|
1552 for the <code>atan2</code> function (note this may change in future versions): |
|
1553 <ul> |
|
1554 <li><code>atan2(+0, -0)</code> returns +Pi. |
|
1555 <li><code>atan2(-0, -0)</code> returns -Pi. |
|
1556 <li><code>atan2(+0, +0)</code> returns +0. |
|
1557 <li><code>atan2(-0, +0)</code> returns −0. |
|
1558 <li><code>atan2(+0, x)</code> returns +Pi for x < 0. |
|
1559 <li><code>atan2(-0, x)</code> returns -Pi for x < 0. |
|
1560 <li><code>atan2(+0, x)</code> returns +0 for x > 0. |
|
1561 <li><code>atan2(-0, x)</code> returns −0 for x > 0. |
|
1562 <li><code>atan2(y, 0)</code> returns -Pi/2 for y < 0. |
|
1563 <li><code>atan2(y, 0)</code> returns +Pi/2 for y > 0. |
|
1564 <li><code>atan2(+Inf, -Inf)</code> returns +3*Pi/4. |
|
1565 <li><code>atan2(-Inf, -Inf)</code> returns -3*Pi/4. |
|
1566 <li><code>atan2(+Inf, +Inf)</code> returns +Pi/4. |
|
1567 <li><code>atan2(-Inf, +Inf)</code> returns -Pi/4. |
|
1568 <li><code>atan2(+Inf, x)</code> returns +Pi/2 for finite x. |
|
1569 <li><code>atan2(-Inf, x)</code> returns -Pi/2 for finite x. |
|
1570 <li><code>atan2(y, -Inf)</code> returns +Pi for finite y > 0. |
|
1571 <li><code>atan2(y, -Inf)</code> returns -Pi for finite y < 0. |
|
1572 <li><code>atan2(y, +Inf)</code> returns +0 for finite y > 0. |
|
1573 <li><code>atan2(y, +Inf)</code> returns −0 for finite y < 0. |
|
1574 </ul> |
|
1575 </p></blockquote></div> |
|
1576 |
|
1577 <div class="defun"> |
|
1578 — Function: int <b>mpfr_cosh</b> (<var>mpfr_t rop, mpfr_t op, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fcosh-172"></a></var><br> |
|
1579 — Function: int <b>mpfr_sinh</b> (<var>mpfr_t rop, mpfr_t op, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fsinh-173"></a></var><br> |
|
1580 — Function: int <b>mpfr_tanh</b> (<var>mpfr_t rop, mpfr_t op, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005ftanh-174"></a></var><br> |
|
1581 <blockquote><p>Set <var>rop</var> to the hyperbolic cosine, sine or tangent of <var>op</var>, |
|
1582 rounded in the direction <var>rnd</var>. |
|
1583 </p></blockquote></div> |
|
1584 |
|
1585 <div class="defun"> |
|
1586 — Function: int <b>mpfr_sech</b> (<var>mpfr_t rop, mpfr_t op, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fsech-175"></a></var><br> |
|
1587 — Function: int <b>mpfr_csch</b> (<var>mpfr_t rop, mpfr_t op, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fcsch-176"></a></var><br> |
|
1588 — Function: int <b>mpfr_coth</b> (<var>mpfr_t rop, mpfr_t op, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fcoth-177"></a></var><br> |
|
1589 <blockquote><p>Set <var>rop</var> to the hyperbolic secant of <var>op</var>, cosecant of <var>op</var>, |
|
1590 cotangent of <var>op</var>, rounded in the direction <var>rnd</var>. |
|
1591 </p></blockquote></div> |
|
1592 |
|
1593 <div class="defun"> |
|
1594 — Function: int <b>mpfr_acosh</b> (<var>mpfr_t rop, mpfr_t op, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005facosh-178"></a></var><br> |
|
1595 — Function: int <b>mpfr_asinh</b> (<var>mpfr_t rop, mpfr_t op, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fasinh-179"></a></var><br> |
|
1596 — Function: int <b>mpfr_atanh</b> (<var>mpfr_t rop, mpfr_t op, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fatanh-180"></a></var><br> |
|
1597 <blockquote><p>Set <var>rop</var> to the inverse hyperbolic cosine, sine or tangent of <var>op</var>, |
|
1598 rounded in the direction <var>rnd</var>. |
|
1599 </p></blockquote></div> |
|
1600 |
|
1601 <div class="defun"> |
|
1602 — Function: int <b>mpfr_fac_ui</b> (<var>mpfr_t rop, unsigned long int op, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005ffac_005fui-181"></a></var><br> |
|
1603 <blockquote><p>Set <var>rop</var> to the factorial of the <code>unsigned long int</code> <var>op</var>, |
|
1604 rounded in the direction <var>rnd</var>. |
|
1605 </p></blockquote></div> |
|
1606 |
|
1607 <div class="defun"> |
|
1608 — Function: int <b>mpfr_log1p</b> (<var>mpfr_t rop, mpfr_t op, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005flog1p-182"></a></var><br> |
|
1609 <blockquote><p>Set <var>rop</var> to the logarithm of one plus <var>op</var>, |
|
1610 rounded in the direction <var>rnd</var>. |
|
1611 </p></blockquote></div> |
|
1612 |
|
1613 <div class="defun"> |
|
1614 — Function: int <b>mpfr_expm1</b> (<var>mpfr_t rop, mpfr_t op, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fexpm1-183"></a></var><br> |
|
1615 <blockquote><p>Set <var>rop</var> to the exponential of <var>op</var> minus one, |
|
1616 rounded in the direction <var>rnd</var>. |
|
1617 </p></blockquote></div> |
|
1618 |
|
1619 <div class="defun"> |
|
1620 — Function: int <b>mpfr_eint</b> (<var>mpfr_t y, mpfr_t x, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005feint-184"></a></var><br> |
|
1621 <blockquote><p>Set <var>y</var> to the exponential integral of <var>x</var>, |
|
1622 rounded in the direction <var>rnd</var>. |
|
1623 For positive <var>x</var>, |
|
1624 the exponential integral is the sum of Euler's constant, of the logarithm |
|
1625 of <var>x</var>, and of the sum for k from 1 to infinity of |
|
1626 <var>x</var> to the power k, divided by k and factorial(k). |
|
1627 For negative <var>x</var>, the returned value is NaN. |
|
1628 </p></blockquote></div> |
|
1629 |
|
1630 <div class="defun"> |
|
1631 — Function: int <b>mpfr_gamma</b> (<var>mpfr_t rop, mpfr_t op, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fgamma-185"></a></var><br> |
|
1632 <blockquote><p>Set <var>rop</var> to the value of the Gamma function on <var>op</var>, rounded in the |
|
1633 direction <var>rnd</var>. When <var>op</var> is a negative integer, NaN is returned. |
|
1634 </p></blockquote></div> |
|
1635 |
|
1636 <div class="defun"> |
|
1637 — Function: int <b>mpfr_lngamma</b> (<var>mpfr_t rop, mpfr_t op, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005flngamma-186"></a></var><br> |
|
1638 <blockquote><p>Set <var>rop</var> to the value of the logarithm of the Gamma function on <var>op</var>, |
|
1639 rounded in the direction <var>rnd</var>. |
|
1640 When −2<var>k</var>−1 <= <var>x</var> <= −2<var>k</var>, |
|
1641 <var>k</var> being a non-negative integer, NaN is returned. |
|
1642 See also <code>mpfr_lgamma</code>. |
|
1643 </p></blockquote></div> |
|
1644 |
|
1645 <div class="defun"> |
|
1646 — Function: int <b>mpfr_lgamma</b> (<var>mpfr_t rop, int *signp, mpfr_t op, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005flgamma-187"></a></var><br> |
|
1647 <blockquote><p>Set <var>rop</var> to the value of the logarithm of the absolute value of the |
|
1648 Gamma function on <var>op</var>, rounded in the direction <var>rnd</var>. The sign |
|
1649 (1 or −1) of Gamma(<var>op</var>) is returned in the object pointed to |
|
1650 by <var>signp</var>. When <var>op</var> is an infinity or a non-positive integer, |
|
1651 +Inf is returned. When <var>op</var> is NaN, −Inf or a negative integer, |
|
1652 *<var>signp</var> is undefined, and when <var>op</var> is �0, *<var>signp</var> is |
|
1653 the sign of the zero. |
|
1654 </p></blockquote></div> |
|
1655 |
|
1656 <div class="defun"> |
|
1657 — Function: int <b>mpfr_zeta</b> (<var>mpfr_t rop, mpfr_t op, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fzeta-188"></a></var><br> |
|
1658 — Function: int <b>mpfr_zeta_ui</b> (<var>mpfr_t rop, unsigned long op, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fzeta_005fui-189"></a></var><br> |
|
1659 <blockquote><p>Set <var>rop</var> to the value of the Riemann Zeta function on <var>op</var>, |
|
1660 rounded in the direction <var>rnd</var>. |
|
1661 </p></blockquote></div> |
|
1662 |
|
1663 <div class="defun"> |
|
1664 — Function: int <b>mpfr_erf</b> (<var>mpfr_t rop, mpfr_t op, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005ferf-190"></a></var><br> |
|
1665 <blockquote><p>Set <var>rop</var> to the value of the error function on <var>op</var>, |
|
1666 rounded in the direction <var>rnd</var>. |
|
1667 </p></blockquote></div> |
|
1668 |
|
1669 <div class="defun"> |
|
1670 — Function: int <b>mpfr_erfc</b> (<var>mpfr_t rop, mpfr_t op, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005ferfc-191"></a></var><br> |
|
1671 <blockquote><p>Set <var>rop</var> to the value of the complementary error function on <var>op</var>, |
|
1672 rounded in the direction <var>rnd</var>. |
|
1673 </p></blockquote></div> |
|
1674 |
|
1675 <div class="defun"> |
|
1676 — Function: int <b>mpfr_j0</b> (<var>mpfr_t rop, mpfr_t op, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fj0-192"></a></var><br> |
|
1677 — Function: int <b>mpfr_j1</b> (<var>mpfr_t rop, mpfr_t op, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fj1-193"></a></var><br> |
|
1678 — Function: int <b>mpfr_jn</b> (<var>mpfr_t rop, long n, mpfr_t op, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fjn-194"></a></var><br> |
|
1679 <blockquote><p>Set <var>rop</var> to the value of the first order Bessel function of order 0, 1 |
|
1680 and <var>n</var> on <var>op</var>, rounded in the direction <var>rnd</var>. When <var>op</var> is |
|
1681 NaN, <var>rop</var> is always set to NaN. When <var>op</var> is plus or minus Infinity, |
|
1682 <var>rop</var> is set to +0. When <var>op</var> is zero, and <var>n</var> is not zero, |
|
1683 <var>rop</var> is +0 or −0 depending on the parity and sign of <var>n</var>, |
|
1684 and the sign of <var>op</var>. |
|
1685 </p></blockquote></div> |
|
1686 |
|
1687 <div class="defun"> |
|
1688 — Function: int <b>mpfr_y0</b> (<var>mpfr_t rop, mpfr_t op, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fy0-195"></a></var><br> |
|
1689 — Function: int <b>mpfr_y1</b> (<var>mpfr_t rop, mpfr_t op, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fy1-196"></a></var><br> |
|
1690 — Function: int <b>mpfr_yn</b> (<var>mpfr_t rop, long n, mpfr_t op, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fyn-197"></a></var><br> |
|
1691 <blockquote><p>Set <var>rop</var> to the value of the second order Bessel function of order 0, 1 |
|
1692 and <var>n</var> on <var>op</var>, rounded in the direction <var>rnd</var>. When <var>op</var> is |
|
1693 NaN or negative, |
|
1694 <var>rop</var> is always set to NaN. When <var>op</var> is +Inf, |
|
1695 <var>rop</var> is +0. When <var>op</var> is zero, |
|
1696 <var>rop</var> is +Inf or −Inf depending on the parity and sign of <var>n</var>. |
|
1697 </p></blockquote></div> |
|
1698 |
|
1699 <div class="defun"> |
|
1700 — Function: int <b>mpfr_fma</b> (<var>mpfr_t rop, mpfr_t op1, mpfr_t op2, mpfr_t op3, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005ffma-198"></a></var><br> |
|
1701 <blockquote><p>Set <var>rop</var> to (<var>op1</var> times <var>op2</var>) + <var>op3</var>, |
|
1702 rounded in the direction <var>rnd</var>. |
|
1703 </p></blockquote></div> |
|
1704 |
|
1705 <div class="defun"> |
|
1706 — Function: int <b>mpfr_fms</b> (<var>mpfr_t rop, mpfr_t op1, mpfr_t op2, mpfr_t op3, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005ffms-199"></a></var><br> |
|
1707 <blockquote><p>Set <var>rop</var> to (<var>op1</var> times <var>op2</var>) - <var>op3</var>, |
|
1708 rounded in the direction <var>rnd</var>. |
|
1709 </p></blockquote></div> |
|
1710 |
|
1711 <div class="defun"> |
|
1712 — Function: int <b>mpfr_agm</b> (<var>mpfr_t rop, mpfr_t op1, mpfr_t op2, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fagm-200"></a></var><br> |
|
1713 <blockquote><p>Set <var>rop</var> to the arithmetic-geometric mean of <var>op1</var> and <var>op2</var>, |
|
1714 rounded in the direction <var>rnd</var>. |
|
1715 The arithmetic-geometric mean is the common limit of the sequences |
|
1716 u[n] and v[n], where u[0]=<var>op1</var>, v[0]=<var>op2</var>, u[n+1] is the |
|
1717 arithmetic mean of u[n] and v[n], and v[n+1] is the geometric mean of |
|
1718 u[n] and v[n]. |
|
1719 If any operand is negative, the return value is NaN. |
|
1720 </p></blockquote></div> |
|
1721 |
|
1722 <div class="defun"> |
|
1723 — Function: int <b>mpfr_hypot</b> (<var>mpfr_t rop, mpfr_t x, mpfr_t y, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fhypot-201"></a></var><br> |
|
1724 <blockquote><p>Set <var>rop</var> to the Euclidean norm of <var>x</var> and <var>y</var>, |
|
1725 i.e. the square root of the sum of the squares of <var>x</var> and <var>y</var>, |
|
1726 rounded in the direction <var>rnd</var>. |
|
1727 Special values are currently handled as described in Section F.9.4.3 of |
|
1728 the ISO C99 standard, for the <code>hypot</code> function (note this may change |
|
1729 in future versions): If <var>x</var> or <var>y</var> is an infinity, then plus |
|
1730 infinity is returned in <var>rop</var>, even if the other number is NaN. |
|
1731 </p></blockquote></div> |
|
1732 |
|
1733 <div class="defun"> |
|
1734 — Function: int <b>mpfr_const_log2</b> (<var>mpfr_t rop, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fconst_005flog2-202"></a></var><br> |
|
1735 — Function: int <b>mpfr_const_pi</b> (<var>mpfr_t rop, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fconst_005fpi-203"></a></var><br> |
|
1736 — Function: int <b>mpfr_const_euler</b> (<var>mpfr_t rop, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fconst_005feuler-204"></a></var><br> |
|
1737 — Function: int <b>mpfr_const_catalan</b> (<var>mpfr_t rop, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fconst_005fcatalan-205"></a></var><br> |
|
1738 <blockquote><p>Set <var>rop</var> to the logarithm of 2, the value of Pi, |
|
1739 of Euler's constant 0.577<small class="dots">...</small>, of Catalan's constant 0.915<small class="dots">...</small>, |
|
1740 respectively, rounded in the direction |
|
1741 <var>rnd</var>. These functions cache the computed values to avoid other |
|
1742 calculations if a lower or equal precision is requested. To free these caches, |
|
1743 use <code>mpfr_free_cache</code>. |
|
1744 </p></blockquote></div> |
|
1745 |
|
1746 <div class="defun"> |
|
1747 — Function: void <b>mpfr_free_cache</b> (<var>void</var>)<var><a name="index-mpfr_005ffree_005fcache-206"></a></var><br> |
|
1748 <blockquote><p>Free various caches used by MPFR internally, in particular the |
|
1749 caches used by the functions computing constants (currently |
|
1750 <code>mpfr_const_log2</code>, <code>mpfr_const_pi</code>, |
|
1751 <code>mpfr_const_euler</code> and <code>mpfr_const_catalan</code>). |
|
1752 You should call this function before terminating a thread, even if you did |
|
1753 not call these functions directly (they could have been called internally). |
|
1754 </p></blockquote></div> |
|
1755 |
|
1756 <div class="defun"> |
|
1757 — Function: int <b>mpfr_sum</b> (<var>mpfr_t rop, mpfr_ptr const tab</var>[]<var>, unsigned long n, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fsum-207"></a></var><br> |
|
1758 <blockquote><p>Set <var>ret</var> to the sum of all elements of <var>tab</var> whose size is <var>n</var>, |
|
1759 rounded in the direction <var>rnd</var>. Warning, <var>tab</var> is a table of pointers |
|
1760 to mpfr_t, not a table of mpfr_t (preliminary interface). The returned |
|
1761 <code>int</code> value is zero when the computed value is the exact value, |
|
1762 and non-zero when this cannot be guaranteed, without giving the |
|
1763 direction of the error as the other functions do. |
|
1764 </p></blockquote></div> |
|
1765 |
|
1766 <div class="node"> |
|
1767 <p><hr> |
|
1768 <a name="Input-and-Output-Functions"></a> |
|
1769 Next: <a rel="next" accesskey="n" href="#Integer-Related-Functions">Integer Related Functions</a>, |
|
1770 Previous: <a rel="previous" accesskey="p" href="#Special-Functions">Special Functions</a>, |
|
1771 Up: <a rel="up" accesskey="u" href="#MPFR-Interface">MPFR Interface</a> |
|
1772 |
|
1773 </div> |
|
1774 |
|
1775 <!-- node-name, next, previous, up --> |
|
1776 <p><a name="index-Float-input-and-output-functions-208"></a><a name="index-Input-functions-209"></a><a name="index-Output-functions-210"></a><a name="index-I_002fO-functions-211"></a> |
|
1777 |
|
1778 <h3 class="section">5.8 Input and Output Functions</h3> |
|
1779 |
|
1780 <p>This section describes functions that perform input from an input/output |
|
1781 stream, and functions that output to an input/output stream. |
|
1782 Passing a null pointer for a <var>stream</var> argument to any of |
|
1783 these functions will make them read from <code>stdin</code> and write to |
|
1784 <code>stdout</code>, respectively. |
|
1785 |
|
1786 <p>When using any of these functions, you must include the <code><stdio.h></code> |
|
1787 standard header before <samp><span class="file">mpfr.h</span></samp>, to allow <samp><span class="file">mpfr.h</span></samp> to define |
|
1788 prototypes for these functions. |
|
1789 |
|
1790 <div class="defun"> |
|
1791 — Function: size_t <b>mpfr_out_str</b> (<var>FILE *stream, int base, size_t n, mpfr_t op, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fout_005fstr-212"></a></var><br> |
|
1792 <blockquote><p>Output <var>op</var> on stream <var>stream</var>, as a string of digits in |
|
1793 base <var>base</var>, rounded in the direction <var>rnd</var>. |
|
1794 The base may vary from 2 to 36. Print <var>n</var> significant digits exactly, |
|
1795 or if <var>n</var> is 0, enough digits so that <var>op</var> can be read back |
|
1796 exactly (see <code>mpfr_get_str</code>). |
|
1797 |
|
1798 <p>In addition to the significant digits, a decimal point (defined by the |
|
1799 current locale) at the right of the |
|
1800 first digit and a trailing exponent in base 10, in the form ‘<samp><span class="samp">eNNN</span></samp>’, |
|
1801 are printed. If <var>base</var> is greater than 10, ‘<samp><span class="samp">@</span></samp>’ will be used |
|
1802 instead of ‘<samp><span class="samp">e</span></samp>’ as exponent delimiter. |
|
1803 |
|
1804 <p>Return the number of bytes written, or if an error occurred, return 0. |
|
1805 </p></blockquote></div> |
|
1806 |
|
1807 <div class="defun"> |
|
1808 — Function: size_t <b>mpfr_inp_str</b> (<var>mpfr_t rop, FILE *stream, int base, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005finp_005fstr-213"></a></var><br> |
|
1809 <blockquote><p>Input a string in base <var>base</var> from stream <var>stream</var>, |
|
1810 rounded in the direction <var>rnd</var>, and put the |
|
1811 read float in <var>rop</var>. |
|
1812 <!-- The argument @var{base} must be in the range 2 to 36. --> |
|
1813 |
|
1814 <!-- The string is of the form @samp{M@@N} or, if the --> |
|
1815 <!-- base is 10 or less, alternatively @samp{MeN} or @samp{MEN}, or, if the base --> |
|
1816 <!-- is 16, alternatively @samp{MpB} or @samp{MPB}. --> |
|
1817 <!-- @samp{M} is the significand in the specified base, @samp{N} is the exponent --> |
|
1818 <!-- written in decimal for the specified base, and in base 16, @samp{B} is the --> |
|
1819 <!-- binary exponent written in decimal (i.e.@: it indicates the power of 2 by --> |
|
1820 <!-- which the significand is to be scaled). --> |
|
1821 <p>This function reads a word (defined as a sequence of characters between |
|
1822 whitespace) and parses it using <code>mpfr_set_str</code> (it may change). |
|
1823 See the documentation of <code>mpfr_strtofr</code> for a detailed description |
|
1824 of the valid string formats. |
|
1825 <!-- Special values can be read as follows (the case does not matter): --> |
|
1826 <!-- @code{@@NaN@@}, @code{@@Inf@@}, @code{+@@Inf@@} and @code{-@@Inf@@}, --> |
|
1827 <!-- possibly followed by other characters; if the base is smaller or equal --> |
|
1828 <!-- to 16, the following strings are accepted too: @code{NaN}, @code{Inf}, --> |
|
1829 <!-- @code{+Inf} and @code{-Inf}. --> |
|
1830 |
|
1831 <p>Return the number of bytes read, or if an error occurred, return 0. |
|
1832 </p></blockquote></div> |
|
1833 |
|
1834 <!-- @deftypefun void mpfr_inp_raw (mpfr_t @var{float}, FILE *@var{stream}) --> |
|
1835 <!-- Input from stdio stream @var{stream} in the format written by --> |
|
1836 <!-- @code{mpfr_out_raw}, and put the result in @var{float}. --> |
|
1837 <!-- @end deftypefun --> |
|
1838 <div class="node"> |
|
1839 <p><hr> |
|
1840 <a name="Integer-Related-Functions"></a> |
|
1841 Next: <a rel="next" accesskey="n" href="#Miscellaneous-Functions">Miscellaneous Functions</a>, |
|
1842 Previous: <a rel="previous" accesskey="p" href="#Input-and-Output-Functions">Input and Output Functions</a>, |
|
1843 Up: <a rel="up" accesskey="u" href="#MPFR-Interface">MPFR Interface</a> |
|
1844 |
|
1845 </div> |
|
1846 |
|
1847 <!-- node-name, next, previous, up --> |
|
1848 <p><a name="index-Integer-related-functions-214"></a> |
|
1849 |
|
1850 <h3 class="section">5.9 Integer Related Functions</h3> |
|
1851 |
|
1852 <div class="defun"> |
|
1853 — Function: int <b>mpfr_rint</b> (<var>mpfr_t rop, mpfr_t op, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005frint-215"></a></var><br> |
|
1854 — Function: int <b>mpfr_ceil</b> (<var>mpfr_t rop, mpfr_t op</var>)<var><a name="index-mpfr_005fceil-216"></a></var><br> |
|
1855 — Function: int <b>mpfr_floor</b> (<var>mpfr_t rop, mpfr_t op</var>)<var><a name="index-mpfr_005ffloor-217"></a></var><br> |
|
1856 — Function: int <b>mpfr_round</b> (<var>mpfr_t rop, mpfr_t op</var>)<var><a name="index-mpfr_005fround-218"></a></var><br> |
|
1857 — Function: int <b>mpfr_trunc</b> (<var>mpfr_t rop, mpfr_t op</var>)<var><a name="index-mpfr_005ftrunc-219"></a></var><br> |
|
1858 <blockquote><p>Set <var>rop</var> to <var>op</var> rounded to an integer. |
|
1859 <code>mpfr_rint</code> rounds to the nearest representable integer in the |
|
1860 given rounding mode, <code>mpfr_ceil</code> rounds |
|
1861 to the next higher or equal representable integer, <code>mpfr_floor</code> to |
|
1862 the next lower or equal representable integer, <code>mpfr_round</code> to the |
|
1863 nearest representable integer, rounding halfway cases away from zero, |
|
1864 and <code>mpfr_trunc</code> to the next representable integer toward zero. |
|
1865 |
|
1866 <p>The returned value is zero when the result is exact, positive when it is |
|
1867 greater than the original value of <var>op</var>, and negative when it is smaller. |
|
1868 More precisely, the returned value is 0 when <var>op</var> is an integer |
|
1869 representable in <var>rop</var>, 1 or −1 when <var>op</var> is an integer |
|
1870 that is not representable in <var>rop</var>, 2 or −2 when <var>op</var> is |
|
1871 not an integer. |
|
1872 |
|
1873 <p>Note that <code>mpfr_round</code> is different from <code>mpfr_rint</code> called with |
|
1874 the rounding to nearest mode (where halfway cases are rounded to an even |
|
1875 integer or significand). Note also that no double rounding is performed; for |
|
1876 instance, 4.5 (100.1 in binary) is rounded by <code>mpfr_round</code> to 4 (100 |
|
1877 in binary) in 2-bit precision, though <code>round(4.5)</code> is equal to 5 and |
|
1878 5 (101 in binary) is rounded to 6 (110 in binary) in 2-bit precision. |
|
1879 </p></blockquote></div> |
|
1880 |
|
1881 <div class="defun"> |
|
1882 — Function: int <b>mpfr_rint_ceil</b> (<var>mpfr_t rop, mpfr_t op, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005frint_005fceil-220"></a></var><br> |
|
1883 — Function: int <b>mpfr_rint_floor</b> (<var>mpfr_t rop, mpfr_t op, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005frint_005ffloor-221"></a></var><br> |
|
1884 — Function: int <b>mpfr_rint_round</b> (<var>mpfr_t rop, mpfr_t op, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005frint_005fround-222"></a></var><br> |
|
1885 — Function: int <b>mpfr_rint_trunc</b> (<var>mpfr_t rop, mpfr_t op, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005frint_005ftrunc-223"></a></var><br> |
|
1886 <blockquote><p>Set <var>rop</var> to <var>op</var> rounded to an integer. |
|
1887 <code>mpfr_rint_ceil</code> rounds to the next higher or equal integer, |
|
1888 <code>mpfr_rint_floor</code> to the next lower or equal integer, |
|
1889 <code>mpfr_rint_round</code> to the nearest integer, rounding halfway cases away |
|
1890 from zero, and <code>mpfr_rint_trunc</code> to the next integer toward zero. |
|
1891 If the result is not representable, it is rounded in the direction <var>rnd</var>. |
|
1892 The returned value is the ternary value associated with the considered |
|
1893 round-to-integer function (regarded in the same way as any other |
|
1894 mathematical function). |
|
1895 </p></blockquote></div> |
|
1896 |
|
1897 <div class="defun"> |
|
1898 — Function: int <b>mpfr_frac</b> (<var>mpfr_t rop, mpfr_t op, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005ffrac-224"></a></var><br> |
|
1899 <blockquote><p>Set <var>rop</var> to the fractional part of <var>op</var>, having the same sign as |
|
1900 <var>op</var>, rounded in the direction <var>rnd</var> (unlike in <code>mpfr_rint</code>, |
|
1901 <var>rnd</var> affects only how the exact fractional part is rounded, not how |
|
1902 the fractional part is generated). |
|
1903 </p></blockquote></div> |
|
1904 |
|
1905 <div class="defun"> |
|
1906 — Function: int <b>mpfr_remainder</b> (<var>mpfr_t r, mpfr_t x, mpfr_t y, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fremainder-225"></a></var><br> |
|
1907 — Function: int <b>mpfr_remquo</b> (<var>mpfr_t r, long* q, mpfr_t x, mpfr_t y, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fremquo-226"></a></var><br> |
|
1908 <blockquote><p>Set <var>r</var> to the remainder of the division of <var>x</var> by <var>y</var>, with |
|
1909 quotient rounded to the nearest integer (ties rounded to even), and |
|
1910 <var>r</var> rounded according to the direction <var>rnd</var>. |
|
1911 If <var>r</var> is zero, it has the sign of <var>x</var>. |
|
1912 The return value is the ternary value corresponding to <var>r</var>. |
|
1913 Additionally, <code>mpfr_remquo</code> stores |
|
1914 the low significant bits from the quotient in <var>*q</var> |
|
1915 (more precisely the number of bits in a <code>long</code> minus one), |
|
1916 with the sign of <var>x</var> divided by <var>y</var> |
|
1917 (except if those low bits are all zero, in which case zero is returned). |
|
1918 Note that <var>x</var> may be so large in magnitude relative to <var>y</var> that an |
|
1919 exact representation of the quotient is not practical. |
|
1920 These functions are useful for additive argument reduction. |
|
1921 </p></blockquote></div> |
|
1922 |
|
1923 <div class="defun"> |
|
1924 — Function: int <b>mpfr_integer_p</b> (<var>mpfr_t op</var>)<var><a name="index-mpfr_005finteger_005fp-227"></a></var><br> |
|
1925 <blockquote><p>Return non-zero iff <var>op</var> is an integer. |
|
1926 </p></blockquote></div> |
|
1927 |
|
1928 <div class="node"> |
|
1929 <p><hr> |
|
1930 <a name="Miscellaneous-Functions"></a> |
|
1931 Next: <a rel="next" accesskey="n" href="#Rounding-Mode-Related-Functions">Rounding Mode Related Functions</a>, |
|
1932 Previous: <a rel="previous" accesskey="p" href="#Integer-Related-Functions">Integer Related Functions</a>, |
|
1933 Up: <a rel="up" accesskey="u" href="#MPFR-Interface">MPFR Interface</a> |
|
1934 |
|
1935 </div> |
|
1936 |
|
1937 <!-- node-name, next, previous, up --> |
|
1938 <p><a name="index-Miscellaneous-float-functions-228"></a> |
|
1939 |
|
1940 <h3 class="section">5.10 Miscellaneous Functions</h3> |
|
1941 |
|
1942 <div class="defun"> |
|
1943 — Function: void <b>mpfr_nexttoward</b> (<var>mpfr_t x, mpfr_t y</var>)<var><a name="index-mpfr_005fnexttoward-229"></a></var><br> |
|
1944 <blockquote><p>If <var>x</var> or <var>y</var> is NaN, set <var>x</var> to NaN. Otherwise, if <var>x</var> |
|
1945 is different from <var>y</var>, replace <var>x</var> by the next floating-point |
|
1946 number (with the precision of <var>x</var> and the current exponent range) |
|
1947 in the direction of <var>y</var>, if there is one |
|
1948 (the infinite values are seen as the smallest and largest floating-point |
|
1949 numbers). If the result is zero, it keeps the same sign. No underflow or |
|
1950 overflow is generated. |
|
1951 </p></blockquote></div> |
|
1952 |
|
1953 <div class="defun"> |
|
1954 — Function: void <b>mpfr_nextabove</b> (<var>mpfr_t x</var>)<var><a name="index-mpfr_005fnextabove-230"></a></var><br> |
|
1955 <blockquote><p>Equivalent to <code>mpfr_nexttoward</code> where <var>y</var> is plus infinity. |
|
1956 </p></blockquote></div> |
|
1957 |
|
1958 <div class="defun"> |
|
1959 — Function: void <b>mpfr_nextbelow</b> (<var>mpfr_t x</var>)<var><a name="index-mpfr_005fnextbelow-231"></a></var><br> |
|
1960 <blockquote><p>Equivalent to <code>mpfr_nexttoward</code> where <var>y</var> is minus infinity. |
|
1961 </p></blockquote></div> |
|
1962 |
|
1963 <div class="defun"> |
|
1964 — Function: int <b>mpfr_min</b> (<var>mpfr_t rop, mpfr_t op1, mpfr_t op2, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fmin-232"></a></var><br> |
|
1965 <blockquote><p>Set <var>rop</var> to the minimum of <var>op1</var> and <var>op2</var>. If <var>op1</var> |
|
1966 and <var>op2</var> are both NaN, then <var>rop</var> is set to NaN. If <var>op1</var> |
|
1967 or <var>op2</var> is NaN, then <var>rop</var> is set to the numeric value. If |
|
1968 <var>op1</var> and <var>op2</var> are zeros of different signs, then <var>rop</var> |
|
1969 is set to −0. |
|
1970 </p></blockquote></div> |
|
1971 |
|
1972 <div class="defun"> |
|
1973 — Function: int <b>mpfr_max</b> (<var>mpfr_t rop, mpfr_t op1, mpfr_t op2, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fmax-233"></a></var><br> |
|
1974 <blockquote><p>Set <var>rop</var> to the maximum of <var>op1</var> and <var>op2</var>. If <var>op1</var> |
|
1975 and <var>op2</var> are both NaN, then <var>rop</var> is set to NaN. If <var>op1</var> |
|
1976 or <var>op2</var> is NaN, then <var>rop</var> is set to the numeric value. If |
|
1977 <var>op1</var> and <var>op2</var> are zeros of different signs, then <var>rop</var> |
|
1978 is set to +0. |
|
1979 </p></blockquote></div> |
|
1980 |
|
1981 <div class="defun"> |
|
1982 — Function: int <b>mpfr_urandomb</b> (<var>mpfr_t rop, gmp_randstate_t state</var>)<var><a name="index-mpfr_005furandomb-234"></a></var><br> |
|
1983 <blockquote><p>Generate a uniformly distributed random float in the interval |
|
1984 0 <= <var>rop</var> < 1. |
|
1985 Return 0, unless the exponent is not in the current exponent range, in |
|
1986 which case <var>rop</var> is set to NaN and a non-zero value is returned. The |
|
1987 second argument is a <code>gmp_randstate_t</code> structure which should be |
|
1988 created using the GMP <code>gmp_randinit</code> function, see the GMP manual. |
|
1989 </p></blockquote></div> |
|
1990 |
|
1991 <div class="defun"> |
|
1992 — Function: void <b>mpfr_random</b> (<var>mpfr_t rop</var>)<var><a name="index-mpfr_005frandom-235"></a></var><br> |
|
1993 <blockquote><p>Generate a uniformly distributed random float in the interval |
|
1994 0 <= <var>rop</var> < 1. |
|
1995 This function is deprecated; <code>mpfr_urandomb</code> should be used instead. |
|
1996 </p></blockquote></div> |
|
1997 |
|
1998 <div class="defun"> |
|
1999 — Function: void <b>mpfr_random2</b> (<var>mpfr_t rop, mp_size_t size, mp_exp_t exp</var>)<var><a name="index-mpfr_005frandom2-236"></a></var><br> |
|
2000 <blockquote><p>Generate a random float of at most <var>size</var> limbs, with long strings of |
|
2001 zeros and ones in the binary representation. The exponent of the number is in |
|
2002 the interval −<var>exp</var> to <var>exp</var>. |
|
2003 This function is useful for |
|
2004 testing functions and algorithms, since this kind of random numbers have |
|
2005 proven to be more likely to trigger corner-case bugs. |
|
2006 Negative random numbers are generated when <var>size</var> is negative. |
|
2007 Put +0 in <var>rop</var> when size if zero. The internal state of the default |
|
2008 pseudorandom number generator is modified by a call to this function (the |
|
2009 same one as GMP if MPFR was built using ‘<samp><span class="samp">--with-gmp-build</span></samp>’). |
|
2010 </p></blockquote></div> |
|
2011 |
|
2012 <div class="defun"> |
|
2013 — Function: mp_exp_t <b>mpfr_get_exp</b> (<var>mpfr_t x</var>)<var><a name="index-mpfr_005fget_005fexp-237"></a></var><br> |
|
2014 <blockquote><p>Get the exponent of <var>x</var>, assuming that <var>x</var> is a non-zero ordinary |
|
2015 number and the significand is chosen in [1/2,1). The behavior for NaN, |
|
2016 infinity or zero is undefined. |
|
2017 </p></blockquote></div> |
|
2018 |
|
2019 <div class="defun"> |
|
2020 — Function: int <b>mpfr_set_exp</b> (<var>mpfr_t x, mp_exp_t e</var>)<var><a name="index-mpfr_005fset_005fexp-238"></a></var><br> |
|
2021 <blockquote><p>Set the exponent of <var>x</var> if <var>e</var> is in the current exponent range, |
|
2022 and return 0 (even if <var>x</var> is not a non-zero ordinary number); |
|
2023 otherwise, return a non-zero value. |
|
2024 The significand is assumed to be in [1/2,1). |
|
2025 </p></blockquote></div> |
|
2026 |
|
2027 <div class="defun"> |
|
2028 — Function: int <b>mpfr_signbit</b> (<var>mpfr_t op</var>)<var><a name="index-mpfr_005fsignbit-239"></a></var><br> |
|
2029 <blockquote><p>Return a non-zero value iff <var>op</var> has its sign bit set (i.e. if it is |
|
2030 negative, −0, or a NaN whose representation has its sign bit set). |
|
2031 </p></blockquote></div> |
|
2032 |
|
2033 <div class="defun"> |
|
2034 — Function: int <b>mpfr_setsign</b> (<var>mpfr_t rop, mpfr_t op, int s, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fsetsign-240"></a></var><br> |
|
2035 <blockquote><p>Set the value of <var>rop</var> from <var>op</var>, rounded toward the given |
|
2036 direction <var>rnd</var>, then set (resp. clear) its sign bit if <var>s</var> |
|
2037 is non-zero (resp. zero), even when <var>op</var> is a NaN. |
|
2038 </p></blockquote></div> |
|
2039 |
|
2040 <div class="defun"> |
|
2041 — Function: int <b>mpfr_copysign</b> (<var>mpfr_t rop, mpfr_t op1, mpfr_t op2, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fcopysign-241"></a></var><br> |
|
2042 <blockquote><p>Set the value of <var>rop</var> from <var>op1</var>, rounded toward the given |
|
2043 direction <var>rnd</var>, then set its sign bit to that of <var>op2</var> (even |
|
2044 when <var>op1</var> or <var>op2</var> is a NaN). This function is equivalent to |
|
2045 <code>mpfr_setsign (</code><var>rop</var><code>, </code><var>op1</var><code>, mpfr_signbit (</code><var>op2</var><code>), </code><var>rnd</var><code>)</code>. |
|
2046 </p></blockquote></div> |
|
2047 |
|
2048 <!-- By definition, a C string is always null-terminated, so that we --> |
|
2049 <!-- could just say "string" or "null-terminated character array", --> |
|
2050 <!-- but "null-terminated string" is not an error and probably better --> |
|
2051 <!-- for most users. --> |
|
2052 <div class="defun"> |
|
2053 — Function: const char * <b>mpfr_get_version</b> (<var>void</var>)<var><a name="index-mpfr_005fget_005fversion-242"></a></var><br> |
|
2054 <blockquote><p>Return the MPFR version, as a null-terminated string. |
|
2055 </p></blockquote></div> |
|
2056 |
|
2057 <div class="defun"> |
|
2058 — Macro: <b>MPFR_VERSION</b><var><a name="index-MPFR_005fVERSION-243"></a></var><br> |
|
2059 — Macro: <b>MPFR_VERSION_MAJOR</b><var><a name="index-MPFR_005fVERSION_005fMAJOR-244"></a></var><br> |
|
2060 — Macro: <b>MPFR_VERSION_MINOR</b><var><a name="index-MPFR_005fVERSION_005fMINOR-245"></a></var><br> |
|
2061 — Macro: <b>MPFR_VERSION_PATCHLEVEL</b><var><a name="index-MPFR_005fVERSION_005fPATCHLEVEL-246"></a></var><br> |
|
2062 — Macro: <b>MPFR_VERSION_STRING</b><var><a name="index-MPFR_005fVERSION_005fSTRING-247"></a></var><br> |
|
2063 <blockquote><p><code>MPFR_VERSION</code> is the version of MPFR as a preprocessing constant. |
|
2064 <code>MPFR_VERSION_MAJOR</code>, <code>MPFR_VERSION_MINOR</code> and |
|
2065 <code>MPFR_VERSION_PATCHLEVEL</code> are respectively the major, minor and patch |
|
2066 level of MPFR version, as preprocessing constants. |
|
2067 <code>MPFR_VERSION_STRING</code> is the version (with an optional suffix, used |
|
2068 in development and pre-release versions) as a string constant, which can |
|
2069 be compared to the result of <code>mpfr_get_version</code> to check at run time |
|
2070 the header file and library used match: |
|
2071 <pre class="example"> if (strcmp (mpfr_get_version (), MPFR_VERSION_STRING)) |
|
2072 fprintf (stderr, "Warning: header and library do not match\n"); |
|
2073 </pre> |
|
2074 <p>Note: Obtaining different strings is not necessarily an error, as |
|
2075 in general, a program compiled with some old MPFR version can be |
|
2076 dynamically linked with a newer MPFR library version (if allowed |
|
2077 by the library versioning system). |
|
2078 </p></blockquote></div> |
|
2079 |
|
2080 <div class="defun"> |
|
2081 — Macro: long <b>MPFR_VERSION_NUM</b> (<var>major, minor, patchlevel</var>)<var><a name="index-MPFR_005fVERSION_005fNUM-248"></a></var><br> |
|
2082 <blockquote><p>Create an integer in the same format as used by <code>MPFR_VERSION</code> from the |
|
2083 given <var>major</var>, <var>minor</var> and <var>patchlevel</var>. |
|
2084 Here is an example of how to check the MPFR version at compile time: |
|
2085 <pre class="example"> #if (!defined(MPFR_VERSION) || (MPFR_VERSION<MPFR_VERSION_NUM(2,1,0))) |
|
2086 # error "Wrong MPFR version." |
|
2087 #endif |
|
2088 </pre> |
|
2089 </blockquote></div> |
|
2090 |
|
2091 <div class="defun"> |
|
2092 — Function: const char * <b>mpfr_get_patches</b> (<var>void</var>)<var><a name="index-mpfr_005fget_005fpatches-249"></a></var><br> |
|
2093 <blockquote><p>Return a null-terminated string containing the ids of the patches applied to |
|
2094 the MPFR library (contents of the <samp><span class="file">PATCHES</span></samp> file), separated by spaces. |
|
2095 Note: If the program has been compiled with an older MPFR version and is |
|
2096 dynamically linked with a new MPFR library version, the ids of the patches |
|
2097 applied to the old (compile-time) MPFR version are not available (however |
|
2098 this information should not have much interest in general). |
|
2099 </p></blockquote></div> |
|
2100 |
|
2101 <div class="node"> |
|
2102 <p><hr> |
|
2103 <a name="Rounding-Mode-Related-Functions"></a> |
|
2104 Next: <a rel="next" accesskey="n" href="#Exception-Related-Functions">Exception Related Functions</a>, |
|
2105 Previous: <a rel="previous" accesskey="p" href="#Miscellaneous-Functions">Miscellaneous Functions</a>, |
|
2106 Up: <a rel="up" accesskey="u" href="#MPFR-Interface">MPFR Interface</a> |
|
2107 |
|
2108 </div> |
|
2109 |
|
2110 <p><a name="index-Rounding-mode-related-functions-250"></a> |
|
2111 |
|
2112 <h3 class="section">5.11 Rounding Mode Related Functions</h3> |
|
2113 |
|
2114 <div class="defun"> |
|
2115 — Function: void <b>mpfr_set_default_rounding_mode</b> (<var>mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fset_005fdefault_005frounding_005fmode-251"></a></var><br> |
|
2116 <blockquote><p>Set the default rounding mode to <var>rnd</var>. |
|
2117 The default rounding mode is to nearest initially. |
|
2118 </p></blockquote></div> |
|
2119 |
|
2120 <div class="defun"> |
|
2121 — Function: mp_rnd_t <b>mpfr_get_default_rounding_mode</b> (<var>void</var>)<var><a name="index-mpfr_005fget_005fdefault_005frounding_005fmode-252"></a></var><br> |
|
2122 <blockquote><p>Get the default rounding mode. |
|
2123 </p></blockquote></div> |
|
2124 |
|
2125 <div class="defun"> |
|
2126 — Function: int <b>mpfr_prec_round</b> (<var>mpfr_t x, mp_prec_t prec, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fprec_005fround-253"></a></var><br> |
|
2127 <blockquote><p>Round <var>x</var> according to <var>rnd</var> with precision <var>prec</var>, which |
|
2128 must be an integer between <code>MPFR_PREC_MIN</code> and <code>MPFR_PREC_MAX</code> |
|
2129 (otherwise the behavior is undefined). |
|
2130 If <var>prec</var> is greater or equal to the precision of <var>x</var>, then new |
|
2131 space is allocated for the significand, and it is filled with zeros. |
|
2132 Otherwise, the significand is rounded to precision <var>prec</var> with the given |
|
2133 direction. In both cases, the precision of <var>x</var> is changed to <var>prec</var>. |
|
2134 </p></blockquote></div> |
|
2135 |
|
2136 <div class="defun"> |
|
2137 — Function: int <b>mpfr_round_prec</b> (<var>mpfr_t x, mp_rnd_t rnd, mp_prec_t prec</var>)<var><a name="index-mpfr_005fround_005fprec-254"></a></var><br> |
|
2138 <blockquote><p>[This function is obsolete. Please use <code>mpfr_prec_round</code> instead.] |
|
2139 </p></blockquote></div> |
|
2140 |
|
2141 <div class="defun"> |
|
2142 — Function: const char * <b>mpfr_print_rnd_mode</b> (<var>mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fprint_005frnd_005fmode-255"></a></var><br> |
|
2143 <blockquote><p>Return the input string (GMP_RNDD, GMP_RNDU, GMP_RNDN, GMP_RNDZ) |
|
2144 corresponding to the rounding mode <var>rnd</var> or a null pointer if |
|
2145 <var>rnd</var> is an invalid rounding mode. |
|
2146 </p></blockquote></div> |
|
2147 |
|
2148 <div class="node"> |
|
2149 <p><hr> |
|
2150 <a name="Exception-Related-Functions"></a> |
|
2151 Next: <a rel="next" accesskey="n" href="#Advanced-Functions">Advanced Functions</a>, |
|
2152 Previous: <a rel="previous" accesskey="p" href="#Rounding-Mode-Related-Functions">Rounding Mode Related Functions</a>, |
|
2153 Up: <a rel="up" accesskey="u" href="#MPFR-Interface">MPFR Interface</a> |
|
2154 |
|
2155 </div> |
|
2156 |
|
2157 <!-- node-name, next, previous, up --> |
|
2158 <p><a name="index-Exception-related-functions-256"></a> |
|
2159 |
|
2160 <h3 class="section">5.12 Exception Related Functions</h3> |
|
2161 |
|
2162 <div class="defun"> |
|
2163 — Function: mp_exp_t <b>mpfr_get_emin</b> (<var>void</var>)<var><a name="index-mpfr_005fget_005femin-257"></a></var><br> |
|
2164 — Function: mp_exp_t <b>mpfr_get_emax</b> (<var>void</var>)<var><a name="index-mpfr_005fget_005femax-258"></a></var><br> |
|
2165 <blockquote><p>Return the (current) smallest and largest exponents allowed for a |
|
2166 floating-point variable. The smallest positive value of a floating-point |
|
2167 variable is one half times 2 raised to the |
|
2168 smallest exponent and the largest value has the form (1 - epsilon) times 2 raised to the largest exponent. |
|
2169 </p></blockquote></div> |
|
2170 |
|
2171 <div class="defun"> |
|
2172 — Function: int <b>mpfr_set_emin</b> (<var>mp_exp_t exp</var>)<var><a name="index-mpfr_005fset_005femin-259"></a></var><br> |
|
2173 — Function: int <b>mpfr_set_emax</b> (<var>mp_exp_t exp</var>)<var><a name="index-mpfr_005fset_005femax-260"></a></var><br> |
|
2174 <blockquote><p>Set the smallest and largest exponents allowed for a floating-point variable. |
|
2175 Return a non-zero value when <var>exp</var> is not in the range accepted by the |
|
2176 implementation (in that case the smallest or largest exponent is not changed), |
|
2177 and zero otherwise. |
|
2178 If the user changes the exponent range, it is her/his responsibility to check |
|
2179 that all current floating-point variables are in the new allowed range |
|
2180 (for example using <code>mpfr_check_range</code>), otherwise the subsequent |
|
2181 behavior will be undefined, in the sense of the ISO C standard. |
|
2182 <!-- It is also her/his responsibility to check that @m {emin <= emax}. --> |
|
2183 </p></blockquote></div> |
|
2184 |
|
2185 <div class="defun"> |
|
2186 — Function: mp_exp_t <b>mpfr_get_emin_min</b> (<var>void</var>)<var><a name="index-mpfr_005fget_005femin_005fmin-261"></a></var><br> |
|
2187 — Function: mp_exp_t <b>mpfr_get_emin_max</b> (<var>void</var>)<var><a name="index-mpfr_005fget_005femin_005fmax-262"></a></var><br> |
|
2188 — Function: mp_exp_t <b>mpfr_get_emax_min</b> (<var>void</var>)<var><a name="index-mpfr_005fget_005femax_005fmin-263"></a></var><br> |
|
2189 — Function: mp_exp_t <b>mpfr_get_emax_max</b> (<var>void</var>)<var><a name="index-mpfr_005fget_005femax_005fmax-264"></a></var><br> |
|
2190 <blockquote><p>Return the minimum and maximum of the smallest and largest exponents |
|
2191 allowed for <code>mpfr_set_emin</code> and <code>mpfr_set_emax</code>. These values |
|
2192 are implementation dependent; it is possible to create a non |
|
2193 portable program by writing <code>mpfr_set_emax(mpfr_get_emax_max())</code> |
|
2194 and <code>mpfr_set_emin(mpfr_get_emin_min())</code> since the values |
|
2195 of the smallest and largest exponents become implementation dependent. |
|
2196 </p></blockquote></div> |
|
2197 |
|
2198 <div class="defun"> |
|
2199 — Function: int <b>mpfr_check_range</b> (<var>mpfr_t x, int t, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fcheck_005frange-265"></a></var><br> |
|
2200 <blockquote><p>This function forces <var>x</var> to be in the current range of acceptable |
|
2201 values, <var>t</var> being the current ternary value: negative if <var>x</var> |
|
2202 is smaller than the exact value, positive if <var>x</var> is larger than |
|
2203 the exact value and zero if <var>x</var> is exact (before the call). It |
|
2204 generates an underflow or an overflow if the exponent of <var>x</var> is |
|
2205 outside the current allowed range; the value of <var>t</var> may be used |
|
2206 to avoid a double rounding. This function returns zero if the rounded |
|
2207 result is equal to the exact one, a positive value if the rounded |
|
2208 result is larger than the exact one, a negative value if the rounded |
|
2209 result is smaller than the exact one. Note that unlike most functions, |
|
2210 the result is compared to the exact one, not the input value <var>x</var>, |
|
2211 i.e. the ternary value is propagated. |
|
2212 |
|
2213 <p>Note: If <var>x</var> is an infinity and <var>t</var> is different from zero (i.e., |
|
2214 if the rounded result is an inexact infinity), then the overflow flag is |
|
2215 set. This is useful because <code>mpfr_check_range</code> is typically called |
|
2216 (at least in MPFR functions) after restoring the flags that could have |
|
2217 been set due to internal computations. |
|
2218 </p></blockquote></div> |
|
2219 |
|
2220 <div class="defun"> |
|
2221 — Function: int <b>mpfr_subnormalize</b> (<var>mpfr_t x, int t, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fsubnormalize-266"></a></var><br> |
|
2222 <blockquote><p>This function rounds <var>x</var> emulating subnormal number arithmetic: |
|
2223 if <var>x</var> is outside the subnormal exponent range, it just propagates the |
|
2224 ternary value <var>t</var>; otherwise, it rounds <var>x</var> to precision |
|
2225 <code>EXP(x)-emin+1</code> according to rounding mode <var>rnd</var> and previous |
|
2226 ternary value <var>t</var>, avoiding double rounding problems. |
|
2227 More precisely in the subnormal domain, denoting by <var>e</var> the value of |
|
2228 <code>emin</code>, <var>x</var> is rounded in fixed-point |
|
2229 arithmetic to an integer multiple of two to the power |
|
2230 <var>e</var>−1; as a consequence, 1.5 multiplied by two to the power <var>e</var>−1 when <var>t</var> is zero |
|
2231 is rounded to two to the power <var>e</var> with rounding to nearest. |
|
2232 |
|
2233 <p><code>PREC(x)</code> is not modified by this function. |
|
2234 <var>rnd</var> and <var>t</var> must be the used rounding mode for computing <var>x</var> |
|
2235 and the returned ternary value when computing <var>x</var>. |
|
2236 The subnormal exponent range is from <code>emin</code> to <code>emin+PREC(x)-1</code>. |
|
2237 If the result cannot be represented in the current exponent range |
|
2238 (due to a too small <code>emax</code>), the behavior is undefined. |
|
2239 Note that unlike most functions, the result is compared to the exact one, |
|
2240 not the input value <var>x</var>, i.e. the ternary value is propagated. |
|
2241 This is a preliminary interface. |
|
2242 </p></blockquote></div> |
|
2243 |
|
2244 <p>This is an example of how to emulate double IEEE-754 arithmetic |
|
2245 using MPFR: |
|
2246 |
|
2247 <pre class="example"> { |
|
2248 mpfr_t xa, xb; |
|
2249 int i; |
|
2250 volatile double a, b; |
|
2251 |
|
2252 mpfr_set_default_prec (53); |
|
2253 mpfr_set_emin (-1073); |
|
2254 mpfr_set_emax (1024); |
|
2255 |
|
2256 mpfr_init (xa); mpfr_init (xb); |
|
2257 |
|
2258 b = 34.3; mpfr_set_d (xb, b, GMP_RNDN); |
|
2259 a = 0x1.1235P-1021; mpfr_set_d (xa, a, GMP_RNDN); |
|
2260 |
|
2261 a /= b; |
|
2262 i = mpfr_div (xa, xa, xb, GMP_RNDN); |
|
2263 i = mpfr_subnormalize (xa, i, GMP_RNDN); |
|
2264 |
|
2265 mpfr_clear (xa); mpfr_clear (xb); |
|
2266 } |
|
2267 </pre> |
|
2268 <p>Warning: this emulates a double IEEE-754 arithmetic with correct rounding |
|
2269 in the subnormal range, which may not be the case for your hardware. |
|
2270 |
|
2271 <div class="defun"> |
|
2272 — Function: void <b>mpfr_clear_underflow</b> (<var>void</var>)<var><a name="index-mpfr_005fclear_005funderflow-267"></a></var><br> |
|
2273 — Function: void <b>mpfr_clear_overflow</b> (<var>void</var>)<var><a name="index-mpfr_005fclear_005foverflow-268"></a></var><br> |
|
2274 — Function: void <b>mpfr_clear_nanflag</b> (<var>void</var>)<var><a name="index-mpfr_005fclear_005fnanflag-269"></a></var><br> |
|
2275 — Function: void <b>mpfr_clear_inexflag</b> (<var>void</var>)<var><a name="index-mpfr_005fclear_005finexflag-270"></a></var><br> |
|
2276 — Function: void <b>mpfr_clear_erangeflag</b> (<var>void</var>)<var><a name="index-mpfr_005fclear_005ferangeflag-271"></a></var><br> |
|
2277 <blockquote><p>Clear the underflow, overflow, invalid, inexact and erange flags. |
|
2278 </p></blockquote></div> |
|
2279 |
|
2280 <div class="defun"> |
|
2281 — Function: void <b>mpfr_set_underflow</b> (<var>void</var>)<var><a name="index-mpfr_005fset_005funderflow-272"></a></var><br> |
|
2282 — Function: void <b>mpfr_set_overflow</b> (<var>void</var>)<var><a name="index-mpfr_005fset_005foverflow-273"></a></var><br> |
|
2283 — Function: void <b>mpfr_set_nanflag</b> (<var>void</var>)<var><a name="index-mpfr_005fset_005fnanflag-274"></a></var><br> |
|
2284 — Function: void <b>mpfr_set_inexflag</b> (<var>void</var>)<var><a name="index-mpfr_005fset_005finexflag-275"></a></var><br> |
|
2285 — Function: void <b>mpfr_set_erangeflag</b> (<var>void</var>)<var><a name="index-mpfr_005fset_005ferangeflag-276"></a></var><br> |
|
2286 <blockquote><p>Set the underflow, overflow, invalid, inexact and erange flags. |
|
2287 </p></blockquote></div> |
|
2288 |
|
2289 <div class="defun"> |
|
2290 — Function: void <b>mpfr_clear_flags</b> (<var>void</var>)<var><a name="index-mpfr_005fclear_005fflags-277"></a></var><br> |
|
2291 <blockquote><p>Clear all global flags (underflow, overflow, inexact, invalid, erange). |
|
2292 </p></blockquote></div> |
|
2293 |
|
2294 <div class="defun"> |
|
2295 — Function: int <b>mpfr_underflow_p</b> (<var>void</var>)<var><a name="index-mpfr_005funderflow_005fp-278"></a></var><br> |
|
2296 — Function: int <b>mpfr_overflow_p</b> (<var>void</var>)<var><a name="index-mpfr_005foverflow_005fp-279"></a></var><br> |
|
2297 — Function: int <b>mpfr_nanflag_p</b> (<var>void</var>)<var><a name="index-mpfr_005fnanflag_005fp-280"></a></var><br> |
|
2298 — Function: int <b>mpfr_inexflag_p</b> (<var>void</var>)<var><a name="index-mpfr_005finexflag_005fp-281"></a></var><br> |
|
2299 — Function: int <b>mpfr_erangeflag_p</b> (<var>void</var>)<var><a name="index-mpfr_005ferangeflag_005fp-282"></a></var><br> |
|
2300 <blockquote><p>Return the corresponding (underflow, overflow, invalid, inexact, erange) |
|
2301 flag, which is non-zero iff the flag is set. |
|
2302 </p></blockquote></div> |
|
2303 |
|
2304 <div class="node"> |
|
2305 <p><hr> |
|
2306 <a name="Advanced-Functions"></a> |
|
2307 Next: <a rel="next" accesskey="n" href="#Compatibility-with-MPF">Compatibility with MPF</a>, |
|
2308 Previous: <a rel="previous" accesskey="p" href="#Exception-Related-Functions">Exception Related Functions</a>, |
|
2309 Up: <a rel="up" accesskey="u" href="#MPFR-Interface">MPFR Interface</a> |
|
2310 |
|
2311 </div> |
|
2312 |
|
2313 <!-- node-name, next, previous, up --> |
|
2314 <p><a name="index-Advanced-functions-283"></a> |
|
2315 |
|
2316 <h3 class="section">5.13 Advanced Functions</h3> |
|
2317 |
|
2318 <p>All the given interfaces are preliminary. They might change incompatibly in |
|
2319 future revisions. |
|
2320 |
|
2321 <div class="defun"> |
|
2322 — Macro: <b>MPFR_DECL_INIT</b> (<var>name, prec</var>)<var><a name="index-MPFR_005fDECL_005fINIT-284"></a></var><br> |
|
2323 <blockquote><p>This macro declares <var>name</var> as an automatic variable of type <code>mpfr_t</code>, |
|
2324 initializes it and sets its precision to be <strong>exactly</strong> <var>prec</var> bits |
|
2325 and its value to NaN. <var>name</var> must be a valid identifier. |
|
2326 You must use this macro in the declaration section. |
|
2327 This macro is much faster than using <code>mpfr_init2</code> but has some |
|
2328 drawbacks: |
|
2329 |
|
2330 <ul> |
|
2331 <li>You <strong>must not</strong> call <code>mpfr_clear</code> with variables |
|
2332 created with this macro (The storage is allocated at the point of declaration |
|
2333 and deallocated when the brace-level is exited.). |
|
2334 <li>You <strong>can not</strong> change their precision. |
|
2335 <li>You <strong>should not</strong> create variables with huge precision with this macro. |
|
2336 <li>Your compiler must support ‘<samp><span class="samp">Non-Constant Initializers</span></samp>’ (standard |
|
2337 in C++ and ISO C99) and ‘<samp><span class="samp">Token Pasting</span></samp>’ |
|
2338 (standard in ISO C89). If <var>prec</var> is not a compiler constant, your compiler |
|
2339 must support ‘<samp><span class="samp">Variable-length automatic arrays</span></samp>’ (standard in ISO C99). |
|
2340 ‘<samp><span class="samp">GCC 2.95.3</span></samp>’ supports all these features. If you compile your program |
|
2341 with gcc in c89 mode and with ‘<samp><span class="samp">-pedantic</span></samp>’, you may want to define the |
|
2342 <code>MPFR_USE_EXTENSION</code> macro to avoid warnings due to the |
|
2343 <code>MPFR_DECL_INIT</code> implementation. |
|
2344 </ul> |
|
2345 </p></blockquote></div> |
|
2346 |
|
2347 <div class="defun"> |
|
2348 — Function: void <b>mpfr_inits</b> (<var>mpfr_t x, ...</var>)<var><a name="index-mpfr_005finits-285"></a></var><br> |
|
2349 <blockquote><p>Initialize all the <code>mpfr_t</code> variables of the given <code>va_list</code>, |
|
2350 set their precision to be the default precision and their value to NaN. |
|
2351 See <code>mpfr_init</code> for more details. |
|
2352 The <code>va_list</code> is assumed to be composed only of type <code>mpfr_t</code> |
|
2353 (or equivalently <code>mpfr_ptr</code>). |
|
2354 It begins from <var>x</var>. It ends when it encounters a null pointer (whose |
|
2355 type must also be <code>mpfr_ptr</code>). |
|
2356 </p></blockquote></div> |
|
2357 |
|
2358 <div class="defun"> |
|
2359 — Function: void <b>mpfr_inits2</b> (<var>mp_prec_t prec, mpfr_t x, ...</var>)<var><a name="index-mpfr_005finits2-286"></a></var><br> |
|
2360 <blockquote><p>Initialize all the <code>mpfr_t</code> variables of the given <code>va_list</code>, |
|
2361 set their precision to be <strong>exactly</strong> |
|
2362 <var>prec</var> bits and their value to NaN. |
|
2363 See <code>mpfr_init2</code> for more details. |
|
2364 The <code>va_list</code> is assumed to be composed only of type <code>mpfr_t</code> |
|
2365 (or equivalently <code>mpfr_ptr</code>). |
|
2366 It begins from <var>x</var>. It ends when it encounters a null pointer (whose |
|
2367 type must also be <code>mpfr_ptr</code>). |
|
2368 </p></blockquote></div> |
|
2369 |
|
2370 <div class="defun"> |
|
2371 — Function: void <b>mpfr_clears</b> (<var>mpfr_t x, ...</var>)<var><a name="index-mpfr_005fclears-287"></a></var><br> |
|
2372 <blockquote><p>Free the space occupied by all the <code>mpfr_t</code> variables of the given |
|
2373 <code>va_list</code>. See <code>mpfr_clear</code> for more details. |
|
2374 The <code>va_list</code> is assumed to be composed only of type <code>mpfr_t</code> |
|
2375 (or equivalently <code>mpfr_ptr</code>). |
|
2376 It begins from <var>x</var>. It ends when it encounters a null pointer (whose |
|
2377 type must also be <code>mpfr_ptr</code>). |
|
2378 </p></blockquote></div> |
|
2379 |
|
2380 <p>Here is an example of how to use multiple initialization functions: |
|
2381 |
|
2382 <pre class="example"> { |
|
2383 mpfr_t x, y, z, t; |
|
2384 mpfr_inits2 (256, x, y, z, t, (mpfr_ptr) 0); |
|
2385 ... |
|
2386 mpfr_clears (x, y, z, t, (mpfr_ptr) 0); |
|
2387 } |
|
2388 </pre> |
|
2389 <div class="node"> |
|
2390 <p><hr> |
|
2391 <a name="Compatibility-with-MPF"></a> |
|
2392 Next: <a rel="next" accesskey="n" href="#Custom-Interface">Custom Interface</a>, |
|
2393 Previous: <a rel="previous" accesskey="p" href="#Advanced-Functions">Advanced Functions</a>, |
|
2394 Up: <a rel="up" accesskey="u" href="#MPFR-Interface">MPFR Interface</a> |
|
2395 |
|
2396 </div> |
|
2397 |
|
2398 <p><a name="index-Compatibility-with-MPF-288"></a> |
|
2399 |
|
2400 <h3 class="section">5.14 Compatibility With MPF</h3> |
|
2401 |
|
2402 <p>A header file <samp><span class="file">mpf2mpfr.h</span></samp> is included in the distribution of MPFR for |
|
2403 compatibility with the GNU MP class MPF. |
|
2404 After inserting the following two lines after the <code>#include <gmp.h></code> |
|
2405 line, |
|
2406 <pre class="verbatim"> |
|
2407 #include <mpfr.h> |
|
2408 #include <mpf2mpfr.h> |
|
2409 </pre> |
|
2410 any program written for |
|
2411 MPF can be compiled directly with MPFR without any changes. |
|
2412 All operations are then performed with the default MPFR rounding mode, |
|
2413 which can be reset with <code>mpfr_set_default_rounding_mode</code>. |
|
2414 |
|
2415 <p>Warning: the <code>mpf_init</code> and <code>mpf_init2</code> functions initialize |
|
2416 to zero, whereas the corresponding MPFR functions initialize to NaN: |
|
2417 this is useful to detect uninitialized values, but is slightly incompatible |
|
2418 with <code>mpf</code>. |
|
2419 |
|
2420 <div class="defun"> |
|
2421 — Function: void <b>mpfr_set_prec_raw</b> (<var>mpfr_t x, mp_prec_t prec</var>)<var><a name="index-mpfr_005fset_005fprec_005fraw-289"></a></var><br> |
|
2422 <blockquote><p>Reset the precision of <var>x</var> to be <strong>exactly</strong> <var>prec</var> bits. |
|
2423 The only difference with <code>mpfr_set_prec</code> is that <var>prec</var> is assumed to |
|
2424 be small enough so that the significand fits into the current allocated memory |
|
2425 space for <var>x</var>. Otherwise the behavior is undefined. |
|
2426 </p></blockquote></div> |
|
2427 |
|
2428 <div class="defun"> |
|
2429 — Function: int <b>mpfr_eq</b> (<var>mpfr_t op1, mpfr_t op2, unsigned long int op3</var>)<var><a name="index-mpfr_005feq-290"></a></var><br> |
|
2430 <blockquote><p>Return non-zero if <var>op1</var> and <var>op2</var> are both non-zero ordinary |
|
2431 numbers with the same exponent and the same first <var>op3</var> bits, both |
|
2432 zero, or both infinities of the same sign. Return zero otherwise. This |
|
2433 function is defined for compatibility with <code>mpf</code>. Do not use it if |
|
2434 you want to know whether two numbers are close to each other; for instance, |
|
2435 1.011111 and 1.100000 are regarded as different for any value of <var>op3</var> |
|
2436 larger than 1. |
|
2437 </p></blockquote></div> |
|
2438 |
|
2439 <div class="defun"> |
|
2440 — Function: void <b>mpfr_reldiff</b> (<var>mpfr_t rop, mpfr_t op1, mpfr_t op2, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005freldiff-291"></a></var><br> |
|
2441 <blockquote><p>Compute the relative difference between <var>op1</var> and <var>op2</var> |
|
2442 and store the result in <var>rop</var>. |
|
2443 This function does not guarantee the correct rounding on the relative |
|
2444 difference; it just computes |<var>op1</var>-<var>op2</var>|/<var>op1</var>, using the |
|
2445 rounding mode <var>rnd</var> for all operations and the precision of <var>rop</var>. |
|
2446 </p></blockquote></div> |
|
2447 |
|
2448 <div class="defun"> |
|
2449 — Function: int <b>mpfr_mul_2exp</b> (<var>mpfr_t rop, mpfr_t op1, unsigned long int op2, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fmul_005f2exp-292"></a></var><br> |
|
2450 — Function: int <b>mpfr_div_2exp</b> (<var>mpfr_t rop, mpfr_t op1, unsigned long int op2, mp_rnd_t rnd</var>)<var><a name="index-mpfr_005fdiv_005f2exp-293"></a></var><br> |
|
2451 <blockquote><p>See <code>mpfr_mul_2ui</code> and <code>mpfr_div_2ui</code>. These functions are only kept |
|
2452 for compatibility with MPF. |
|
2453 </p></blockquote></div> |
|
2454 |
|
2455 <div class="node"> |
|
2456 <p><hr> |
|
2457 <a name="Custom-Interface"></a> |
|
2458 Next: <a rel="next" accesskey="n" href="#Internals">Internals</a>, |
|
2459 Previous: <a rel="previous" accesskey="p" href="#Compatibility-with-MPF">Compatibility with MPF</a>, |
|
2460 Up: <a rel="up" accesskey="u" href="#MPFR-Interface">MPFR Interface</a> |
|
2461 |
|
2462 </div> |
|
2463 |
|
2464 <p><a name="index-Custom-interface-294"></a> |
|
2465 |
|
2466 <h3 class="section">5.15 Custom Interface</h3> |
|
2467 |
|
2468 <p>Some applications use a stack to handle the memory and their objects. |
|
2469 However, the MPFR memory design is not well suited for such a thing. So that |
|
2470 such applications are able to use MPFR, an auxiliary memory interface has |
|
2471 been created: the Custom Interface. |
|
2472 |
|
2473 <p>The following interface allows them to use MPFR in two ways: |
|
2474 <ul> |
|
2475 <li>Either they directly store the MPFR FP number as a <code>mpfr_t</code> |
|
2476 on the stack. |
|
2477 <li>Either they store their own representation of a FP number on the |
|
2478 stack and construct a new temporary <code>mpfr_t</code> each time it is needed. |
|
2479 </ul> |
|
2480 Nothing has to be done to destroy the FP numbers except garbaging the used |
|
2481 memory: all the memory stuff (allocating, destroying, garbaging) is kept to |
|
2482 the application. |
|
2483 |
|
2484 <p>Each function in this interface is also implemented as a macro for |
|
2485 efficiency reasons: for example <code>mpfr_custom_init (s, p)</code> |
|
2486 uses the macro, while <code>(mpfr_custom_init) (s, p)</code> uses the function. |
|
2487 |
|
2488 <p>Note 1: MPFR functions may still initialize temporary FP numbers |
|
2489 using standard mpfr_init. See Custom Allocation (GNU MP). |
|
2490 |
|
2491 <p>Note 2: MPFR functions may use the cached functions (mpfr_const_pi for |
|
2492 example), even if they are not explicitly called. You have to call |
|
2493 <code>mpfr_free_cache</code> each time you garbage the memory iff mpfr_init, through |
|
2494 GMP Custom Allocation, allocates its memory on the application stack. |
|
2495 |
|
2496 <p>Note 3: This interface is preliminary. |
|
2497 |
|
2498 <div class="defun"> |
|
2499 — Function: size_t <b>mpfr_custom_get_size</b> (<var>mp_prec_t prec</var>)<var><a name="index-mpfr_005fcustom_005fget_005fsize-295"></a></var><br> |
|
2500 <blockquote><p>Return the needed size in bytes to store the significand of a FP number |
|
2501 of precision <var>prec</var>. |
|
2502 </p></blockquote></div> |
|
2503 |
|
2504 <div class="defun"> |
|
2505 — Function: void <b>mpfr_custom_init</b> (<var>void *significand, mp_prec_t prec</var>)<var><a name="index-mpfr_005fcustom_005finit-296"></a></var><br> |
|
2506 <blockquote><p>Initialize a significand of precision <var>prec</var>. |
|
2507 <var>significand</var> must be an area of <code>mpfr_custom_get_size (prec)</code> bytes |
|
2508 at least and be suitably aligned for an array of <code>mp_limb_t</code>. |
|
2509 </p></blockquote></div> |
|
2510 |
|
2511 <div class="defun"> |
|
2512 — Function: void <b>mpfr_custom_init_set</b> (<var>mpfr_t x, int kind, mp_exp_t exp, mp_prec_t prec, void *significand</var>)<var><a name="index-mpfr_005fcustom_005finit_005fset-297"></a></var><br> |
|
2513 <blockquote><p>Perform a dummy initialization of a <code>mpfr_t</code> and set it to: |
|
2514 <ul> |
|
2515 <li>if <code>ABS(kind) == MPFR_NAN_KIND</code>, <var>x</var> is set to NaN; |
|
2516 <li>if <code>ABS(kind) == MPFR_INF_KIND</code>, <var>x</var> is set to the infinity |
|
2517 of sign <code>sign(kind)</code>; |
|
2518 <li>if <code>ABS(kind) == MPFR_ZERO_KIND</code>, <var>x</var> is set to the zero of |
|
2519 sign <code>sign(kind)</code>; |
|
2520 <li>if <code>ABS(kind) == MPFR_REGULAR_KIND</code>, <var>x</var> is set to a regular |
|
2521 number: <code>x = sign(kind)*significand*2^exp</code> |
|
2522 </ul> |
|
2523 In all cases, it uses <var>significand</var> directly for further computing |
|
2524 involving <var>x</var>. It will not allocate anything. |
|
2525 A FP number initialized with this function cannot be resized using |
|
2526 <code>mpfr_set_prec</code>, or cleared using <code>mpfr_clear</code>! |
|
2527 <var>significand</var> must have been initialized with <code>mpfr_custom_init</code> |
|
2528 using the same precision <var>prec</var>. |
|
2529 </p></blockquote></div> |
|
2530 |
|
2531 <div class="defun"> |
|
2532 — Function: int <b>mpfr_custom_get_kind</b> (<var>mpfr_t x</var>)<var><a name="index-mpfr_005fcustom_005fget_005fkind-298"></a></var><br> |
|
2533 <blockquote><p>Return the current kind of a <code>mpfr_t</code> as used by |
|
2534 <code>mpfr_custom_init_set</code>. |
|
2535 The behavior of this function for any <code>mpfr_t</code> not initialized |
|
2536 with <code>mpfr_custom_init_set</code> is undefined. |
|
2537 </p></blockquote></div> |
|
2538 |
|
2539 <div class="defun"> |
|
2540 — Function: void * <b>mpfr_custom_get_mantissa</b> (<var>mpfr_t x</var>)<var><a name="index-mpfr_005fcustom_005fget_005fmantissa-299"></a></var><br> |
|
2541 <blockquote><p>Return a pointer to the significand used by a <code>mpfr_t</code> initialized with |
|
2542 <code>mpfr_custom_init_set</code>. |
|
2543 The behavior of this function for any <code>mpfr_t</code> not initialized |
|
2544 with <code>mpfr_custom_init_set</code> is undefined. |
|
2545 </p></blockquote></div> |
|
2546 |
|
2547 <div class="defun"> |
|
2548 — Function: mp_exp_t <b>mpfr_custom_get_exp</b> (<var>mpfr_t x</var>)<var><a name="index-mpfr_005fcustom_005fget_005fexp-300"></a></var><br> |
|
2549 <blockquote><p>Return the exponent of <var>x</var>, assuming that <var>x</var> is a non-zero ordinary |
|
2550 number. The return value for NaN, Infinity or Zero is unspecified but doesn't |
|
2551 produce any trap. |
|
2552 The behavior of this function for any <code>mpfr_t</code> not initialized |
|
2553 with <code>mpfr_custom_init_set</code> is undefined. |
|
2554 </p></blockquote></div> |
|
2555 |
|
2556 <div class="defun"> |
|
2557 — Function: void <b>mpfr_custom_move</b> (<var>mpfr_t x, void *new_position</var>)<var><a name="index-mpfr_005fcustom_005fmove-301"></a></var><br> |
|
2558 <blockquote><p>Inform MPFR that the significand has moved due to a garbage collect |
|
2559 and update its new position to <code>new_position</code>. |
|
2560 However the application has to move the significand and the <code>mpfr_t</code> |
|
2561 itself. |
|
2562 The behavior of this function for any <code>mpfr_t</code> not initialized |
|
2563 with <code>mpfr_custom_init_set</code> is undefined. |
|
2564 </p></blockquote></div> |
|
2565 |
|
2566 <p>See the test suite for examples. |
|
2567 |
|
2568 <div class="node"> |
|
2569 <p><hr> |
|
2570 <a name="Internals"></a> |
|
2571 Previous: <a rel="previous" accesskey="p" href="#Custom-Interface">Custom Interface</a>, |
|
2572 Up: <a rel="up" accesskey="u" href="#MPFR-Interface">MPFR Interface</a> |
|
2573 |
|
2574 </div> |
|
2575 |
|
2576 <p><a name="index-Internals-302"></a> |
|
2577 |
|
2578 <h3 class="section">5.16 Internals</h3> |
|
2579 |
|
2580 <p>The following types and |
|
2581 functions were mainly designed for the implementation of MPFR, |
|
2582 but may be useful for users too. |
|
2583 However no upward compatibility is guaranteed. |
|
2584 You may need to include <samp><span class="file">mpfr-impl.h</span></samp> to use them. |
|
2585 |
|
2586 <p>The <code>mpfr_t</code> type consists of four fields. |
|
2587 |
|
2588 <ul> |
|
2589 <li>The <code>_mpfr_prec</code> field is used to store the precision of |
|
2590 the variable (in bits); this is not less than <code>MPFR_PREC_MIN</code>. |
|
2591 |
|
2592 <li>The <code>_mpfr_sign</code> field is used to store the sign of the variable. |
|
2593 |
|
2594 <li>The <code>_mpfr_exp</code> field stores the exponent. |
|
2595 An exponent of 0 means a radix point just above the most significant |
|
2596 limb. Non-zero values n are a multiplier 2^n relative to that |
|
2597 point. |
|
2598 A NaN, an infinity and a zero are indicated by a special value of the exponent. |
|
2599 |
|
2600 <li>Finally, the <code>_mpfr_d</code> is a pointer to the limbs, least |
|
2601 significant limbs stored first. |
|
2602 The number of limbs in use is controlled by <code>_mpfr_prec</code>, namely |
|
2603 ceil(<code>_mpfr_prec</code>/<code>mp_bits_per_limb</code>). |
|
2604 Non-singular values always have the most significant bit of the most |
|
2605 significant limb set to 1. When the precision does not correspond to a |
|
2606 whole number of limbs, the excess bits at the low end of the data are zero. |
|
2607 |
|
2608 </ul> |
|
2609 |
|
2610 <!-- @deftypefun int mpfr_add_one_ulp (mpfr_t @var{x}, mp_rnd_t @var{rnd}) --> |
|
2611 <!-- Add one unit in last place (ulp) to @var{x} if @var{x} is finite --> |
|
2612 <!-- and positive, subtract one ulp if @var{x} is finite and negative; --> |
|
2613 <!-- otherwise, @var{x} is not changed. --> |
|
2614 <!-- The return value is zero unless an overflow occurs, in which case the --> |
|
2615 <!-- @code{mpfr_add_one_ulp} function behaves like a conventional addition. --> |
|
2616 <!-- @end deftypefun --> |
|
2617 <!-- @deftypefun int mpfr_sub_one_ulp (mpfr_t @var{x}, mp_rnd_t @var{rnd}) --> |
|
2618 <!-- Subtract one ulp to @var{x} if @var{x} is finite and positive, add one --> |
|
2619 <!-- ulp if @var{x} is finite and negative; otherwise, @var{x} is not changed. --> |
|
2620 <!-- The return value is zero unless an underflow occurs, in which case the --> |
|
2621 <!-- @code{mpfr_sub_one_ulp} function behaves like a conventional subtraction. --> |
|
2622 <!-- @end deftypefun --> |
|
2623 <div class="defun"> |
|
2624 — Function: int <b>mpfr_can_round</b> (<var>mpfr_t b, mp_exp_t err, mp_rnd_t rnd1, mp_rnd_t rnd2, mp_prec_t prec</var>)<var><a name="index-mpfr_005fcan_005fround-303"></a></var><br> |
|
2625 <blockquote><p>Assuming <var>b</var> is an approximation of an unknown number |
|
2626 <var>x</var> in the direction <var>rnd1</var> with error at most two to the power |
|
2627 E(b)-<var>err</var> where E(b) is the exponent of <var>b</var>, return a non-zero |
|
2628 value if one is able to round correctly <var>x</var> to precision |
|
2629 <var>prec</var> with the direction <var>rnd2</var>, |
|
2630 and 0 otherwise (including for NaN and Inf). |
|
2631 This function <strong>does not modify</strong> its arguments. |
|
2632 |
|
2633 <p>Note: if one wants to also determine the correct ternary value when rounding |
|
2634 <var>b</var> to precision <var>prec</var>, a useful trick is the following: |
|
2635 <pre class="verbatim"> |
|
2636 if (mpfr_can_round (b, err, rnd1, GMP_RNDZ, prec + (rnd2 == GMP_RNDN))) |
|
2637 ... |
|
2638 </pre> |
|
2639 Indeed, if <var>rnd2</var> is <code>GMP_RNDN</code>, this will check if one can |
|
2640 round to <var>prec</var>+1 bits with a directed rounding: |
|
2641 if so, one can surely round to nearest to <var>prec</var> bits, |
|
2642 and in addition one can determine the correct ternary value, which would not |
|
2643 be the case when <var>b</var> is near from a value exactly representable on |
|
2644 <var>prec</var> bits. |
|
2645 </p></blockquote></div> |
|
2646 |
|
2647 <div class="defun"> |
|
2648 — Function: double <b>mpfr_get_d1</b> (<var>mpfr_t op</var>)<var><a name="index-mpfr_005fget_005fd1-304"></a></var><br> |
|
2649 <blockquote><p>Convert <var>op</var> to a <code>double</code>, using the default MPFR rounding mode |
|
2650 (see function <code>mpfr_set_default_rounding_mode</code>). This function is |
|
2651 obsolete. |
|
2652 </p></blockquote></div> |
|
2653 |
|
2654 <!-- @deftypefun void mpfr_set_str_binary (mpfr_t @var{x}, const char *@var{s}) --> |
|
2655 <!-- Set @var{x} to the value of the binary number in string @var{s}, which has to --> |
|
2656 <!-- be of the --> |
|
2657 <!-- form +/-xxxx.xxxxxxEyy. The exponent is read in decimal, but is interpreted --> |
|
2658 <!-- as the power of two to be multiplied by the significand. --> |
|
2659 <!-- The significand length of @var{s} has to be less or equal to the precision --> |
|
2660 <!-- of @var{x}, otherwise an error occurs. --> |
|
2661 <!-- If @var{s} starts with @code{N}, it is interpreted as NaN (Not-a-Number); --> |
|
2662 <!-- if it starts with @code{I} after the sign, it is interpreted as infinity, --> |
|
2663 <!-- with the corresponding sign. --> |
|
2664 <!-- @end deftypefun --> |
|
2665 <!-- @deftypefun void mpfr_print_binary (mpfr_t @var{float}) --> |
|
2666 <!-- Output @var{float} on stdout --> |
|
2667 <!-- in raw binary format (the exponent is written in decimal, yet). --> |
|
2668 <!-- @end deftypefun --> |
|
2669 <div class="node"> |
|
2670 <p><hr> |
|
2671 <a name="Contributors"></a> |
|
2672 Next: <a rel="next" accesskey="n" href="#References">References</a>, |
|
2673 Previous: <a rel="previous" accesskey="p" href="#MPFR-Interface">MPFR Interface</a>, |
|
2674 Up: <a rel="up" accesskey="u" href="#Top">Top</a> |
|
2675 |
|
2676 </div> |
|
2677 |
|
2678 <!-- node-name, next, previous, up --> |
|
2679 <h2 class="unnumbered">Contributors</h2> |
|
2680 |
|
2681 <p>The main developers of MPFR are Guillaume Hanrot, Vincent Lefèvre, |
|
2682 Patrick Pélissier, Philippe Théveny and Paul Zimmermann. |
|
2683 |
|
2684 <p>Sylvie Boldo from ENS-Lyon, France, |
|
2685 contributed the functions <code>mpfr_agm</code> and <code>mpfr_log</code>. |
|
2686 Emmanuel Jeandel, from ENS-Lyon too, |
|
2687 contributed the generic hypergeometric code in |
|
2688 <code>generic.c</code>, as well as the <code>mpfr_exp3</code>, |
|
2689 a first implementation of the sine and cosine, |
|
2690 and improved versions of |
|
2691 <code>mpfr_const_log2</code> and <code>mpfr_const_pi</code>. |
|
2692 Mathieu Dutour contributed the functions <code>mpfr_atan</code> and <code>mpfr_asin</code>, |
|
2693 and a previous version of <code>mpfr_gamma</code>; |
|
2694 David Daney contributed the hyperbolic and inverse hyperbolic functions, |
|
2695 the base-2 exponential, and the factorial function. Fabrice Rouillier |
|
2696 contributed the original version of <samp><span class="file">mul_ui.c</span></samp>, the <samp><span class="file">gmp_op.c</span></samp> |
|
2697 file, and helped to the Microsoft Windows porting. |
|
2698 Jean-Luc Rémy contributed the <code>mpfr_zeta</code> code. |
|
2699 Ludovic Meunier helped in the design of the <code>mpfr_erf</code> code. |
|
2700 Damien Stehlé contributed the <code>mpfr_get_ld_2exp</code> function. |
|
2701 |
|
2702 <p>We would like to thank Jean-Michel Muller and Joris van der Hoeven for very |
|
2703 fruitful discussions at the beginning of that project, Torbjörn Granlund |
|
2704 and Kevin Ryde for their help about design issues, |
|
2705 and Nathalie Revol for her careful reading of a previous version of |
|
2706 this documentation. |
|
2707 Kevin Ryde did a tremendous job for the portability of MPFR in 2002-2004. |
|
2708 |
|
2709 <p>The development of the MPFR library would not have been possible without |
|
2710 the continuous support of INRIA, and of the LORIA (Nancy, France) and LIP |
|
2711 (Lyon, France) laboratories. In particular the main authors were or are |
|
2712 members of the PolKA, Spaces, Cacao project-teams at LORIA and of the |
|
2713 Arenaire project-team at LIP. |
|
2714 This project was started during the Fiable (reliable in French) action |
|
2715 supported by INRIA, and continued during the AOC action. |
|
2716 The development of MPFR was also supported by a grant |
|
2717 (202F0659 00 MPN 121) from the Conseil Régional de Lorraine in 2002, |
|
2718 and from INRIA by an "associate engineer" grant (2003-2005) |
|
2719 and an "opération de développement logiciel" grant (2007-2009). |
|
2720 |
|
2721 <div class="node"> |
|
2722 <p><hr> |
|
2723 <a name="References"></a> |
|
2724 Next: <a rel="next" accesskey="n" href="#GNU-Free-Documentation-License">GNU Free Documentation License</a>, |
|
2725 Previous: <a rel="previous" accesskey="p" href="#Contributors">Contributors</a>, |
|
2726 Up: <a rel="up" accesskey="u" href="#Top">Top</a> |
|
2727 |
|
2728 </div> |
|
2729 |
|
2730 <!-- node-name, next, previous, up --> |
|
2731 <h2 class="unnumbered">References</h2> |
|
2732 |
|
2733 <ul> |
|
2734 <li>Laurent Fousse, Guillaume Hanrot, Vincent Lefèvre, |
|
2735 Patrick Pélissier and Paul Zimmermann, |
|
2736 "MPFR: A Multiple-Precision Binary Floating-Point Library With Correct Rounding", |
|
2737 ACM Transactions on Mathematical Software, |
|
2738 volume 33, issue 2, article 13, 15 pages, 2007, |
|
2739 <a href="http://doi.acm.org/10.1145/1236463.1236468">http://doi.acm.org/10.1145/1236463.1236468</a>. |
|
2740 |
|
2741 <li>Torbjörn Granlund, "GNU MP: The GNU Multiple Precision Arithmetic Library", |
|
2742 version 4.2.2, 2007, <a href="http://gmplib.org">http://gmplib.org</a>. |
|
2743 |
|
2744 <li>IEEE standard for binary floating-point arithmetic, Technical Report |
|
2745 ANSI-IEEE Standard 754-1985, New York, 1985. |
|
2746 Approved March 21, 1985: IEEE Standards Board; approved July 26, |
|
2747 1985: American National Standards Institute, 18 pages. |
|
2748 |
|
2749 <li>Donald E. Knuth, "The Art of Computer Programming", vol 2, |
|
2750 "Seminumerical Algorithms", 2nd edition, Addison-Wesley, 1981. |
|
2751 |
|
2752 <li>Jean-Michel Muller, "Elementary Functions, Algorithms and Implementation", |
|
2753 Birkhauser, Boston, 2nd edition, 2006. |
|
2754 |
|
2755 </ul> |
|
2756 |
|
2757 <div class="node"> |
|
2758 <p><hr> |
|
2759 <a name="GNU-Free-Documentation-License"></a> |
|
2760 Next: <a rel="next" accesskey="n" href="#Concept-Index">Concept Index</a>, |
|
2761 Previous: <a rel="previous" accesskey="p" href="#References">References</a>, |
|
2762 Up: <a rel="up" accesskey="u" href="#Top">Top</a> |
|
2763 |
|
2764 </div> |
|
2765 |
|
2766 <h2 class="appendix">Appendix A GNU Free Documentation License</h2> |
|
2767 |
|
2768 <p><a name="index-GNU-Free-Documentation-License-305"></a> |
|
2769 |
|
2770 <!-- MPFR tweak: Have this in mpfr.texi to help texinfo-mode --> |
|
2771 <!-- @node GNU Free Documentation License --> |
|
2772 <!-- @appendixsec GNU Free Documentation License --> |
|
2773 <p><a name="index-FDL_002c-GNU-Free-Documentation-License-306"></a><div align="center">Version 1.2, November 2002</div> |
|
2774 |
|
2775 <pre class="display"> Copyright © 2000,2001,2002 Free Software Foundation, Inc. |
|
2776 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA |
|
2777 |
|
2778 Everyone is permitted to copy and distribute verbatim copies |
|
2779 of this license document, but changing it is not allowed. |
|
2780 </pre> |
|
2781 <ol type=1 start=0> |
|
2782 <li>PREAMBLE |
|
2783 |
|
2784 <p>The purpose of this License is to make a manual, textbook, or other |
|
2785 functional and useful document <dfn>free</dfn> in the sense of freedom: to |
|
2786 assure everyone the effective freedom to copy and redistribute it, |
|
2787 with or without modifying it, either commercially or noncommercially. |
|
2788 Secondarily, this License preserves for the author and publisher a way |
|
2789 to get credit for their work, while not being considered responsible |
|
2790 for modifications made by others. |
|
2791 |
|
2792 <p>This License is a kind of “copyleft”, which means that derivative |
|
2793 works of the document must themselves be free in the same sense. It |
|
2794 complements the GNU General Public License, which is a copyleft |
|
2795 license designed for free software. |
|
2796 |
|
2797 <p>We have designed this License in order to use it for manuals for free |
|
2798 software, because free software needs free documentation: a free |
|
2799 program should come with manuals providing the same freedoms that the |
|
2800 software does. But this License is not limited to software manuals; |
|
2801 it can be used for any textual work, regardless of subject matter or |
|
2802 whether it is published as a printed book. We recommend this License |
|
2803 principally for works whose purpose is instruction or reference. |
|
2804 |
|
2805 <li>APPLICABILITY AND DEFINITIONS |
|
2806 |
|
2807 <p>This License applies to any manual or other work, in any medium, that |
|
2808 contains a notice placed by the copyright holder saying it can be |
|
2809 distributed under the terms of this License. Such a notice grants a |
|
2810 world-wide, royalty-free license, unlimited in duration, to use that |
|
2811 work under the conditions stated herein. The “Document”, below, |
|
2812 refers to any such manual or work. Any member of the public is a |
|
2813 licensee, and is addressed as “you”. You accept the license if you |
|
2814 copy, modify or distribute the work in a way requiring permission |
|
2815 under copyright law. |
|
2816 |
|
2817 <p>A “Modified Version” of the Document means any work containing the |
|
2818 Document or a portion of it, either copied verbatim, or with |
|
2819 modifications and/or translated into another language. |
|
2820 |
|
2821 <p>A “Secondary Section” is a named appendix or a front-matter section |
|
2822 of the Document that deals exclusively with the relationship of the |
|
2823 publishers or authors of the Document to the Document's overall |
|
2824 subject (or to related matters) and contains nothing that could fall |
|
2825 directly within that overall subject. (Thus, if the Document is in |
|
2826 part a textbook of mathematics, a Secondary Section may not explain |
|
2827 any mathematics.) The relationship could be a matter of historical |
|
2828 connection with the subject or with related matters, or of legal, |
|
2829 commercial, philosophical, ethical or political position regarding |
|
2830 them. |
|
2831 |
|
2832 <p>The “Invariant Sections” are certain Secondary Sections whose titles |
|
2833 are designated, as being those of Invariant Sections, in the notice |
|
2834 that says that the Document is released under this License. If a |
|
2835 section does not fit the above definition of Secondary then it is not |
|
2836 allowed to be designated as Invariant. The Document may contain zero |
|
2837 Invariant Sections. If the Document does not identify any Invariant |
|
2838 Sections then there are none. |
|
2839 |
|
2840 <p>The “Cover Texts” are certain short passages of text that are listed, |
|
2841 as Front-Cover Texts or Back-Cover Texts, in the notice that says that |
|
2842 the Document is released under this License. A Front-Cover Text may |
|
2843 be at most 5 words, and a Back-Cover Text may be at most 25 words. |
|
2844 |
|
2845 <p>A “Transparent” copy of the Document means a machine-readable copy, |
|
2846 represented in a format whose specification is available to the |
|
2847 general public, that is suitable for revising the document |
|
2848 straightforwardly with generic text editors or (for images composed of |
|
2849 pixels) generic paint programs or (for drawings) some widely available |
|
2850 drawing editor, and that is suitable for input to text formatters or |
|
2851 for automatic translation to a variety of formats suitable for input |
|
2852 to text formatters. A copy made in an otherwise Transparent file |
|
2853 format whose markup, or absence of markup, has been arranged to thwart |
|
2854 or discourage subsequent modification by readers is not Transparent. |
|
2855 An image format is not Transparent if used for any substantial amount |
|
2856 of text. A copy that is not “Transparent” is called “Opaque”. |
|
2857 |
|
2858 <p>Examples of suitable formats for Transparent copies include plain |
|
2859 <span class="sc">ascii</span> without markup, Texinfo input format, LaTeX input |
|
2860 format, <acronym>SGML</acronym> or <acronym>XML</acronym> using a publicly available |
|
2861 <acronym>DTD</acronym>, and standard-conforming simple <acronym>HTML</acronym>, |
|
2862 PostScript or <acronym>PDF</acronym> designed for human modification. Examples |
|
2863 of transparent image formats include <acronym>PNG</acronym>, <acronym>XCF</acronym> and |
|
2864 <acronym>JPG</acronym>. Opaque formats include proprietary formats that can be |
|
2865 read and edited only by proprietary word processors, <acronym>SGML</acronym> or |
|
2866 <acronym>XML</acronym> for which the <acronym>DTD</acronym> and/or processing tools are |
|
2867 not generally available, and the machine-generated <acronym>HTML</acronym>, |
|
2868 PostScript or <acronym>PDF</acronym> produced by some word processors for |
|
2869 output purposes only. |
|
2870 |
|
2871 <p>The “Title Page” means, for a printed book, the title page itself, |
|
2872 plus such following pages as are needed to hold, legibly, the material |
|
2873 this License requires to appear in the title page. For works in |
|
2874 formats which do not have any title page as such, “Title Page” means |
|
2875 the text near the most prominent appearance of the work's title, |
|
2876 preceding the beginning of the body of the text. |
|
2877 |
|
2878 <p>A section “Entitled XYZ” means a named subunit of the Document whose |
|
2879 title either is precisely XYZ or contains XYZ in parentheses following |
|
2880 text that translates XYZ in another language. (Here XYZ stands for a |
|
2881 specific section name mentioned below, such as “Acknowledgements”, |
|
2882 “Dedications”, “Endorsements”, or “History”.) To “Preserve the Title” |
|
2883 of such a section when you modify the Document means that it remains a |
|
2884 section “Entitled XYZ” according to this definition. |
|
2885 |
|
2886 <p>The Document may include Warranty Disclaimers next to the notice which |
|
2887 states that this License applies to the Document. These Warranty |
|
2888 Disclaimers are considered to be included by reference in this |
|
2889 License, but only as regards disclaiming warranties: any other |
|
2890 implication that these Warranty Disclaimers may have is void and has |
|
2891 no effect on the meaning of this License. |
|
2892 |
|
2893 <li>VERBATIM COPYING |
|
2894 |
|
2895 <p>You may copy and distribute the Document in any medium, either |
|
2896 commercially or noncommercially, provided that this License, the |
|
2897 copyright notices, and the license notice saying this License applies |
|
2898 to the Document are reproduced in all copies, and that you add no other |
|
2899 conditions whatsoever to those of this License. You may not use |
|
2900 technical measures to obstruct or control the reading or further |
|
2901 copying of the copies you make or distribute. However, you may accept |
|
2902 compensation in exchange for copies. If you distribute a large enough |
|
2903 number of copies you must also follow the conditions in section 3. |
|
2904 |
|
2905 <p>You may also lend copies, under the same conditions stated above, and |
|
2906 you may publicly display copies. |
|
2907 |
|
2908 <li>COPYING IN QUANTITY |
|
2909 |
|
2910 <p>If you publish printed copies (or copies in media that commonly have |
|
2911 printed covers) of the Document, numbering more than 100, and the |
|
2912 Document's license notice requires Cover Texts, you must enclose the |
|
2913 copies in covers that carry, clearly and legibly, all these Cover |
|
2914 Texts: Front-Cover Texts on the front cover, and Back-Cover Texts on |
|
2915 the back cover. Both covers must also clearly and legibly identify |
|
2916 you as the publisher of these copies. The front cover must present |
|
2917 the full title with all words of the title equally prominent and |
|
2918 visible. You may add other material on the covers in addition. |
|
2919 Copying with changes limited to the covers, as long as they preserve |
|
2920 the title of the Document and satisfy these conditions, can be treated |
|
2921 as verbatim copying in other respects. |
|
2922 |
|
2923 <p>If the required texts for either cover are too voluminous to fit |
|
2924 legibly, you should put the first ones listed (as many as fit |
|
2925 reasonably) on the actual cover, and continue the rest onto adjacent |
|
2926 pages. |
|
2927 |
|
2928 <p>If you publish or distribute Opaque copies of the Document numbering |
|
2929 more than 100, you must either include a machine-readable Transparent |
|
2930 copy along with each Opaque copy, or state in or with each Opaque copy |
|
2931 a computer-network location from which the general network-using |
|
2932 public has access to download using public-standard network protocols |
|
2933 a complete Transparent copy of the Document, free of added material. |
|
2934 If you use the latter option, you must take reasonably prudent steps, |
|
2935 when you begin distribution of Opaque copies in quantity, to ensure |
|
2936 that this Transparent copy will remain thus accessible at the stated |
|
2937 location until at least one year after the last time you distribute an |
|
2938 Opaque copy (directly or through your agents or retailers) of that |
|
2939 edition to the public. |
|
2940 |
|
2941 <p>It is requested, but not required, that you contact the authors of the |
|
2942 Document well before redistributing any large number of copies, to give |
|
2943 them a chance to provide you with an updated version of the Document. |
|
2944 |
|
2945 <li>MODIFICATIONS |
|
2946 |
|
2947 <p>You may copy and distribute a Modified Version of the Document under |
|
2948 the conditions of sections 2 and 3 above, provided that you release |
|
2949 the Modified Version under precisely this License, with the Modified |
|
2950 Version filling the role of the Document, thus licensing distribution |
|
2951 and modification of the Modified Version to whoever possesses a copy |
|
2952 of it. In addition, you must do these things in the Modified Version: |
|
2953 |
|
2954 <ol type=A start=1> |
|
2955 <li>Use in the Title Page (and on the covers, if any) a title distinct |
|
2956 from that of the Document, and from those of previous versions |
|
2957 (which should, if there were any, be listed in the History section |
|
2958 of the Document). You may use the same title as a previous version |
|
2959 if the original publisher of that version gives permission. |
|
2960 |
|
2961 <li>List on the Title Page, as authors, one or more persons or entities |
|
2962 responsible for authorship of the modifications in the Modified |
|
2963 Version, together with at least five of the principal authors of the |
|
2964 Document (all of its principal authors, if it has fewer than five), |
|
2965 unless they release you from this requirement. |
|
2966 |
|
2967 <li>State on the Title page the name of the publisher of the |
|
2968 Modified Version, as the publisher. |
|
2969 |
|
2970 <li>Preserve all the copyright notices of the Document. |
|
2971 |
|
2972 <li>Add an appropriate copyright notice for your modifications |
|
2973 adjacent to the other copyright notices. |
|
2974 |
|
2975 <li>Include, immediately after the copyright notices, a license notice |
|
2976 giving the public permission to use the Modified Version under the |
|
2977 terms of this License, in the form shown in the Addendum below. |
|
2978 |
|
2979 <li>Preserve in that license notice the full lists of Invariant Sections |
|
2980 and required Cover Texts given in the Document's license notice. |
|
2981 |
|
2982 <li>Include an unaltered copy of this License. |
|
2983 |
|
2984 <li>Preserve the section Entitled “History”, Preserve its Title, and add |
|
2985 to it an item stating at least the title, year, new authors, and |
|
2986 publisher of the Modified Version as given on the Title Page. If |
|
2987 there is no section Entitled “History” in the Document, create one |
|
2988 stating the title, year, authors, and publisher of the Document as |
|
2989 given on its Title Page, then add an item describing the Modified |
|
2990 Version as stated in the previous sentence. |
|
2991 |
|
2992 <li>Preserve the network location, if any, given in the Document for |
|
2993 public access to a Transparent copy of the Document, and likewise |
|
2994 the network locations given in the Document for previous versions |
|
2995 it was based on. These may be placed in the “History” section. |
|
2996 You may omit a network location for a work that was published at |
|
2997 least four years before the Document itself, or if the original |
|
2998 publisher of the version it refers to gives permission. |
|
2999 |
|
3000 <li>For any section Entitled “Acknowledgements” or “Dedications”, Preserve |
|
3001 the Title of the section, and preserve in the section all the |
|
3002 substance and tone of each of the contributor acknowledgements and/or |
|
3003 dedications given therein. |
|
3004 |
|
3005 <li>Preserve all the Invariant Sections of the Document, |
|
3006 unaltered in their text and in their titles. Section numbers |
|
3007 or the equivalent are not considered part of the section titles. |
|
3008 |
|
3009 <li>Delete any section Entitled “Endorsements”. Such a section |
|
3010 may not be included in the Modified Version. |
|
3011 |
|
3012 <li>Do not retitle any existing section to be Entitled “Endorsements” or |
|
3013 to conflict in title with any Invariant Section. |
|
3014 |
|
3015 <li>Preserve any Warranty Disclaimers. |
|
3016 </ol> |
|
3017 |
|
3018 <p>If the Modified Version includes new front-matter sections or |
|
3019 appendices that qualify as Secondary Sections and contain no material |
|
3020 copied from the Document, you may at your option designate some or all |
|
3021 of these sections as invariant. To do this, add their titles to the |
|
3022 list of Invariant Sections in the Modified Version's license notice. |
|
3023 These titles must be distinct from any other section titles. |
|
3024 |
|
3025 <p>You may add a section Entitled “Endorsements”, provided it contains |
|
3026 nothing but endorsements of your Modified Version by various |
|
3027 parties—for example, statements of peer review or that the text has |
|
3028 been approved by an organization as the authoritative definition of a |
|
3029 standard. |
|
3030 |
|
3031 <p>You may add a passage of up to five words as a Front-Cover Text, and a |
|
3032 passage of up to 25 words as a Back-Cover Text, to the end of the list |
|
3033 of Cover Texts in the Modified Version. Only one passage of |
|
3034 Front-Cover Text and one of Back-Cover Text may be added by (or |
|
3035 through arrangements made by) any one entity. If the Document already |
|
3036 includes a cover text for the same cover, previously added by you or |
|
3037 by arrangement made by the same entity you are acting on behalf of, |
|
3038 you may not add another; but you may replace the old one, on explicit |
|
3039 permission from the previous publisher that added the old one. |
|
3040 |
|
3041 <p>The author(s) and publisher(s) of the Document do not by this License |
|
3042 give permission to use their names for publicity for or to assert or |
|
3043 imply endorsement of any Modified Version. |
|
3044 |
|
3045 <li>COMBINING DOCUMENTS |
|
3046 |
|
3047 <p>You may combine the Document with other documents released under this |
|
3048 License, under the terms defined in section 4 above for modified |
|
3049 versions, provided that you include in the combination all of the |
|
3050 Invariant Sections of all of the original documents, unmodified, and |
|
3051 list them all as Invariant Sections of your combined work in its |
|
3052 license notice, and that you preserve all their Warranty Disclaimers. |
|
3053 |
|
3054 <p>The combined work need only contain one copy of this License, and |
|
3055 multiple identical Invariant Sections may be replaced with a single |
|
3056 copy. If there are multiple Invariant Sections with the same name but |
|
3057 different contents, make the title of each such section unique by |
|
3058 adding at the end of it, in parentheses, the name of the original |
|
3059 author or publisher of that section if known, or else a unique number. |
|
3060 Make the same adjustment to the section titles in the list of |
|
3061 Invariant Sections in the license notice of the combined work. |
|
3062 |
|
3063 <p>In the combination, you must combine any sections Entitled “History” |
|
3064 in the various original documents, forming one section Entitled |
|
3065 “History”; likewise combine any sections Entitled “Acknowledgements”, |
|
3066 and any sections Entitled “Dedications”. You must delete all |
|
3067 sections Entitled “Endorsements.” |
|
3068 |
|
3069 <li>COLLECTIONS OF DOCUMENTS |
|
3070 |
|
3071 <p>You may make a collection consisting of the Document and other documents |
|
3072 released under this License, and replace the individual copies of this |
|
3073 License in the various documents with a single copy that is included in |
|
3074 the collection, provided that you follow the rules of this License for |
|
3075 verbatim copying of each of the documents in all other respects. |
|
3076 |
|
3077 <p>You may extract a single document from such a collection, and distribute |
|
3078 it individually under this License, provided you insert a copy of this |
|
3079 License into the extracted document, and follow this License in all |
|
3080 other respects regarding verbatim copying of that document. |
|
3081 |
|
3082 <li>AGGREGATION WITH INDEPENDENT WORKS |
|
3083 |
|
3084 <p>A compilation of the Document or its derivatives with other separate |
|
3085 and independent documents or works, in or on a volume of a storage or |
|
3086 distribution medium, is called an “aggregate” if the copyright |
|
3087 resulting from the compilation is not used to limit the legal rights |
|
3088 of the compilation's users beyond what the individual works permit. |
|
3089 When the Document is included in an aggregate, this License does not |
|
3090 apply to the other works in the aggregate which are not themselves |
|
3091 derivative works of the Document. |
|
3092 |
|
3093 <p>If the Cover Text requirement of section 3 is applicable to these |
|
3094 copies of the Document, then if the Document is less than one half of |
|
3095 the entire aggregate, the Document's Cover Texts may be placed on |
|
3096 covers that bracket the Document within the aggregate, or the |
|
3097 electronic equivalent of covers if the Document is in electronic form. |
|
3098 Otherwise they must appear on printed covers that bracket the whole |
|
3099 aggregate. |
|
3100 |
|
3101 <li>TRANSLATION |
|
3102 |
|
3103 <p>Translation is considered a kind of modification, so you may |
|
3104 distribute translations of the Document under the terms of section 4. |
|
3105 Replacing Invariant Sections with translations requires special |
|
3106 permission from their copyright holders, but you may include |
|
3107 translations of some or all Invariant Sections in addition to the |
|
3108 original versions of these Invariant Sections. You may include a |
|
3109 translation of this License, and all the license notices in the |
|
3110 Document, and any Warranty Disclaimers, provided that you also include |
|
3111 the original English version of this License and the original versions |
|
3112 of those notices and disclaimers. In case of a disagreement between |
|
3113 the translation and the original version of this License or a notice |
|
3114 or disclaimer, the original version will prevail. |
|
3115 |
|
3116 <p>If a section in the Document is Entitled “Acknowledgements”, |
|
3117 “Dedications”, or “History”, the requirement (section 4) to Preserve |
|
3118 its Title (section 1) will typically require changing the actual |
|
3119 title. |
|
3120 |
|
3121 <li>TERMINATION |
|
3122 |
|
3123 <p>You may not copy, modify, sublicense, or distribute the Document except |
|
3124 as expressly provided for under this License. Any other attempt to |
|
3125 copy, modify, sublicense or distribute the Document is void, and will |
|
3126 automatically terminate your rights under this License. However, |
|
3127 parties who have received copies, or rights, from you under this |
|
3128 License will not have their licenses terminated so long as such |
|
3129 parties remain in full compliance. |
|
3130 |
|
3131 <li>FUTURE REVISIONS OF THIS LICENSE |
|
3132 |
|
3133 <p>The Free Software Foundation may publish new, revised versions |
|
3134 of the GNU Free Documentation License from time to time. Such new |
|
3135 versions will be similar in spirit to the present version, but may |
|
3136 differ in detail to address new problems or concerns. See |
|
3137 <a href="http://www.gnu.org/copyleft/">http://www.gnu.org/copyleft/</a>. |
|
3138 |
|
3139 <p>Each version of the License is given a distinguishing version number. |
|
3140 If the Document specifies that a particular numbered version of this |
|
3141 License “or any later version” applies to it, you have the option of |
|
3142 following the terms and conditions either of that specified version or |
|
3143 of any later version that has been published (not as a draft) by the |
|
3144 Free Software Foundation. If the Document does not specify a version |
|
3145 number of this License, you may choose any version ever published (not |
|
3146 as a draft) by the Free Software Foundation. |
|
3147 </ol> |
|
3148 |
|
3149 <!-- MPFR tweak: Use @appendixsec --> |
|
3150 <!-- @appendixsubsec ADDENDUM: How to use this License for your documents --> |
|
3151 <h3 class="appendixsec">A.1 ADDENDUM: How to use this License for your documents</h3> |
|
3152 |
|
3153 <p>To use this License in a document you have written, include a copy of |
|
3154 the License in the document and put the following copyright and |
|
3155 license notices just after the title page: |
|
3156 |
|
3157 <pre class="smallexample"> Copyright (C) <var>year</var> <var>your name</var>. |
|
3158 Permission is granted to copy, distribute and/or modify this document |
|
3159 under the terms of the GNU Free Documentation License, Version 1.2 |
|
3160 or any later version published by the Free Software Foundation; |
|
3161 with no Invariant Sections, no Front-Cover Texts, and no Back-Cover |
|
3162 Texts. A copy of the license is included in the section entitled ``GNU |
|
3163 Free Documentation License''. |
|
3164 </pre> |
|
3165 <p>If you have Invariant Sections, Front-Cover Texts and Back-Cover Texts, |
|
3166 replace the “with...Texts.” line with this: |
|
3167 |
|
3168 <pre class="smallexample"> with the Invariant Sections being <var>list their titles</var>, with |
|
3169 the Front-Cover Texts being <var>list</var>, and with the Back-Cover Texts |
|
3170 being <var>list</var>. |
|
3171 </pre> |
|
3172 <p>If you have Invariant Sections without Cover Texts, or some other |
|
3173 combination of the three, merge those two alternatives to suit the |
|
3174 situation. |
|
3175 |
|
3176 <p>If your document contains nontrivial examples of program code, we |
|
3177 recommend releasing these examples in parallel under your choice of |
|
3178 free software license, such as the GNU General Public License, |
|
3179 to permit their use in free software. |
|
3180 |
|
3181 <!-- Local Variables: --> |
|
3182 <!-- ispell-local-pdict: "ispell-dict" --> |
|
3183 <!-- End: --> |
|
3184 <div class="node"> |
|
3185 <p><hr> |
|
3186 <a name="Concept-Index"></a> |
|
3187 Next: <a rel="next" accesskey="n" href="#Function-Index">Function Index</a>, |
|
3188 Previous: <a rel="previous" accesskey="p" href="#GNU-Free-Documentation-License">GNU Free Documentation License</a>, |
|
3189 Up: <a rel="up" accesskey="u" href="#Top">Top</a> |
|
3190 |
|
3191 </div> |
|
3192 |
|
3193 <!-- node-name, next, previous, up --> |
|
3194 <h2 class="unnumbered">Concept Index</h2> |
|
3195 |
|
3196 <ul class="index-cp" compact> |
|
3197 <li><a href="#index-Accuracy-21">Accuracy</a>: <a href="#MPFR-Interface">MPFR Interface</a></li> |
|
3198 <li><a href="#index-Advanced-functions-283">Advanced functions</a>: <a href="#Advanced-Functions">Advanced Functions</a></li> |
|
3199 <li><a href="#index-Arithmetic-functions-86">Arithmetic functions</a>: <a href="#Basic-Arithmetic-Functions">Basic Arithmetic Functions</a></li> |
|
3200 <li><a href="#index-Assignment-functions-30">Assignment functions</a>: <a href="#Assignment-Functions">Assignment Functions</a></li> |
|
3201 <li><a href="#index-Basic-arithmetic-functions-84">Basic arithmetic functions</a>: <a href="#Basic-Arithmetic-Functions">Basic Arithmetic Functions</a></li> |
|
3202 <li><a href="#index-Combined-initialization-and-assignment-functions-51">Combined initialization and assignment functions</a>: <a href="#Combined-Initialization-and-Assignment-Functions">Combined Initialization and Assignment Functions</a></li> |
|
3203 <li><a href="#index-Comparison-functions-130">Comparison functions</a>: <a href="#Comparison-Functions">Comparison Functions</a></li> |
|
3204 <li><a href="#index-Compatibility-with-MPF-288">Compatibility with MPF</a>: <a href="#Compatibility-with-MPF">Compatibility with MPF</a></li> |
|
3205 <li><a href="#index-Conditions-for-copying-MPFR-2">Conditions for copying MPFR</a>: <a href="#Copying">Copying</a></li> |
|
3206 <li><a href="#index-Conversion-functions-61">Conversion functions</a>: <a href="#Conversion-Functions">Conversion Functions</a></li> |
|
3207 <li><a href="#index-Copying-conditions-1">Copying conditions</a>: <a href="#Copying">Copying</a></li> |
|
3208 <li><a href="#index-Custom-interface-294">Custom interface</a>: <a href="#Custom-Interface">Custom Interface</a></li> |
|
3209 <li><a href="#index-Exception-related-functions-256">Exception related functions</a>: <a href="#Exception-Related-Functions">Exception Related Functions</a></li> |
|
3210 <li><a href="#index-FDL_002c-GNU-Free-Documentation-License-306">FDL, GNU Free Documentation License</a>: <a href="#GNU-Free-Documentation-License">GNU Free Documentation License</a></li> |
|
3211 <li><a href="#index-Float-arithmetic-functions-85">Float arithmetic functions</a>: <a href="#Basic-Arithmetic-Functions">Basic Arithmetic Functions</a></li> |
|
3212 <li><a href="#index-Float-comparisons-functions-129">Float comparisons functions</a>: <a href="#Comparison-Functions">Comparison Functions</a></li> |
|
3213 <li><a href="#index-Float-functions-19">Float functions</a>: <a href="#MPFR-Interface">MPFR Interface</a></li> |
|
3214 <li><a href="#index-Float-input-and-output-functions-208">Float input and output functions</a>: <a href="#Input-and-Output-Functions">Input and Output Functions</a></li> |
|
3215 <li><a href="#index-Floating_002dpoint-functions-18">Floating-point functions</a>: <a href="#MPFR-Interface">MPFR Interface</a></li> |
|
3216 <li><a href="#index-Floating_002dpoint-number-11">Floating-point number</a>: <a href="#MPFR-Basics">MPFR Basics</a></li> |
|
3217 <li><a href="#index-GNU-Free-Documentation-License-305">GNU Free Documentation License</a>: <a href="#GNU-Free-Documentation-License">GNU Free Documentation License</a></li> |
|
3218 <li><a href="#index-I_002fO-functions-211">I/O functions</a>: <a href="#Input-and-Output-Functions">Input and Output Functions</a></li> |
|
3219 <li><a href="#index-Initialization-functions-22">Initialization functions</a>: <a href="#Initialization-Functions">Initialization Functions</a></li> |
|
3220 <li><a href="#index-Input-functions-209">Input functions</a>: <a href="#Input-and-Output-Functions">Input and Output Functions</a></li> |
|
3221 <li><a href="#index-Installation-3">Installation</a>: <a href="#Installing-MPFR">Installing MPFR</a></li> |
|
3222 <li><a href="#index-Integer-related-functions-214">Integer related functions</a>: <a href="#Integer-Related-Functions">Integer Related Functions</a></li> |
|
3223 <li><a href="#index-Internals-302">Internals</a>: <a href="#Internals">Internals</a></li> |
|
3224 <li><a href="#index-g_t_0040code_007blibmpfr_007d-9"><code>libmpfr</code></a>: <a href="#MPFR-Basics">MPFR Basics</a></li> |
|
3225 <li><a href="#index-Libraries-7">Libraries</a>: <a href="#MPFR-Basics">MPFR Basics</a></li> |
|
3226 <li><a href="#index-Libtool-10">Libtool</a>: <a href="#MPFR-Basics">MPFR Basics</a></li> |
|
3227 <li><a href="#index-Limb-17">Limb</a>: <a href="#MPFR-Basics">MPFR Basics</a></li> |
|
3228 <li><a href="#index-Linking-8">Linking</a>: <a href="#MPFR-Basics">MPFR Basics</a></li> |
|
3229 <li><a href="#index-Miscellaneous-float-functions-228">Miscellaneous float functions</a>: <a href="#Miscellaneous-Functions">Miscellaneous Functions</a></li> |
|
3230 <li><a href="#index-g_t_0040file_007bmpfr_002eh_007d-5"><samp><span class="file">mpfr.h</span></samp></a>: <a href="#MPFR-Basics">MPFR Basics</a></li> |
|
3231 <li><a href="#index-Output-functions-210">Output functions</a>: <a href="#Input-and-Output-Functions">Input and Output Functions</a></li> |
|
3232 <li><a href="#index-Precision-20">Precision</a>: <a href="#MPFR-Interface">MPFR Interface</a></li> |
|
3233 <li><a href="#index-Precision-13">Precision</a>: <a href="#MPFR-Basics">MPFR Basics</a></li> |
|
3234 <li><a href="#index-Reporting-bugs-4">Reporting bugs</a>: <a href="#Reporting-Bugs">Reporting Bugs</a></li> |
|
3235 <li><a href="#index-Rounding-mode-related-functions-250">Rounding mode related functions</a>: <a href="#Rounding-Mode-Related-Functions">Rounding Mode Related Functions</a></li> |
|
3236 <li><a href="#index-Rounding-Modes-15">Rounding Modes</a>: <a href="#MPFR-Basics">MPFR Basics</a></li> |
|
3237 <li><a href="#index-Special-functions-154">Special functions</a>: <a href="#Special-Functions">Special Functions</a></li> |
|
3238 <li><a href="#index-g_t_0040code_007bstdio_002eh_007d-6"><code>stdio.h</code></a>: <a href="#MPFR-Basics">MPFR Basics</a></li> |
|
3239 </ul><div class="node"> |
|
3240 <p><hr> |
|
3241 <a name="Function-Index"></a> |
|
3242 Previous: <a rel="previous" accesskey="p" href="#Concept-Index">Concept Index</a>, |
|
3243 Up: <a rel="up" accesskey="u" href="#Top">Top</a> |
|
3244 |
|
3245 </div> |
|
3246 |
|
3247 <!-- node-name, next, previous, up --> |
|
3248 <h2 class="unnumbered">Function and Type Index</h2> |
|
3249 |
|
3250 |
|
3251 |
|
3252 <ul class="index-fn" compact> |
|
3253 <li><a href="#index-g_t_0040code_007bmp_005fprec_005ft_007d-14"><code>mp_prec_t</code></a>: <a href="#MPFR-Basics">MPFR Basics</a></li> |
|
3254 <li><a href="#index-g_t_0040code_007bmp_005frnd_005ft_007d-16"><code>mp_rnd_t</code></a>: <a href="#MPFR-Basics">MPFR Basics</a></li> |
|
3255 <li><a href="#index-mpfr_005fabs-123"><code>mpfr_abs</code></a>: <a href="#Basic-Arithmetic-Functions">Basic Arithmetic Functions</a></li> |
|
3256 <li><a href="#index-mpfr_005facos-168"><code>mpfr_acos</code></a>: <a href="#Special-Functions">Special Functions</a></li> |
|
3257 <li><a href="#index-mpfr_005facosh-178"><code>mpfr_acosh</code></a>: <a href="#Special-Functions">Special Functions</a></li> |
|
3258 <li><a href="#index-mpfr_005fadd-87"><code>mpfr_add</code></a>: <a href="#Basic-Arithmetic-Functions">Basic Arithmetic Functions</a></li> |
|
3259 <li><a href="#index-mpfr_005fadd_005fq-91"><code>mpfr_add_q</code></a>: <a href="#Basic-Arithmetic-Functions">Basic Arithmetic Functions</a></li> |
|
3260 <li><a href="#index-mpfr_005fadd_005fsi-89"><code>mpfr_add_si</code></a>: <a href="#Basic-Arithmetic-Functions">Basic Arithmetic Functions</a></li> |
|
3261 <li><a href="#index-mpfr_005fadd_005fui-88"><code>mpfr_add_ui</code></a>: <a href="#Basic-Arithmetic-Functions">Basic Arithmetic Functions</a></li> |
|
3262 <li><a href="#index-mpfr_005fadd_005fz-90"><code>mpfr_add_z</code></a>: <a href="#Basic-Arithmetic-Functions">Basic Arithmetic Functions</a></li> |
|
3263 <li><a href="#index-mpfr_005fagm-200"><code>mpfr_agm</code></a>: <a href="#Special-Functions">Special Functions</a></li> |
|
3264 <li><a href="#index-mpfr_005fasin-169"><code>mpfr_asin</code></a>: <a href="#Special-Functions">Special Functions</a></li> |
|
3265 <li><a href="#index-mpfr_005fasinh-179"><code>mpfr_asinh</code></a>: <a href="#Special-Functions">Special Functions</a></li> |
|
3266 <li><a href="#index-mpfr_005fatan-170"><code>mpfr_atan</code></a>: <a href="#Special-Functions">Special Functions</a></li> |
|
3267 <li><a href="#index-mpfr_005fatan2-171"><code>mpfr_atan2</code></a>: <a href="#Special-Functions">Special Functions</a></li> |
|
3268 <li><a href="#index-mpfr_005fatanh-180"><code>mpfr_atanh</code></a>: <a href="#Special-Functions">Special Functions</a></li> |
|
3269 <li><a href="#index-mpfr_005fcan_005fround-303"><code>mpfr_can_round</code></a>: <a href="#Internals">Internals</a></li> |
|
3270 <li><a href="#index-mpfr_005fcbrt-114"><code>mpfr_cbrt</code></a>: <a href="#Basic-Arithmetic-Functions">Basic Arithmetic Functions</a></li> |
|
3271 <li><a href="#index-mpfr_005fceil-216"><code>mpfr_ceil</code></a>: <a href="#Integer-Related-Functions">Integer Related Functions</a></li> |
|
3272 <li><a href="#index-mpfr_005fcheck_005frange-265"><code>mpfr_check_range</code></a>: <a href="#Exception-Related-Functions">Exception Related Functions</a></li> |
|
3273 <li><a href="#index-mpfr_005fclear-24"><code>mpfr_clear</code></a>: <a href="#Initialization-Functions">Initialization Functions</a></li> |
|
3274 <li><a href="#index-mpfr_005fclear_005ferangeflag-271"><code>mpfr_clear_erangeflag</code></a>: <a href="#Exception-Related-Functions">Exception Related Functions</a></li> |
|
3275 <li><a href="#index-mpfr_005fclear_005fflags-277"><code>mpfr_clear_flags</code></a>: <a href="#Exception-Related-Functions">Exception Related Functions</a></li> |
|
3276 <li><a href="#index-mpfr_005fclear_005finexflag-270"><code>mpfr_clear_inexflag</code></a>: <a href="#Exception-Related-Functions">Exception Related Functions</a></li> |
|
3277 <li><a href="#index-mpfr_005fclear_005fnanflag-269"><code>mpfr_clear_nanflag</code></a>: <a href="#Exception-Related-Functions">Exception Related Functions</a></li> |
|
3278 <li><a href="#index-mpfr_005fclear_005foverflow-268"><code>mpfr_clear_overflow</code></a>: <a href="#Exception-Related-Functions">Exception Related Functions</a></li> |
|
3279 <li><a href="#index-mpfr_005fclear_005funderflow-267"><code>mpfr_clear_underflow</code></a>: <a href="#Exception-Related-Functions">Exception Related Functions</a></li> |
|
3280 <li><a href="#index-mpfr_005fclears-287"><code>mpfr_clears</code></a>: <a href="#Advanced-Functions">Advanced Functions</a></li> |
|
3281 <li><a href="#index-mpfr_005fcmp-131"><code>mpfr_cmp</code></a>: <a href="#Comparison-Functions">Comparison Functions</a></li> |
|
3282 <li><a href="#index-mpfr_005fcmp_005fd-134"><code>mpfr_cmp_d</code></a>: <a href="#Comparison-Functions">Comparison Functions</a></li> |
|
3283 <li><a href="#index-mpfr_005fcmp_005ff-138"><code>mpfr_cmp_f</code></a>: <a href="#Comparison-Functions">Comparison Functions</a></li> |
|
3284 <li><a href="#index-mpfr_005fcmp_005fld-135"><code>mpfr_cmp_ld</code></a>: <a href="#Comparison-Functions">Comparison Functions</a></li> |
|
3285 <li><a href="#index-mpfr_005fcmp_005fq-137"><code>mpfr_cmp_q</code></a>: <a href="#Comparison-Functions">Comparison Functions</a></li> |
|
3286 <li><a href="#index-mpfr_005fcmp_005fsi-133"><code>mpfr_cmp_si</code></a>: <a href="#Comparison-Functions">Comparison Functions</a></li> |
|
3287 <li><a href="#index-mpfr_005fcmp_005fsi_005f2exp-140"><code>mpfr_cmp_si_2exp</code></a>: <a href="#Comparison-Functions">Comparison Functions</a></li> |
|
3288 <li><a href="#index-mpfr_005fcmp_005fui-132"><code>mpfr_cmp_ui</code></a>: <a href="#Comparison-Functions">Comparison Functions</a></li> |
|
3289 <li><a href="#index-mpfr_005fcmp_005fui_005f2exp-139"><code>mpfr_cmp_ui_2exp</code></a>: <a href="#Comparison-Functions">Comparison Functions</a></li> |
|
3290 <li><a href="#index-mpfr_005fcmp_005fz-136"><code>mpfr_cmp_z</code></a>: <a href="#Comparison-Functions">Comparison Functions</a></li> |
|
3291 <li><a href="#index-mpfr_005fcmpabs-141"><code>mpfr_cmpabs</code></a>: <a href="#Comparison-Functions">Comparison Functions</a></li> |
|
3292 <li><a href="#index-mpfr_005fconst_005fcatalan-205"><code>mpfr_const_catalan</code></a>: <a href="#Special-Functions">Special Functions</a></li> |
|
3293 <li><a href="#index-mpfr_005fconst_005feuler-204"><code>mpfr_const_euler</code></a>: <a href="#Special-Functions">Special Functions</a></li> |
|
3294 <li><a href="#index-mpfr_005fconst_005flog2-202"><code>mpfr_const_log2</code></a>: <a href="#Special-Functions">Special Functions</a></li> |
|
3295 <li><a href="#index-mpfr_005fconst_005fpi-203"><code>mpfr_const_pi</code></a>: <a href="#Special-Functions">Special Functions</a></li> |
|
3296 <li><a href="#index-mpfr_005fcopysign-241"><code>mpfr_copysign</code></a>: <a href="#Miscellaneous-Functions">Miscellaneous Functions</a></li> |
|
3297 <li><a href="#index-mpfr_005fcos-161"><code>mpfr_cos</code></a>: <a href="#Special-Functions">Special Functions</a></li> |
|
3298 <li><a href="#index-mpfr_005fcosh-172"><code>mpfr_cosh</code></a>: <a href="#Special-Functions">Special Functions</a></li> |
|
3299 <li><a href="#index-mpfr_005fcot-166"><code>mpfr_cot</code></a>: <a href="#Special-Functions">Special Functions</a></li> |
|
3300 <li><a href="#index-mpfr_005fcoth-177"><code>mpfr_coth</code></a>: <a href="#Special-Functions">Special Functions</a></li> |
|
3301 <li><a href="#index-mpfr_005fcsc-165"><code>mpfr_csc</code></a>: <a href="#Special-Functions">Special Functions</a></li> |
|
3302 <li><a href="#index-mpfr_005fcsch-176"><code>mpfr_csch</code></a>: <a href="#Special-Functions">Special Functions</a></li> |
|
3303 <li><a href="#index-mpfr_005fcustom_005fget_005fexp-300"><code>mpfr_custom_get_exp</code></a>: <a href="#Custom-Interface">Custom Interface</a></li> |
|
3304 <li><a href="#index-mpfr_005fcustom_005fget_005fkind-298"><code>mpfr_custom_get_kind</code></a>: <a href="#Custom-Interface">Custom Interface</a></li> |
|
3305 <li><a href="#index-mpfr_005fcustom_005fget_005fmantissa-299"><code>mpfr_custom_get_mantissa</code></a>: <a href="#Custom-Interface">Custom Interface</a></li> |
|
3306 <li><a href="#index-mpfr_005fcustom_005fget_005fsize-295"><code>mpfr_custom_get_size</code></a>: <a href="#Custom-Interface">Custom Interface</a></li> |
|
3307 <li><a href="#index-mpfr_005fcustom_005finit-296"><code>mpfr_custom_init</code></a>: <a href="#Custom-Interface">Custom Interface</a></li> |
|
3308 <li><a href="#index-mpfr_005fcustom_005finit_005fset-297"><code>mpfr_custom_init_set</code></a>: <a href="#Custom-Interface">Custom Interface</a></li> |
|
3309 <li><a href="#index-mpfr_005fcustom_005fmove-301"><code>mpfr_custom_move</code></a>: <a href="#Custom-Interface">Custom Interface</a></li> |
|
3310 <li><a href="#index-MPFR_005fDECL_005fINIT-284"><code>MPFR_DECL_INIT</code></a>: <a href="#Advanced-Functions">Advanced Functions</a></li> |
|
3311 <li><a href="#index-mpfr_005fdim-124"><code>mpfr_dim</code></a>: <a href="#Basic-Arithmetic-Functions">Basic Arithmetic Functions</a></li> |
|
3312 <li><a href="#index-mpfr_005fdiv-105"><code>mpfr_div</code></a>: <a href="#Basic-Arithmetic-Functions">Basic Arithmetic Functions</a></li> |
|
3313 <li><a href="#index-mpfr_005fdiv_005f2exp-293"><code>mpfr_div_2exp</code></a>: <a href="#Compatibility-with-MPF">Compatibility with MPF</a></li> |
|
3314 <li><a href="#index-mpfr_005fdiv_005f2si-128"><code>mpfr_div_2si</code></a>: <a href="#Basic-Arithmetic-Functions">Basic Arithmetic Functions</a></li> |
|
3315 <li><a href="#index-mpfr_005fdiv_005f2ui-127"><code>mpfr_div_2ui</code></a>: <a href="#Basic-Arithmetic-Functions">Basic Arithmetic Functions</a></li> |
|
3316 <li><a href="#index-mpfr_005fdiv_005fq-111"><code>mpfr_div_q</code></a>: <a href="#Basic-Arithmetic-Functions">Basic Arithmetic Functions</a></li> |
|
3317 <li><a href="#index-mpfr_005fdiv_005fsi-109"><code>mpfr_div_si</code></a>: <a href="#Basic-Arithmetic-Functions">Basic Arithmetic Functions</a></li> |
|
3318 <li><a href="#index-mpfr_005fdiv_005fui-107"><code>mpfr_div_ui</code></a>: <a href="#Basic-Arithmetic-Functions">Basic Arithmetic Functions</a></li> |
|
3319 <li><a href="#index-mpfr_005fdiv_005fz-110"><code>mpfr_div_z</code></a>: <a href="#Basic-Arithmetic-Functions">Basic Arithmetic Functions</a></li> |
|
3320 <li><a href="#index-mpfr_005feint-184"><code>mpfr_eint</code></a>: <a href="#Special-Functions">Special Functions</a></li> |
|
3321 <li><a href="#index-mpfr_005feq-290"><code>mpfr_eq</code></a>: <a href="#Compatibility-with-MPF">Compatibility with MPF</a></li> |
|
3322 <li><a href="#index-mpfr_005fequal_005fp-152"><code>mpfr_equal_p</code></a>: <a href="#Comparison-Functions">Comparison Functions</a></li> |
|
3323 <li><a href="#index-mpfr_005ferangeflag_005fp-282"><code>mpfr_erangeflag_p</code></a>: <a href="#Exception-Related-Functions">Exception Related Functions</a></li> |
|
3324 <li><a href="#index-mpfr_005ferf-190"><code>mpfr_erf</code></a>: <a href="#Special-Functions">Special Functions</a></li> |
|
3325 <li><a href="#index-mpfr_005ferfc-191"><code>mpfr_erfc</code></a>: <a href="#Special-Functions">Special Functions</a></li> |
|
3326 <li><a href="#index-mpfr_005fexp-158"><code>mpfr_exp</code></a>: <a href="#Special-Functions">Special Functions</a></li> |
|
3327 <li><a href="#index-mpfr_005fexp10-160"><code>mpfr_exp10</code></a>: <a href="#Special-Functions">Special Functions</a></li> |
|
3328 <li><a href="#index-mpfr_005fexp2-159"><code>mpfr_exp2</code></a>: <a href="#Special-Functions">Special Functions</a></li> |
|
3329 <li><a href="#index-mpfr_005fexpm1-183"><code>mpfr_expm1</code></a>: <a href="#Special-Functions">Special Functions</a></li> |
|
3330 <li><a href="#index-mpfr_005ffac_005fui-181"><code>mpfr_fac_ui</code></a>: <a href="#Special-Functions">Special Functions</a></li> |
|
3331 <li><a href="#index-mpfr_005ffits_005fintmax_005fp-82"><code>mpfr_fits_intmax_p</code></a>: <a href="#Conversion-Functions">Conversion Functions</a></li> |
|
3332 <li><a href="#index-mpfr_005ffits_005fsint_005fp-79"><code>mpfr_fits_sint_p</code></a>: <a href="#Conversion-Functions">Conversion Functions</a></li> |
|
3333 <li><a href="#index-mpfr_005ffits_005fslong_005fp-77"><code>mpfr_fits_slong_p</code></a>: <a href="#Conversion-Functions">Conversion Functions</a></li> |
|
3334 <li><a href="#index-mpfr_005ffits_005fsshort_005fp-81"><code>mpfr_fits_sshort_p</code></a>: <a href="#Conversion-Functions">Conversion Functions</a></li> |
|
3335 <li><a href="#index-mpfr_005ffits_005fuint_005fp-78"><code>mpfr_fits_uint_p</code></a>: <a href="#Conversion-Functions">Conversion Functions</a></li> |
|
3336 <li><a href="#index-mpfr_005ffits_005fuintmax_005fp-83"><code>mpfr_fits_uintmax_p</code></a>: <a href="#Conversion-Functions">Conversion Functions</a></li> |
|
3337 <li><a href="#index-mpfr_005ffits_005fulong_005fp-76"><code>mpfr_fits_ulong_p</code></a>: <a href="#Conversion-Functions">Conversion Functions</a></li> |
|
3338 <li><a href="#index-mpfr_005ffits_005fushort_005fp-80"><code>mpfr_fits_ushort_p</code></a>: <a href="#Conversion-Functions">Conversion Functions</a></li> |
|
3339 <li><a href="#index-mpfr_005ffloor-217"><code>mpfr_floor</code></a>: <a href="#Integer-Related-Functions">Integer Related Functions</a></li> |
|
3340 <li><a href="#index-mpfr_005ffma-198"><code>mpfr_fma</code></a>: <a href="#Special-Functions">Special Functions</a></li> |
|
3341 <li><a href="#index-mpfr_005ffms-199"><code>mpfr_fms</code></a>: <a href="#Special-Functions">Special Functions</a></li> |
|
3342 <li><a href="#index-mpfr_005ffrac-224"><code>mpfr_frac</code></a>: <a href="#Integer-Related-Functions">Integer Related Functions</a></li> |
|
3343 <li><a href="#index-mpfr_005ffree_005fcache-206"><code>mpfr_free_cache</code></a>: <a href="#Special-Functions">Special Functions</a></li> |
|
3344 <li><a href="#index-mpfr_005ffree_005fstr-75"><code>mpfr_free_str</code></a>: <a href="#Conversion-Functions">Conversion Functions</a></li> |
|
3345 <li><a href="#index-mpfr_005fgamma-185"><code>mpfr_gamma</code></a>: <a href="#Special-Functions">Special Functions</a></li> |
|
3346 <li><a href="#index-mpfr_005fget_005fd-62"><code>mpfr_get_d</code></a>: <a href="#Conversion-Functions">Conversion Functions</a></li> |
|
3347 <li><a href="#index-mpfr_005fget_005fd1-304"><code>mpfr_get_d1</code></a>: <a href="#Internals">Internals</a></li> |
|
3348 <li><a href="#index-mpfr_005fget_005fd_005f2exp-65"><code>mpfr_get_d_2exp</code></a>: <a href="#Conversion-Functions">Conversion Functions</a></li> |
|
3349 <li><a href="#index-mpfr_005fget_005fdecimal64-64"><code>mpfr_get_decimal64</code></a>: <a href="#Conversion-Functions">Conversion Functions</a></li> |
|
3350 <li><a href="#index-mpfr_005fget_005fdefault_005fprec-27"><code>mpfr_get_default_prec</code></a>: <a href="#Initialization-Functions">Initialization Functions</a></li> |
|
3351 <li><a href="#index-mpfr_005fget_005fdefault_005frounding_005fmode-252"><code>mpfr_get_default_rounding_mode</code></a>: <a href="#Rounding-Mode-Related-Functions">Rounding Mode Related Functions</a></li> |
|
3352 <li><a href="#index-mpfr_005fget_005femax-258"><code>mpfr_get_emax</code></a>: <a href="#Exception-Related-Functions">Exception Related Functions</a></li> |
|
3353 <li><a href="#index-mpfr_005fget_005femax_005fmax-264"><code>mpfr_get_emax_max</code></a>: <a href="#Exception-Related-Functions">Exception Related Functions</a></li> |
|
3354 <li><a href="#index-mpfr_005fget_005femax_005fmin-263"><code>mpfr_get_emax_min</code></a>: <a href="#Exception-Related-Functions">Exception Related Functions</a></li> |
|
3355 <li><a href="#index-mpfr_005fget_005femin-257"><code>mpfr_get_emin</code></a>: <a href="#Exception-Related-Functions">Exception Related Functions</a></li> |
|
3356 <li><a href="#index-mpfr_005fget_005femin_005fmax-262"><code>mpfr_get_emin_max</code></a>: <a href="#Exception-Related-Functions">Exception Related Functions</a></li> |
|
3357 <li><a href="#index-mpfr_005fget_005femin_005fmin-261"><code>mpfr_get_emin_min</code></a>: <a href="#Exception-Related-Functions">Exception Related Functions</a></li> |
|
3358 <li><a href="#index-mpfr_005fget_005fexp-237"><code>mpfr_get_exp</code></a>: <a href="#Miscellaneous-Functions">Miscellaneous Functions</a></li> |
|
3359 <li><a href="#index-mpfr_005fget_005ff-73"><code>mpfr_get_f</code></a>: <a href="#Conversion-Functions">Conversion Functions</a></li> |
|
3360 <li><a href="#index-mpfr_005fget_005fld-63"><code>mpfr_get_ld</code></a>: <a href="#Conversion-Functions">Conversion Functions</a></li> |
|
3361 <li><a href="#index-mpfr_005fget_005fld_005f2exp-66"><code>mpfr_get_ld_2exp</code></a>: <a href="#Conversion-Functions">Conversion Functions</a></li> |
|
3362 <li><a href="#index-mpfr_005fget_005fpatches-249"><code>mpfr_get_patches</code></a>: <a href="#Miscellaneous-Functions">Miscellaneous Functions</a></li> |
|
3363 <li><a href="#index-mpfr_005fget_005fprec-29"><code>mpfr_get_prec</code></a>: <a href="#Initialization-Functions">Initialization Functions</a></li> |
|
3364 <li><a href="#index-mpfr_005fget_005fsi-67"><code>mpfr_get_si</code></a>: <a href="#Conversion-Functions">Conversion Functions</a></li> |
|
3365 <li><a href="#index-mpfr_005fget_005fsj-69"><code>mpfr_get_sj</code></a>: <a href="#Conversion-Functions">Conversion Functions</a></li> |
|
3366 <li><a href="#index-mpfr_005fget_005fstr-74"><code>mpfr_get_str</code></a>: <a href="#Conversion-Functions">Conversion Functions</a></li> |
|
3367 <li><a href="#index-mpfr_005fget_005fui-68"><code>mpfr_get_ui</code></a>: <a href="#Conversion-Functions">Conversion Functions</a></li> |
|
3368 <li><a href="#index-mpfr_005fget_005fuj-70"><code>mpfr_get_uj</code></a>: <a href="#Conversion-Functions">Conversion Functions</a></li> |
|
3369 <li><a href="#index-mpfr_005fget_005fversion-242"><code>mpfr_get_version</code></a>: <a href="#Miscellaneous-Functions">Miscellaneous Functions</a></li> |
|
3370 <li><a href="#index-mpfr_005fget_005fz-72"><code>mpfr_get_z</code></a>: <a href="#Conversion-Functions">Conversion Functions</a></li> |
|
3371 <li><a href="#index-mpfr_005fget_005fz_005fexp-71"><code>mpfr_get_z_exp</code></a>: <a href="#Conversion-Functions">Conversion Functions</a></li> |
|
3372 <li><a href="#index-mpfr_005fgreater_005fp-147"><code>mpfr_greater_p</code></a>: <a href="#Comparison-Functions">Comparison Functions</a></li> |
|
3373 <li><a href="#index-mpfr_005fgreaterequal_005fp-148"><code>mpfr_greaterequal_p</code></a>: <a href="#Comparison-Functions">Comparison Functions</a></li> |
|
3374 <li><a href="#index-mpfr_005fhypot-201"><code>mpfr_hypot</code></a>: <a href="#Special-Functions">Special Functions</a></li> |
|
3375 <li><a href="#index-mpfr_005finexflag_005fp-281"><code>mpfr_inexflag_p</code></a>: <a href="#Exception-Related-Functions">Exception Related Functions</a></li> |
|
3376 <li><a href="#index-mpfr_005finf_005fp-143"><code>mpfr_inf_p</code></a>: <a href="#Comparison-Functions">Comparison Functions</a></li> |
|
3377 <li><a href="#index-mpfr_005finit-25"><code>mpfr_init</code></a>: <a href="#Initialization-Functions">Initialization Functions</a></li> |
|
3378 <li><a href="#index-mpfr_005finit2-23"><code>mpfr_init2</code></a>: <a href="#Initialization-Functions">Initialization Functions</a></li> |
|
3379 <li><a href="#index-mpfr_005finit_005fset-52"><code>mpfr_init_set</code></a>: <a href="#Combined-Initialization-and-Assignment-Functions">Combined Initialization and Assignment Functions</a></li> |
|
3380 <li><a href="#index-mpfr_005finit_005fset_005fd-55"><code>mpfr_init_set_d</code></a>: <a href="#Combined-Initialization-and-Assignment-Functions">Combined Initialization and Assignment Functions</a></li> |
|
3381 <li><a href="#index-mpfr_005finit_005fset_005ff-59"><code>mpfr_init_set_f</code></a>: <a href="#Combined-Initialization-and-Assignment-Functions">Combined Initialization and Assignment Functions</a></li> |
|
3382 <li><a href="#index-mpfr_005finit_005fset_005fld-56"><code>mpfr_init_set_ld</code></a>: <a href="#Combined-Initialization-and-Assignment-Functions">Combined Initialization and Assignment Functions</a></li> |
|
3383 <li><a href="#index-mpfr_005finit_005fset_005fq-58"><code>mpfr_init_set_q</code></a>: <a href="#Combined-Initialization-and-Assignment-Functions">Combined Initialization and Assignment Functions</a></li> |
|
3384 <li><a href="#index-mpfr_005finit_005fset_005fsi-54"><code>mpfr_init_set_si</code></a>: <a href="#Combined-Initialization-and-Assignment-Functions">Combined Initialization and Assignment Functions</a></li> |
|
3385 <li><a href="#index-mpfr_005finit_005fset_005fstr-60"><code>mpfr_init_set_str</code></a>: <a href="#Combined-Initialization-and-Assignment-Functions">Combined Initialization and Assignment Functions</a></li> |
|
3386 <li><a href="#index-mpfr_005finit_005fset_005fui-53"><code>mpfr_init_set_ui</code></a>: <a href="#Combined-Initialization-and-Assignment-Functions">Combined Initialization and Assignment Functions</a></li> |
|
3387 <li><a href="#index-mpfr_005finit_005fset_005fz-57"><code>mpfr_init_set_z</code></a>: <a href="#Combined-Initialization-and-Assignment-Functions">Combined Initialization and Assignment Functions</a></li> |
|
3388 <li><a href="#index-mpfr_005finits-285"><code>mpfr_inits</code></a>: <a href="#Advanced-Functions">Advanced Functions</a></li> |
|
3389 <li><a href="#index-mpfr_005finits2-286"><code>mpfr_inits2</code></a>: <a href="#Advanced-Functions">Advanced Functions</a></li> |
|
3390 <li><a href="#index-mpfr_005finp_005fstr-213"><code>mpfr_inp_str</code></a>: <a href="#Input-and-Output-Functions">Input and Output Functions</a></li> |
|
3391 <li><a href="#index-mpfr_005finteger_005fp-227"><code>mpfr_integer_p</code></a>: <a href="#Integer-Related-Functions">Integer Related Functions</a></li> |
|
3392 <li><a href="#index-mpfr_005fj0-192"><code>mpfr_j0</code></a>: <a href="#Special-Functions">Special Functions</a></li> |
|
3393 <li><a href="#index-mpfr_005fj1-193"><code>mpfr_j1</code></a>: <a href="#Special-Functions">Special Functions</a></li> |
|
3394 <li><a href="#index-mpfr_005fjn-194"><code>mpfr_jn</code></a>: <a href="#Special-Functions">Special Functions</a></li> |
|
3395 <li><a href="#index-mpfr_005fless_005fp-149"><code>mpfr_less_p</code></a>: <a href="#Comparison-Functions">Comparison Functions</a></li> |
|
3396 <li><a href="#index-mpfr_005flessequal_005fp-150"><code>mpfr_lessequal_p</code></a>: <a href="#Comparison-Functions">Comparison Functions</a></li> |
|
3397 <li><a href="#index-mpfr_005flessgreater_005fp-151"><code>mpfr_lessgreater_p</code></a>: <a href="#Comparison-Functions">Comparison Functions</a></li> |
|
3398 <li><a href="#index-mpfr_005flgamma-187"><code>mpfr_lgamma</code></a>: <a href="#Special-Functions">Special Functions</a></li> |
|
3399 <li><a href="#index-mpfr_005flngamma-186"><code>mpfr_lngamma</code></a>: <a href="#Special-Functions">Special Functions</a></li> |
|
3400 <li><a href="#index-mpfr_005flog-155"><code>mpfr_log</code></a>: <a href="#Special-Functions">Special Functions</a></li> |
|
3401 <li><a href="#index-mpfr_005flog10-157"><code>mpfr_log10</code></a>: <a href="#Special-Functions">Special Functions</a></li> |
|
3402 <li><a href="#index-mpfr_005flog1p-182"><code>mpfr_log1p</code></a>: <a href="#Special-Functions">Special Functions</a></li> |
|
3403 <li><a href="#index-mpfr_005flog2-156"><code>mpfr_log2</code></a>: <a href="#Special-Functions">Special Functions</a></li> |
|
3404 <li><a href="#index-mpfr_005fmax-233"><code>mpfr_max</code></a>: <a href="#Miscellaneous-Functions">Miscellaneous Functions</a></li> |
|
3405 <li><a href="#index-mpfr_005fmin-232"><code>mpfr_min</code></a>: <a href="#Miscellaneous-Functions">Miscellaneous Functions</a></li> |
|
3406 <li><a href="#index-mpfr_005fmul-99"><code>mpfr_mul</code></a>: <a href="#Basic-Arithmetic-Functions">Basic Arithmetic Functions</a></li> |
|
3407 <li><a href="#index-mpfr_005fmul_005f2exp-292"><code>mpfr_mul_2exp</code></a>: <a href="#Compatibility-with-MPF">Compatibility with MPF</a></li> |
|
3408 <li><a href="#index-mpfr_005fmul_005f2si-126"><code>mpfr_mul_2si</code></a>: <a href="#Basic-Arithmetic-Functions">Basic Arithmetic Functions</a></li> |
|
3409 <li><a href="#index-mpfr_005fmul_005f2ui-125"><code>mpfr_mul_2ui</code></a>: <a href="#Basic-Arithmetic-Functions">Basic Arithmetic Functions</a></li> |
|
3410 <li><a href="#index-mpfr_005fmul_005fq-103"><code>mpfr_mul_q</code></a>: <a href="#Basic-Arithmetic-Functions">Basic Arithmetic Functions</a></li> |
|
3411 <li><a href="#index-mpfr_005fmul_005fsi-101"><code>mpfr_mul_si</code></a>: <a href="#Basic-Arithmetic-Functions">Basic Arithmetic Functions</a></li> |
|
3412 <li><a href="#index-mpfr_005fmul_005fui-100"><code>mpfr_mul_ui</code></a>: <a href="#Basic-Arithmetic-Functions">Basic Arithmetic Functions</a></li> |
|
3413 <li><a href="#index-mpfr_005fmul_005fz-102"><code>mpfr_mul_z</code></a>: <a href="#Basic-Arithmetic-Functions">Basic Arithmetic Functions</a></li> |
|
3414 <li><a href="#index-mpfr_005fnan_005fp-142"><code>mpfr_nan_p</code></a>: <a href="#Comparison-Functions">Comparison Functions</a></li> |
|
3415 <li><a href="#index-mpfr_005fnanflag_005fp-280"><code>mpfr_nanflag_p</code></a>: <a href="#Exception-Related-Functions">Exception Related Functions</a></li> |
|
3416 <li><a href="#index-mpfr_005fneg-122"><code>mpfr_neg</code></a>: <a href="#Basic-Arithmetic-Functions">Basic Arithmetic Functions</a></li> |
|
3417 <li><a href="#index-mpfr_005fnextabove-230"><code>mpfr_nextabove</code></a>: <a href="#Miscellaneous-Functions">Miscellaneous Functions</a></li> |
|
3418 <li><a href="#index-mpfr_005fnextbelow-231"><code>mpfr_nextbelow</code></a>: <a href="#Miscellaneous-Functions">Miscellaneous Functions</a></li> |
|
3419 <li><a href="#index-mpfr_005fnexttoward-229"><code>mpfr_nexttoward</code></a>: <a href="#Miscellaneous-Functions">Miscellaneous Functions</a></li> |
|
3420 <li><a href="#index-mpfr_005fnumber_005fp-144"><code>mpfr_number_p</code></a>: <a href="#Comparison-Functions">Comparison Functions</a></li> |
|
3421 <li><a href="#index-mpfr_005fout_005fstr-212"><code>mpfr_out_str</code></a>: <a href="#Input-and-Output-Functions">Input and Output Functions</a></li> |
|
3422 <li><a href="#index-mpfr_005foverflow_005fp-279"><code>mpfr_overflow_p</code></a>: <a href="#Exception-Related-Functions">Exception Related Functions</a></li> |
|
3423 <li><a href="#index-mpfr_005fpow-116"><code>mpfr_pow</code></a>: <a href="#Basic-Arithmetic-Functions">Basic Arithmetic Functions</a></li> |
|
3424 <li><a href="#index-mpfr_005fpow_005fsi-118"><code>mpfr_pow_si</code></a>: <a href="#Basic-Arithmetic-Functions">Basic Arithmetic Functions</a></li> |
|
3425 <li><a href="#index-mpfr_005fpow_005fui-117"><code>mpfr_pow_ui</code></a>: <a href="#Basic-Arithmetic-Functions">Basic Arithmetic Functions</a></li> |
|
3426 <li><a href="#index-mpfr_005fpow_005fz-119"><code>mpfr_pow_z</code></a>: <a href="#Basic-Arithmetic-Functions">Basic Arithmetic Functions</a></li> |
|
3427 <li><a href="#index-mpfr_005fprec_005fround-253"><code>mpfr_prec_round</code></a>: <a href="#Rounding-Mode-Related-Functions">Rounding Mode Related Functions</a></li> |
|
3428 <li><a href="#index-mpfr_005fprint_005frnd_005fmode-255"><code>mpfr_print_rnd_mode</code></a>: <a href="#Rounding-Mode-Related-Functions">Rounding Mode Related Functions</a></li> |
|
3429 <li><a href="#index-mpfr_005frandom-235"><code>mpfr_random</code></a>: <a href="#Miscellaneous-Functions">Miscellaneous Functions</a></li> |
|
3430 <li><a href="#index-mpfr_005frandom2-236"><code>mpfr_random2</code></a>: <a href="#Miscellaneous-Functions">Miscellaneous Functions</a></li> |
|
3431 <li><a href="#index-mpfr_005freldiff-291"><code>mpfr_reldiff</code></a>: <a href="#Compatibility-with-MPF">Compatibility with MPF</a></li> |
|
3432 <li><a href="#index-mpfr_005fremainder-225"><code>mpfr_remainder</code></a>: <a href="#Integer-Related-Functions">Integer Related Functions</a></li> |
|
3433 <li><a href="#index-mpfr_005fremquo-226"><code>mpfr_remquo</code></a>: <a href="#Integer-Related-Functions">Integer Related Functions</a></li> |
|
3434 <li><a href="#index-mpfr_005frint-215"><code>mpfr_rint</code></a>: <a href="#Integer-Related-Functions">Integer Related Functions</a></li> |
|
3435 <li><a href="#index-mpfr_005frint_005fceil-220"><code>mpfr_rint_ceil</code></a>: <a href="#Integer-Related-Functions">Integer Related Functions</a></li> |
|
3436 <li><a href="#index-mpfr_005frint_005ffloor-221"><code>mpfr_rint_floor</code></a>: <a href="#Integer-Related-Functions">Integer Related Functions</a></li> |
|
3437 <li><a href="#index-mpfr_005frint_005fround-222"><code>mpfr_rint_round</code></a>: <a href="#Integer-Related-Functions">Integer Related Functions</a></li> |
|
3438 <li><a href="#index-mpfr_005frint_005ftrunc-223"><code>mpfr_rint_trunc</code></a>: <a href="#Integer-Related-Functions">Integer Related Functions</a></li> |
|
3439 <li><a href="#index-mpfr_005froot-115"><code>mpfr_root</code></a>: <a href="#Basic-Arithmetic-Functions">Basic Arithmetic Functions</a></li> |
|
3440 <li><a href="#index-mpfr_005fround-218"><code>mpfr_round</code></a>: <a href="#Integer-Related-Functions">Integer Related Functions</a></li> |
|
3441 <li><a href="#index-mpfr_005fround_005fprec-254"><code>mpfr_round_prec</code></a>: <a href="#Rounding-Mode-Related-Functions">Rounding Mode Related Functions</a></li> |
|
3442 <li><a href="#index-mpfr_005fsec-164"><code>mpfr_sec</code></a>: <a href="#Special-Functions">Special Functions</a></li> |
|
3443 <li><a href="#index-mpfr_005fsech-175"><code>mpfr_sech</code></a>: <a href="#Special-Functions">Special Functions</a></li> |
|
3444 <li><a href="#index-mpfr_005fset-31"><code>mpfr_set</code></a>: <a href="#Assignment-Functions">Assignment Functions</a></li> |
|
3445 <li><a href="#index-mpfr_005fset_005fd-36"><code>mpfr_set_d</code></a>: <a href="#Assignment-Functions">Assignment Functions</a></li> |
|
3446 <li><a href="#index-mpfr_005fset_005fdecimal64-38"><code>mpfr_set_decimal64</code></a>: <a href="#Assignment-Functions">Assignment Functions</a></li> |
|
3447 <li><a href="#index-mpfr_005fset_005fdefault_005fprec-26"><code>mpfr_set_default_prec</code></a>: <a href="#Initialization-Functions">Initialization Functions</a></li> |
|
3448 <li><a href="#index-mpfr_005fset_005fdefault_005frounding_005fmode-251"><code>mpfr_set_default_rounding_mode</code></a>: <a href="#Rounding-Mode-Related-Functions">Rounding Mode Related Functions</a></li> |
|
3449 <li><a href="#index-mpfr_005fset_005femax-260"><code>mpfr_set_emax</code></a>: <a href="#Exception-Related-Functions">Exception Related Functions</a></li> |
|
3450 <li><a href="#index-mpfr_005fset_005femin-259"><code>mpfr_set_emin</code></a>: <a href="#Exception-Related-Functions">Exception Related Functions</a></li> |
|
3451 <li><a href="#index-mpfr_005fset_005ferangeflag-276"><code>mpfr_set_erangeflag</code></a>: <a href="#Exception-Related-Functions">Exception Related Functions</a></li> |
|
3452 <li><a href="#index-mpfr_005fset_005fexp-238"><code>mpfr_set_exp</code></a>: <a href="#Miscellaneous-Functions">Miscellaneous Functions</a></li> |
|
3453 <li><a href="#index-mpfr_005fset_005ff-41"><code>mpfr_set_f</code></a>: <a href="#Assignment-Functions">Assignment Functions</a></li> |
|
3454 <li><a href="#index-mpfr_005fset_005finexflag-275"><code>mpfr_set_inexflag</code></a>: <a href="#Exception-Related-Functions">Exception Related Functions</a></li> |
|
3455 <li><a href="#index-mpfr_005fset_005finf-48"><code>mpfr_set_inf</code></a>: <a href="#Assignment-Functions">Assignment Functions</a></li> |
|
3456 <li><a href="#index-mpfr_005fset_005fld-37"><code>mpfr_set_ld</code></a>: <a href="#Assignment-Functions">Assignment Functions</a></li> |
|
3457 <li><a href="#index-mpfr_005fset_005fnan-49"><code>mpfr_set_nan</code></a>: <a href="#Assignment-Functions">Assignment Functions</a></li> |
|
3458 <li><a href="#index-mpfr_005fset_005fnanflag-274"><code>mpfr_set_nanflag</code></a>: <a href="#Exception-Related-Functions">Exception Related Functions</a></li> |
|
3459 <li><a href="#index-mpfr_005fset_005foverflow-273"><code>mpfr_set_overflow</code></a>: <a href="#Exception-Related-Functions">Exception Related Functions</a></li> |
|
3460 <li><a href="#index-mpfr_005fset_005fprec-28"><code>mpfr_set_prec</code></a>: <a href="#Initialization-Functions">Initialization Functions</a></li> |
|
3461 <li><a href="#index-mpfr_005fset_005fprec_005fraw-289"><code>mpfr_set_prec_raw</code></a>: <a href="#Compatibility-with-MPF">Compatibility with MPF</a></li> |
|
3462 <li><a href="#index-mpfr_005fset_005fq-40"><code>mpfr_set_q</code></a>: <a href="#Assignment-Functions">Assignment Functions</a></li> |
|
3463 <li><a href="#index-mpfr_005fset_005fsi-33"><code>mpfr_set_si</code></a>: <a href="#Assignment-Functions">Assignment Functions</a></li> |
|
3464 <li><a href="#index-mpfr_005fset_005fsi_005f2exp-43"><code>mpfr_set_si_2exp</code></a>: <a href="#Assignment-Functions">Assignment Functions</a></li> |
|
3465 <li><a href="#index-mpfr_005fset_005fsj-35"><code>mpfr_set_sj</code></a>: <a href="#Assignment-Functions">Assignment Functions</a></li> |
|
3466 <li><a href="#index-mpfr_005fset_005fsj_005f2exp-45"><code>mpfr_set_sj_2exp</code></a>: <a href="#Assignment-Functions">Assignment Functions</a></li> |
|
3467 <li><a href="#index-mpfr_005fset_005fstr-46"><code>mpfr_set_str</code></a>: <a href="#Assignment-Functions">Assignment Functions</a></li> |
|
3468 <li><a href="#index-mpfr_005fset_005fui-32"><code>mpfr_set_ui</code></a>: <a href="#Assignment-Functions">Assignment Functions</a></li> |
|
3469 <li><a href="#index-mpfr_005fset_005fui_005f2exp-42"><code>mpfr_set_ui_2exp</code></a>: <a href="#Assignment-Functions">Assignment Functions</a></li> |
|
3470 <li><a href="#index-mpfr_005fset_005fuj-34"><code>mpfr_set_uj</code></a>: <a href="#Assignment-Functions">Assignment Functions</a></li> |
|
3471 <li><a href="#index-mpfr_005fset_005fuj_005f2exp-44"><code>mpfr_set_uj_2exp</code></a>: <a href="#Assignment-Functions">Assignment Functions</a></li> |
|
3472 <li><a href="#index-mpfr_005fset_005funderflow-272"><code>mpfr_set_underflow</code></a>: <a href="#Exception-Related-Functions">Exception Related Functions</a></li> |
|
3473 <li><a href="#index-mpfr_005fset_005fz-39"><code>mpfr_set_z</code></a>: <a href="#Assignment-Functions">Assignment Functions</a></li> |
|
3474 <li><a href="#index-mpfr_005fsetsign-240"><code>mpfr_setsign</code></a>: <a href="#Miscellaneous-Functions">Miscellaneous Functions</a></li> |
|
3475 <li><a href="#index-mpfr_005fsgn-146"><code>mpfr_sgn</code></a>: <a href="#Comparison-Functions">Comparison Functions</a></li> |
|
3476 <li><a href="#index-mpfr_005fsi_005fdiv-108"><code>mpfr_si_div</code></a>: <a href="#Basic-Arithmetic-Functions">Basic Arithmetic Functions</a></li> |
|
3477 <li><a href="#index-mpfr_005fsi_005fsub-95"><code>mpfr_si_sub</code></a>: <a href="#Basic-Arithmetic-Functions">Basic Arithmetic Functions</a></li> |
|
3478 <li><a href="#index-mpfr_005fsignbit-239"><code>mpfr_signbit</code></a>: <a href="#Miscellaneous-Functions">Miscellaneous Functions</a></li> |
|
3479 <li><a href="#index-mpfr_005fsin-162"><code>mpfr_sin</code></a>: <a href="#Special-Functions">Special Functions</a></li> |
|
3480 <li><a href="#index-mpfr_005fsin_005fcos-167"><code>mpfr_sin_cos</code></a>: <a href="#Special-Functions">Special Functions</a></li> |
|
3481 <li><a href="#index-mpfr_005fsinh-173"><code>mpfr_sinh</code></a>: <a href="#Special-Functions">Special Functions</a></li> |
|
3482 <li><a href="#index-mpfr_005fsqr-104"><code>mpfr_sqr</code></a>: <a href="#Basic-Arithmetic-Functions">Basic Arithmetic Functions</a></li> |
|
3483 <li><a href="#index-mpfr_005fsqrt-112"><code>mpfr_sqrt</code></a>: <a href="#Basic-Arithmetic-Functions">Basic Arithmetic Functions</a></li> |
|
3484 <li><a href="#index-mpfr_005fsqrt_005fui-113"><code>mpfr_sqrt_ui</code></a>: <a href="#Basic-Arithmetic-Functions">Basic Arithmetic Functions</a></li> |
|
3485 <li><a href="#index-mpfr_005fstrtofr-47"><code>mpfr_strtofr</code></a>: <a href="#Assignment-Functions">Assignment Functions</a></li> |
|
3486 <li><a href="#index-mpfr_005fsub-92"><code>mpfr_sub</code></a>: <a href="#Basic-Arithmetic-Functions">Basic Arithmetic Functions</a></li> |
|
3487 <li><a href="#index-mpfr_005fsub_005fq-98"><code>mpfr_sub_q</code></a>: <a href="#Basic-Arithmetic-Functions">Basic Arithmetic Functions</a></li> |
|
3488 <li><a href="#index-mpfr_005fsub_005fsi-96"><code>mpfr_sub_si</code></a>: <a href="#Basic-Arithmetic-Functions">Basic Arithmetic Functions</a></li> |
|
3489 <li><a href="#index-mpfr_005fsub_005fui-94"><code>mpfr_sub_ui</code></a>: <a href="#Basic-Arithmetic-Functions">Basic Arithmetic Functions</a></li> |
|
3490 <li><a href="#index-mpfr_005fsub_005fz-97"><code>mpfr_sub_z</code></a>: <a href="#Basic-Arithmetic-Functions">Basic Arithmetic Functions</a></li> |
|
3491 <li><a href="#index-mpfr_005fsubnormalize-266"><code>mpfr_subnormalize</code></a>: <a href="#Exception-Related-Functions">Exception Related Functions</a></li> |
|
3492 <li><a href="#index-mpfr_005fsum-207"><code>mpfr_sum</code></a>: <a href="#Special-Functions">Special Functions</a></li> |
|
3493 <li><a href="#index-mpfr_005fswap-50"><code>mpfr_swap</code></a>: <a href="#Assignment-Functions">Assignment Functions</a></li> |
|
3494 <li><a href="#index-g_t_0040code_007bmpfr_005ft_007d-12"><code>mpfr_t</code></a>: <a href="#MPFR-Basics">MPFR Basics</a></li> |
|
3495 <li><a href="#index-mpfr_005ftan-163"><code>mpfr_tan</code></a>: <a href="#Special-Functions">Special Functions</a></li> |
|
3496 <li><a href="#index-mpfr_005ftanh-174"><code>mpfr_tanh</code></a>: <a href="#Special-Functions">Special Functions</a></li> |
|
3497 <li><a href="#index-mpfr_005ftrunc-219"><code>mpfr_trunc</code></a>: <a href="#Integer-Related-Functions">Integer Related Functions</a></li> |
|
3498 <li><a href="#index-mpfr_005fui_005fdiv-106"><code>mpfr_ui_div</code></a>: <a href="#Basic-Arithmetic-Functions">Basic Arithmetic Functions</a></li> |
|
3499 <li><a href="#index-mpfr_005fui_005fpow-121"><code>mpfr_ui_pow</code></a>: <a href="#Basic-Arithmetic-Functions">Basic Arithmetic Functions</a></li> |
|
3500 <li><a href="#index-mpfr_005fui_005fpow_005fui-120"><code>mpfr_ui_pow_ui</code></a>: <a href="#Basic-Arithmetic-Functions">Basic Arithmetic Functions</a></li> |
|
3501 <li><a href="#index-mpfr_005fui_005fsub-93"><code>mpfr_ui_sub</code></a>: <a href="#Basic-Arithmetic-Functions">Basic Arithmetic Functions</a></li> |
|
3502 <li><a href="#index-mpfr_005funderflow_005fp-278"><code>mpfr_underflow_p</code></a>: <a href="#Exception-Related-Functions">Exception Related Functions</a></li> |
|
3503 <li><a href="#index-mpfr_005funordered_005fp-153"><code>mpfr_unordered_p</code></a>: <a href="#Comparison-Functions">Comparison Functions</a></li> |
|
3504 <li><a href="#index-mpfr_005furandomb-234"><code>mpfr_urandomb</code></a>: <a href="#Miscellaneous-Functions">Miscellaneous Functions</a></li> |
|
3505 <li><a href="#index-MPFR_005fVERSION-243"><code>MPFR_VERSION</code></a>: <a href="#Miscellaneous-Functions">Miscellaneous Functions</a></li> |
|
3506 <li><a href="#index-MPFR_005fVERSION_005fMAJOR-244"><code>MPFR_VERSION_MAJOR</code></a>: <a href="#Miscellaneous-Functions">Miscellaneous Functions</a></li> |
|
3507 <li><a href="#index-MPFR_005fVERSION_005fMINOR-245"><code>MPFR_VERSION_MINOR</code></a>: <a href="#Miscellaneous-Functions">Miscellaneous Functions</a></li> |
|
3508 <li><a href="#index-MPFR_005fVERSION_005fNUM-248"><code>MPFR_VERSION_NUM</code></a>: <a href="#Miscellaneous-Functions">Miscellaneous Functions</a></li> |
|
3509 <li><a href="#index-MPFR_005fVERSION_005fPATCHLEVEL-246"><code>MPFR_VERSION_PATCHLEVEL</code></a>: <a href="#Miscellaneous-Functions">Miscellaneous Functions</a></li> |
|
3510 <li><a href="#index-MPFR_005fVERSION_005fSTRING-247"><code>MPFR_VERSION_STRING</code></a>: <a href="#Miscellaneous-Functions">Miscellaneous Functions</a></li> |
|
3511 <li><a href="#index-mpfr_005fy0-195"><code>mpfr_y0</code></a>: <a href="#Special-Functions">Special Functions</a></li> |
|
3512 <li><a href="#index-mpfr_005fy1-196"><code>mpfr_y1</code></a>: <a href="#Special-Functions">Special Functions</a></li> |
|
3513 <li><a href="#index-mpfr_005fyn-197"><code>mpfr_yn</code></a>: <a href="#Special-Functions">Special Functions</a></li> |
|
3514 <li><a href="#index-mpfr_005fzero_005fp-145"><code>mpfr_zero_p</code></a>: <a href="#Comparison-Functions">Comparison Functions</a></li> |
|
3515 <li><a href="#index-mpfr_005fzeta-188"><code>mpfr_zeta</code></a>: <a href="#Special-Functions">Special Functions</a></li> |
|
3516 <li><a href="#index-mpfr_005fzeta_005fui-189"><code>mpfr_zeta_ui</code></a>: <a href="#Special-Functions">Special Functions</a></li> |
|
3517 </ul></body></html> |
|
3518 |
|
3519 <!-- |
|
3520 |
|
3521 Local Variables: |
|
3522 coding: iso-8859-1 |
|
3523 End: |
|
3524 |
|
3525 --> |