gfiber / toolchains / bruno / f0dcd7f7efd6f7b917902cadf4d492dcb3676093 / . / usr / share / info / mpc.info

This is mpc.info, produced by makeinfo version 5.2 from mpc.texi. | |

This manual is for GNU MPC, a library for multiple precision complex | |

arithmetic, version 1.0.3 of February 2015. | |

Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, | |

2011, 2012 INRIA | |

Permission is granted to copy, distribute and/or modify this | |

document under the terms of the GNU Free Documentation License, | |

Version 1.3 or any later version published by the Free Software | |

Foundation; with no Invariant Sections. A copy of the license is | |

included in the section entitled "GNU Free Documentation License." | |

INFO-DIR-SECTION GNU Packages | |

START-INFO-DIR-ENTRY | |

* mpc: (mpc)Multiple Precision Complex Library. | |

END-INFO-DIR-ENTRY | |

File: mpc.info, Node: Top, Next: Copying, Up: (dir) | |

GNU MPC | |

******* | |

This manual documents how to install and use the GNU Multiple Precision | |

Complex Library, version 1.0.3 | |

* Menu: | |

* Copying:: GNU MPC Copying Conditions (LGPL). | |

* Introduction to GNU MPC:: Brief introduction to GNU MPC. | |

* Installing GNU MPC:: How to configure and compile the GNU MPC library. | |

* Reporting Bugs:: How to usefully report bugs. | |

* GNU MPC Basics:: What every GNU MPC user should know. | |

* Complex Functions:: Functions for arithmetic on complex numbers. | |

* References:: | |

* Concept Index:: | |

* Function Index:: | |

* GNU Free Documentation License:: | |

File: mpc.info, Node: Copying, Next: Introduction to GNU MPC, Prev: Top, Up: Top | |

GNU MPC Copying Conditions | |

************************** | |

GNU MPC is free software; you can redistribute it and/or modify it under | |

the terms of the GNU Lesser General Public License as published by the | |

Free Software Foundation; either version 3 of the License, or (at your | |

option) any later version. | |

GNU MPC is distributed in the hope that it will be useful, but | |

WITHOUT ANY WARRANTY; without even the implied warranty of | |

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser | |

General Public License for more details. | |

You should have received a copy of the GNU Lesser General Public | |

License along with this program. If not, see | |

<http://www.gnu.org/licenses/>. | |

File: mpc.info, Node: Introduction to GNU MPC, Next: Installing GNU MPC, Prev: Copying, Up: Top | |

1 Introduction to GNU MPC | |

************************* | |

GNU MPC is a portable library written in C for arbitrary precision | |

arithmetic on complex numbers providing correct rounding. It implements | |

a multiprecision equivalent of the C99 standard. It builds upon the GNU | |

MP and the GNU MPFR libraries. | |

1.1 How to use this Manual | |

========================== | |

Everyone should read *note GNU MPC Basics::. If you need to install the | |

library yourself, you need to read *note Installing GNU MPC::, too. | |

The remainder of the manual can be used for later reference, although | |

it is probably a good idea to skim through it. | |

File: mpc.info, Node: Installing GNU MPC, Next: Reporting Bugs, Prev: Introduction to GNU MPC, Up: Top | |

2 Installing GNU MPC | |

******************** | |

To build GNU MPC, you first have to install GNU MP (version 4.3.2 or | |

higher) and GNU MPFR (version 2.4.2 or higher) on your computer. You | |

need a C compiler; GCC version 4.4 or higher is recommended, since GNU | |

MPC may trigger a bug in previous versions, see the thread at | |

<http://lists.gforge.inria.fr/pipermail/mpc-discuss/2011-February/000823.html>. | |

And you need a standard Unix 'make' program, plus some other standard | |

Unix utility programs. | |

Here are the steps needed to install the library on Unix systems: | |

1. 'tar xzf mpc-1.0.3.tar.gz' | |

2. 'cd mpc-1.0.3' | |

3. './configure' | |

if GMP and GNU MPFR are installed into standard directories, that | |

is, directories that are searched by default by the compiler and | |

the linking tools. | |

'./configure --with-gmp=<gmp_install_dir>' | |

is used to indicate a different location where GMP is installed. | |

Alternatively, you can specify directly GMP include and GMP lib | |

directories with './configure --with-gmp-lib=<gmp_lib_dir> | |

--with-gmp-include=<gmp_include_dir>'. | |

'./configure --with-mpfr=<mpfr_install_dir>' | |

is used to indicate a different location where GNU MPFR is | |

installed. Alternatively, you can specify directly GNU MPFR | |

include and GNU MPFR lib directories with './configure | |

--with-mpf-lib=<mpfr_lib_dir> | |

--with-mpfr-include=<mpfr_include_dir>'. | |

Another useful parameter is '--prefix', which can be used to | |

specify an alternative installation location instead of | |

'/usr/local'; see 'make install' below. | |

To enable checking for memory leaks using 'valgrind' during 'make | |

check', add the parameter '--enable-valgrind-tests'. | |

If for debugging purposes you wish to log calls to GNU MPC | |

functions from within your code, add the parameter | |

'--enable-logging'. In your code, replace the inclusion of 'mpc.h' | |

by 'mpc-log.h' and link the executable dynamically. Then all calls | |

to functions with only complex arguments are printed to 'stderr' in | |

the following form: First, the function name is given, followed by | |

its type such as 'c_cc', meaning that the function has one complex | |

result (one 'c' in front of the '_'), computed from two complex | |

arguments (two 'c' after the '_'). Then, the precisions of the | |

real and the imaginary part of the first result is given, followed | |

by the second one and so on. Finally, for each argument, the | |

precisions of its real and imaginary part are specified and the | |

argument itself is printed in hexadecimal via the function | |

'mpc_out_str' (*note String and Stream Input and Output::). The | |

option requires a dynamic library, so it may not be combined with | |

'--disable-shared'. | |

Use './configure --help' for an exhaustive list of parameters. | |

4. 'make' | |

This compiles GNU MPC in the working directory. | |

5. 'make check' | |

This will make sure GNU MPC was built correctly. | |

If you get error messages, please report them to | |

'mpc-discuss@lists.gforge.inria.fr' (*Note Reporting Bugs::, for | |

information on what to include in useful bug reports). | |

6. 'make install' | |

This will copy the file 'mpc.h' to the directory | |

'/usr/local/include', the file 'libmpc.a' to the directory | |

'/usr/local/lib', and the file 'mpc.info' to the directory | |

'/usr/local/share/info' (or if you passed the '--prefix' option to | |

'configure', using the prefix directory given as argument to | |

'--prefix' instead of '/usr/local'). Note: you need write | |

permissions on these directories. | |

2.1 Other 'make' Targets | |

======================== | |

There are some other useful make targets: | |

* 'info' | |

Create an info version of the manual, in 'mpc.info'. | |

* 'pdf' | |

Create a PDF version of the manual, in 'doc/mpc.pdf'. | |

* 'dvi' | |

Create a DVI version of the manual, in 'doc/mpc.dvi'. | |

* 'ps' | |

Create a Postscript version of the manual, in 'doc/mpc.ps'. | |

* 'html' | |

Create an HTML version of the manual, in several pages in the | |

directory 'doc/mpc.html'; if you want only one output HTML file, | |

then type 'makeinfo --html --no-split mpc.texi' instead. | |

* 'clean' | |

Delete all object files and archive files, but not the | |

configuration files. | |

* 'distclean' | |

Delete all files not included in the distribution. | |

* 'uninstall' | |

Delete all files copied by 'make install'. | |

2.2 Known Build Problems | |

======================== | |

On AIX, if GMP was built with the 64-bit ABI, before building and | |

testing GNU MPC, it might be necessary to set the 'OBJECT_MODE' | |

environment variable to 64 by, e.g., | |

'export OBJECT_MODE=64' | |

This has been tested with the C compiler IBM XL C/C++ Enterprise | |

Edition V8.0 for AIX, version: 08.00.0000.0021, GMP 4.2.4 and GNU MPFR | |

2.4.1. | |

Please report any other problems you encounter to | |

'mpc-discuss@lists.gforge.inria.fr'. *Note Reporting Bugs::. | |

File: mpc.info, Node: Reporting Bugs, Next: GNU MPC Basics, Prev: Installing GNU MPC, Up: Top | |

3 Reporting Bugs | |

**************** | |

If you think you have found a bug in the GNU MPC library, please | |

investigate and report it. We have made this library available to you, | |

and it is not to ask too much from you, to ask you to report the bugs | |

that you find. | |

There are a few things you should think about when you put your bug | |

report together. | |

You have to send us a test case that makes it possible for us to | |

reproduce the bug. Include instructions on how to run the test case. | |

You also have to explain what is wrong; if you get a crash, or if the | |

results printed are incorrect and in that case, in what way. | |

Please include compiler version information in your bug report. This | |

can be extracted using 'gcc -v', or 'cc -V' on some machines. Also, | |

include the output from 'uname -a'. | |

If your bug report is good, we will do our best to help you to get a | |

corrected version of the library; if the bug report is poor, we will not | |

do anything about it (aside of chiding you to send better bug reports). | |

Send your bug report to: 'mpc-discuss@lists.gforge.inria.fr'. | |

If you think something in this manual is unclear, or downright | |

incorrect, or if the language needs to be improved, please send a note | |

to the same address. | |

File: mpc.info, Node: GNU MPC Basics, Next: Complex Functions, Prev: Reporting Bugs, Up: Top | |

4 GNU MPC Basics | |

**************** | |

All declarations needed to use GNU MPC are collected in the include file | |

'mpc.h'. It is designed to work with both C and C++ compilers. You | |

should include that file in any program using the GNU MPC library by | |

adding the line | |

#include "mpc.h" | |

4.1 Nomenclature and Types | |

========================== | |

"Complex number" or "Complex" for short, is a pair of two arbitrary | |

precision floating-point numbers (for the real and imaginary parts). | |

The C data type for such objects is 'mpc_t'. | |

The "Precision" is the number of bits used to represent the mantissa of | |

the real and imaginary parts; the corresponding C data type is | |

'mpfr_prec_t'. For more details on the allowed precision range, *note | |

(mpfr.info)Nomenclature and Types::. | |

The "rounding mode" specifies the way to round the result of a complex | |

operation, in case the exact result can not be represented exactly in | |

the destination mantissa; the corresponding C data type is 'mpc_rnd_t'. | |

A complex rounding mode is a pair of two rounding modes: one for the | |

real part, one for the imaginary part. | |

4.2 Function Classes | |

==================== | |

There is only one class of functions in the GNU MPC library, namely | |

functions for complex arithmetic. The function names begin with 'mpc_'. | |

The associated type is 'mpc_t'. | |

4.3 GNU MPC Variable Conventions | |

================================ | |

As a general rule, all GNU MPC functions expect output arguments before | |

input arguments. This notation is based on an analogy with the | |

assignment operator. | |

GNU MPC allows you to use the same variable for both input and output | |

in the same expression. For example, the main function for | |

floating-point multiplication, 'mpc_mul', can be used like this: | |

'mpc_mul (x, x, x, rnd_mode)'. This computes the square of X with | |

rounding mode 'rnd_mode' and puts the result back in X. | |

Before you can assign to an GNU MPC variable, you need to initialize | |

it by calling one of the special initialization functions. When you are | |

done with a variable, you need to clear it out, using one of the | |

functions for that purpose. | |

A variable should only be initialized once, or at least cleared out | |

between each initialization. After a variable has been initialized, it | |

may be assigned to any number of times. | |

For efficiency reasons, avoid to initialize and clear out a variable | |

in loops. Instead, initialize it before entering the loop, and clear it | |

out after the loop has exited. | |

You do not need to be concerned about allocating additional space for | |

GNU MPC variables, since each of its real and imaginary part has a | |

mantissa of fixed size. Hence unless you change its precision, or clear | |

and reinitialize it, a complex variable will have the same allocated | |

space during all its life. | |

4.4 Rounding Modes | |

================== | |

A complex rounding mode is of the form 'MPC_RNDxy' where 'x' and 'y' are | |

one of 'N' (to nearest), 'Z' (towards zero), 'U' (towards plus | |

infinity), 'D' (towards minus infinity). The first letter refers to the | |

rounding mode for the real part, and the second one for the imaginary | |

part. For example 'MPC_RNDZU' indicates to round the real part towards | |

zero, and the imaginary part towards plus infinity. | |

The 'round to nearest' mode works as in the IEEE P754 standard: in | |

case the number to be rounded lies exactly in the middle of two | |

representable numbers, it is rounded to the one with the least | |

significant bit set to zero. For example, the number 5, which is | |

represented by (101) in binary, is rounded to (100)=4 with a precision | |

of two bits, and not to (110)=6. | |

4.5 Return Value | |

================ | |

Most GNU MPC functions have a return value of type 'int', which is used | |

to indicate the position of the rounded real and imaginary parts with | |

respect to the exact (infinite precision) values. If this integer is | |

'i', the macros 'MPC_INEX_RE(i)' and 'MPC_INEX_IM(i)' give 0 if the | |

corresponding rounded value is exact, a negative value if the rounded | |

value is less than the exact one, and a positive value if it is greater | |

than the exact one. Similarly, functions computing a result of type | |

'mpfr_t' return an integer that is 0, positive or negative depending on | |

whether the rounded value is the same, larger or smaller then the exact | |

result. | |

Some functions, such as 'mpc_sin_cos', compute two complex results; | |

the macros 'MPC_INEX1(i)' and 'MPC_INEX2(i)', applied to the return | |

value 'i' of such a function, yield the exactness value corresponding to | |

the first or the second computed value, respectively. | |

4.6 Branch Cuts And Special Values | |

================================== | |

Some complex functions have branch cuts, across which the function is | |

discontinous. In GNU MPC, the branch cuts chosen are the same as those | |

specified for the corresponding functions in the ISO C99 standard. | |

Likewise, when evaluated at a point whose real or imaginary part is | |

either infinite or a NaN or a signed zero, a function returns the same | |

value as those specified for the corresponding function in the ISO C99 | |

standard. | |

File: mpc.info, Node: Complex Functions, Next: References, Prev: GNU MPC Basics, Up: Top | |

5 Complex Functions | |

******************* | |

The complex functions expect arguments of type 'mpc_t'. | |

The GNU MPC floating-point functions have an interface that is | |

similar to the GNU MP integer functions. The function prefix for | |

operations on complex numbers is 'mpc_'. | |

The precision of a computation is defined as follows: Compute the | |

requested operation exactly (with "infinite precision"), and round the | |

result to the destination variable precision with the given rounding | |

mode. | |

The GNU MPC complex functions are intended to be a smooth extension | |

of the IEEE P754 arithmetic. The results obtained on one computer | |

should not differ from the results obtained on a computer with a | |

different word size. | |

* Menu: | |

* Initializing Complex Numbers:: | |

* Assigning Complex Numbers:: | |

* Converting Complex Numbers:: | |

* String and Stream Input and Output:: | |

* Complex Comparison:: | |

* Projection & Decomposing:: | |

* Basic Arithmetic:: | |

* Power Functions and Logarithm:: | |

* Trigonometric Functions:: | |

* Miscellaneous Complex Functions:: | |

* Advanced Functions:: | |

* Internals:: | |

File: mpc.info, Node: Initializing Complex Numbers, Next: Assigning Complex Numbers, Up: Complex Functions | |

5.1 Initialization Functions | |

============================ | |

An 'mpc_t' object must be initialized before storing the first value in | |

it. The functions 'mpc_init2' and 'mpc_init3' are used for that | |

purpose. | |

-- Function: void mpc_init2 (mpc_t Z, mpfr_prec_t PREC) | |

Initialize Z to precision PREC bits and set its real and imaginary | |

parts to NaN. Normally, a variable should be initialized once only | |

or at least be cleared, using 'mpc_clear', between initializations. | |

-- Function: void mpc_init3 (mpc_t Z, mpfr_prec_t PREC_R, mpfr_prec_t | |

PREC_I) | |

Initialize Z with the precision of its real part being PREC_R bits | |

and the precision of its imaginary part being PREC_I bits, and set | |

the real and imaginary parts to NaN. | |

-- Function: void mpc_clear (mpc_t Z) | |

Free the space occupied by Z. Make sure to call this function for | |

all 'mpc_t' variables when you are done with them. | |

Here is an example on how to initialize complex variables: | |

{ | |

mpc_t x, y; | |

mpc_init2 (x, 256); /* precision _exactly_ 256 bits */ | |

mpc_init3 (y, 100, 50); /* 100/50 bits for the real/imaginary part */ | |

... | |

mpc_clear (x); | |

mpc_clear (y); | |

} | |

The following function is useful for changing the precision during a | |

calculation. A typical use would be for adjusting the precision | |

gradually in iterative algorithms like Newton-Raphson, making the | |

computation precision closely match the actual accurate part of the | |

numbers. | |

-- Function: void mpc_set_prec (mpc_t X, mpfr_prec_t PREC) | |

Reset the precision of X to be *exactly* PREC bits, and set its | |

real/imaginary parts to NaN. The previous value stored in X is | |

lost. It is equivalent to a call to 'mpc_clear(x)' followed by a | |

call to 'mpc_init2(x, prec)', but more efficient as no allocation | |

is done in case the current allocated space for the mantissa of X | |

is sufficient. | |

-- Function: mpfr_prec_t mpc_get_prec (mpc_t X) | |

If the real and imaginary part of X have the same precision, it is | |

returned, otherwise, 0 is returned. | |

-- Function: void mpc_get_prec2 (mpfr_prec_t* PR, mpfr_prec_t* PI, | |

mpc_t X) | |

Returns the precision of the real part of X via PR and of its | |

imaginary part via PI. | |

File: mpc.info, Node: Assigning Complex Numbers, Next: Converting Complex Numbers, Prev: Initializing Complex Numbers, Up: Complex Functions | |

5.2 Assignment Functions | |

======================== | |

These functions assign new values to already initialized complex numbers | |

(*note Initializing Complex Numbers::). When using any functions with | |

'intmax_t' or 'uintmax_t' parameters, you must include '<stdint.h>' or | |

'<inttypes.h>' _before_ 'mpc.h', to allow 'mpc.h' to define prototypes | |

for these functions. Similarly, functions with parameters of type | |

'complex' or 'long complex' are defined only if '<complex.h>' is | |

included _before_ 'mpc.h'. If you need assignment functions that are | |

not in the current API, you can define them using the 'MPC_SET_X_Y' | |

macro (*note Advanced Functions::). | |

-- Function: int mpc_set (mpc_t ROP, mpc_t OP, mpc_rnd_t RND) | |

Set the value of ROP from OP, rounded to the precision of ROP with | |

the given rounding mode RND. | |

-- Function: int mpc_set_ui (mpc_t ROP, unsigned long int OP, mpc_rnd_t | |

RND) | |

-- Function: int mpc_set_si (mpc_t ROP, long int OP, mpc_rnd_t RND) | |

-- Function: int mpc_set_uj (mpc_t ROP, uintmax_t OP, mpc_rnd_t RND) | |

-- Function: int mpc_set_sj (mpc_t ROP, intmax_t OP, mpc_rnd_t RND) | |

-- Function: int mpc_set_d (mpc_t ROP, double OP, mpc_rnd_t RND) | |

-- Function: int mpc_set_ld (mpc_t ROP, long double OP, mpc_rnd_t RND) | |

-- Function: int mpc_set_dc (mpc_t ROP, double _Complex OP, mpc_rnd_t | |

RND) | |

-- Function: int mpc_set_ldc (mpc_t ROP, long double _Complex OP, | |

mpc_rnd_t RND) | |

-- Function: int mpc_set_z (mpc_t ROP, mpz_t OP mpc_rnd_t RND) | |

-- Function: int mpc_set_q (mpc_t ROP, mpq_t OP mpc_rnd_t RND) | |

-- Function: int mpc_set_f (mpc_t ROP, mpf_t OP mpc_rnd_t RND) | |

-- Function: int mpc_set_fr (mpc_t ROP, mpfr_t OP, mpc_rnd_t RND) | |

Set the value of ROP from OP, rounded to the precision of ROP with | |

the given rounding mode RND. The argument OP is interpreted as | |

real, so the imaginary part of ROP is set to zero with a positive | |

sign. Please note that even a 'long int' may have to be rounded, | |

if the destination precision is less than the machine word width. | |

For 'mpc_set_d', be careful that the input number OP may not be | |

exactly representable as a double-precision number (this happens | |

for 0.1 for instance), in which case it is first rounded by the C | |

compiler to a double-precision number, and then only to a complex | |

number. | |

-- Function: int mpc_set_ui_ui (mpc_t ROP, unsigned long int OP1, | |

unsigned long int OP2, mpc_rnd_t RND) | |

-- Function: int mpc_set_si_si (mpc_t ROP, long int OP1, long int OP2, | |

mpc_rnd_t RND) | |

-- Function: int mpc_set_uj_uj (mpc_t ROP, uintmax_t OP1, uintmax_t | |

OP2, mpc_rnd_t RND) | |

-- Function: int mpc_set_sj_sj (mpc_t ROP, intmax_t OP1, intmax_t OP2, | |

mpc_rnd_t RND) | |

-- Function: int mpc_set_d_d (mpc_t ROP, double OP1, double OP2, | |

mpc_rnd_t RND) | |

-- Function: int mpc_set_ld_ld (mpc_t ROP, long double OP1, long double | |

OP2, mpc_rnd_t RND) | |

-- Function: int mpc_set_z_z (mpc_t ROP, mpz_t OP1, mpz_t OP2, | |

mpc_rnd_t RND) | |

-- Function: int mpc_set_q_q (mpc_t ROP, mpq_t OP1, mpq_t OP2, | |

mpc_rnd_t RND) | |

-- Function: int mpc_set_f_f (mpc_t ROP, mpf_t OP1, mpf_t OP2, | |

mpc_rnd_t RND) | |

-- Function: int mpc_set_fr_fr (mpc_t ROP, mpfr_t OP1, mpfr_t OP2, | |

mpc_rnd_t RND) | |

Set the real part of ROP from OP1, and its imaginary part from OP2, | |

according to the rounding mode RND. | |

Beware that the behaviour of 'mpc_set_fr_fr' is undefined if OP1 or | |

OP2 is a pointer to the real or imaginary part of ROP. To exchange | |

the real and the imaginary part of a complex number, either use | |

'mpfr_swap (mpc_realref (rop), mpc_imagref (rop))', which also | |

exchanges the precisions of the two parts; or use a temporary | |

variable. | |

For functions assigning complex variables from strings or input | |

streams, *note String and Stream Input and Output::. | |

-- Function: void mpc_set_nan (mpc_t ROP) | |

Set ROP to Nan+i*NaN. | |

-- Function: void mpc_swap (mpc_t OP1, mpc_t OP2) | |

Swap the values of OP1 and OP2 efficiently. Warning: The | |

precisions are exchanged, too; in case these are different, | |

'mpc_swap' is thus not equivalent to three 'mpc_set' calls using a | |

third auxiliary variable. | |

File: mpc.info, Node: Converting Complex Numbers, Next: String and Stream Input and Output, Prev: Assigning Complex Numbers, Up: Complex Functions | |

5.3 Conversion Functions | |

======================== | |

The following functions are available only if '<complex.h>' is included | |

_before_ 'mpc.h'. | |

-- Function: double _Complex mpc_get_dc (mpc_t OP, mpc_rnd_t RND) | |

-- Function: long double _Complex mpc_get_ldc (mpc_t OP, mpc_rnd_t RND) | |

Convert OP to a C complex number, using the rounding mode RND. | |

For functions converting complex variables to strings or stream | |

output, *note String and Stream Input and Output::. | |

File: mpc.info, Node: String and Stream Input and Output, Next: Complex Comparison, Prev: Converting Complex Numbers, Up: Complex Functions | |

5.4 String and Stream Input and Output | |

====================================== | |

-- Function: int mpc_strtoc (mpc_t ROP, const char *NPTR, char | |

**ENDPTR, int BASE, mpc_rnd_t RND) | |

Read a complex number from a string NPTR in base BASE, rounded to | |

the precision of ROP with the given rounding mode RND. The BASE | |

must be either 0 or a number from 2 to 36 (otherwise the behaviour | |

is undefined). If NPTR starts with valid data, the result is | |

stored in ROP, the usual inexact value is returned (*note Return | |

Value: return-value.) and, if ENDPTR is not the null pointer, | |

*ENDPTR points to the character just after the valid data. | |

Otherwise, ROP is set to 'NaN + i * NaN', -1 is returned and, if | |

ENDPTR is not the null pointer, the value of NPTR is stored in the | |

location referenced by ENDPTR. | |

The expected form of a complex number string is either a real | |

number (an optional leading whitespace, an optional sign followed | |

by a floating-point number), or a pair of real numbers in | |

parentheses separated by whitespace. If a real number is read, the | |

missing imaginary part is set to +0. The form of a floating-point | |

number depends on the base and is described in the documentation of | |

'mpfr_strtofr' (*note (mpfr.info)Assignment Functions::). For | |

instance, '"3.1415926"', '"(1.25e+7 +.17)"', '"(@nan@ 2)"' and | |

'"(-0 -7)"' are valid strings for BASE = 10. If BASE = 0, then a | |

prefix may be used to indicate the base in which the floating-point | |

number is written. Use prefix '0b' for binary numbers, prefix '0x' | |

for hexadecimal numbers, and no prefix for decimal numbers. The | |

real and imaginary part may then be written in different bases. | |

For instance, '"(1.024e+3 +2.05e+3)"' and '"(0b1p+10 +0x802)"' are | |

valid strings for 'base'=0 and represent the same value. | |

-- Function: int mpc_set_str (mpc_t ROP, const char *S, int BASE, | |

mpc_rnd_t rnd) | |

Set ROP to the value of the string S in base BASE, rounded to the | |

precision of ROP with the given rounding mode RND. See the | |

documentation of 'mpc_strtoc' for a detailed description of the | |

valid string formats. Contrarily to 'mpc_strtoc', 'mpc_set_str' | |

requires the _whole_ string to represent a valid complex number | |

(potentially followed by additional white space). This function | |

returns the usual inexact value (*note Return Value: return-value.) | |

if the entire string up to the final null character is a valid | |

number in base BASE; otherwise it returns -1, and ROP is set to | |

NaN+i*NaN. | |

-- Function: char * mpc_get_str (int B, size_t N, mpc_t OP, mpc_rnd_t | |

RND) | |

Convert OP to a string containing its real and imaginary parts, | |

separated by a space and enclosed in a pair of parentheses. The | |

numbers are written in base B (which may vary from 2 to 36) and | |

rounded according to RND. The number of significant digits, at | |

least 2, is given by N. It is also possible to let N be zero, in | |

which case the number of digits is chosen large enough so that | |

re-reading the printed value with the same precision, assuming both | |

output and input use rounding to nearest, will recover the original | |

value of OP. Note that 'mpc_get_str' uses the decimal point of the | |

current locale if available, and '.' otherwise. | |

The string is generated using the current memory allocation | |

function ('malloc' by default, unless it has been modified using | |

the custom memory allocation interface of 'gmp'); once it is not | |

needed any more, it should be freed by calling 'mpc_free_str'. | |

-- Function: void mpc_free_str (char *STR) | |

Free the string STR, which needs to have been allocated by a call | |

to 'mpc_get_str'. | |

The following two functions read numbers from input streams and write | |

them to output streams. When using any of these functions, you need to | |

include 'stdio.h' _before_ 'mpc.h'. | |

-- Function: int mpc_inp_str (mpc_t ROP, FILE *STREAM, size_t *READ, | |

int BASE, mpc_rnd_t RND) | |

Input a string in base BASE in the same format as for 'mpc_strtoc' | |

from stdio stream STREAM, rounded according to RND, and put the | |

read complex number into ROP. If STREAM is the null pointer, ROP | |

is read from 'stdin'. Return the usual inexact value; if an error | |

occurs, set ROP to 'NaN + i * NaN' and return -1. If READ is not | |

the null pointer, it is set to the number of read characters. | |

Unlike 'mpc_strtoc', the function 'mpc_inp_str' does not possess | |

perfect knowledge of the string to transform and has to read it | |

character by character, so it behaves slightly differently: It | |

tries to read a string describing a complex number and processes | |

this string through a call to 'mpc_set_str'. Precisely, after | |

skipping optional whitespace, a minimal string is read according to | |

the regular expression 'mpfr | '(' \s* mpfr \s+ mpfr \s* ')'', | |

where '\s' denotes a whitespace, and 'mpfr' is either a string | |

containing neither whitespaces nor parentheses, or | |

'nan(n-char-sequence)' or '@nan@(n-char-sequence)' (regardless of | |

capitalisation) with 'n-char-sequence' a string of ascii letters, | |

digits or ''_''. | |

For instance, upon input of '"nan(13 1)"', the function | |

'mpc_inp_str' starts to recognise a value of NaN followed by an | |

n-char-sequence indicated by the opening parenthesis; as soon as | |

the space is reached, it becocmes clear that the expression in | |

parentheses is not an n-char-sequence, and the error flag -1 is | |

returned after 6 characters have been consumed from the stream (the | |

whitespace itself remaining in the stream). The function | |

'mpc_strtoc', on the other hand, may track back when reaching the | |

whitespace; it treats the string as the two successive complex | |

numbers 'NaN + i * 0' and '13 + i'. It is thus recommended to have | |

a whitespace follow each floating point number to avoid this | |

problem. | |

-- Function: size_t mpc_out_str (FILE *STREAM, int BASE, size_t | |

N_DIGITS, mpc_t OP, mpc_rnd_t RND) | |

Output OP on stdio stream STREAM in base BASE, rounded according to | |

RND, in the same format as for 'mpc_strtoc' If STREAM is the null | |

pointer, ROP is written to 'stdout'. | |

Return the number of characters written. | |

File: mpc.info, Node: Complex Comparison, Next: Projection & Decomposing, Prev: String and Stream Input and Output, Up: Complex Functions | |

5.5 Comparison Functions | |

======================== | |

-- Function: int mpc_cmp (mpc_t OP1, mpc_t OP2) | |

-- Function: int mpc_cmp_si_si (mpc_t OP1, long int OP2R, long int | |

OP2I) | |

-- Macro: int mpc_cmp_si (mpc_t OP1, long int OP2) | |

Compare OP1 and OP2, where in the case of 'mpc_cmp_si_si', OP2 is | |

taken to be OP2R + i OP2I. The return value C can be decomposed | |

into 'x = MPC_INEX_RE(c)' and 'y = MPC_INEX_IM(c)', such that X is | |

positive if the real part of OP1 is greater than that of OP2, zero | |

if both real parts are equal, and negative if the real part of OP1 | |

is less than that of OP2, and likewise for Y. Both OP1 and OP2 are | |

considered to their full own precision, which may differ. It is | |

not allowed that one of the operands has a NaN (Not-a-Number) part. | |

The storage of the return value is such that equality can be simply | |

checked with 'mpc_cmp (op1, op2) == 0'. | |

File: mpc.info, Node: Projection & Decomposing, Next: Basic Arithmetic, Prev: Complex Comparison, Up: Complex Functions | |

5.6 Projection and Decomposing Functions | |

======================================== | |

-- Function: int mpc_real (mpfr_t ROP, mpc_t OP, mpfr_rnd_t RND) | |

Set ROP to the value of the real part of OP rounded in the | |

direction RND. | |

-- Function: int mpc_imag (mpfr_t ROP, mpc_t OP, mpfr_rnd_t RND) | |

Set ROP to the value of the imaginary part of OP rounded in the | |

direction RND. | |

-- Macro: mpfr_t mpc_realref (mpc_t OP) | |

-- Macro: mpfr_t mpc_imagref (mpc_t OP) | |

Return a reference to the real part and imaginary part of OP, | |

respectively. The 'mpfr' functions can be used on the result of | |

these macros (note that the 'mpfr_t' type is itself a pointer). | |

-- Function: int mpc_arg (mpfr_t ROP, mpc_t OP, mpfr_rnd_t RND) | |

Set ROP to the argument of OP, with a branch cut along the negative | |

real axis. | |

-- Function: int mpc_proj (mpc_t ROP, mpc_t OP, mpc_rnd_t RND) | |

Compute a projection of OP onto the Riemann sphere. Set ROP to OP | |

rounded in the direction RND, except when at least one part of OP | |

is infinite (even if the other part is a NaN) in which case the | |

real part of ROP is set to plus infinity and its imaginary part to | |

a signed zero with the same sign as the imaginary part of OP. | |

File: mpc.info, Node: Basic Arithmetic, Next: Power Functions and Logarithm, Prev: Projection & Decomposing, Up: Complex Functions | |

5.7 Basic Arithmetic Functions | |

============================== | |

All the following functions are designed in such a way that, when | |

working with real numbers instead of complex numbers, their complexity | |

should essentially be the same as with the GNU MPFR library, with only a | |

marginal overhead due to the GNU MPC layer. | |

-- Function: int mpc_add (mpc_t ROP, mpc_t OP1, mpc_t OP2, mpc_rnd_t | |

RND) | |

-- Function: int mpc_add_ui (mpc_t ROP, mpc_t OP1, unsigned long int | |

OP2, mpc_rnd_t RND) | |

-- Function: int mpc_add_fr (mpc_t ROP, mpc_t OP1, mpfr_t OP2, | |

mpc_rnd_t RND) | |

Set ROP to OP1 + OP2 rounded according to RND. | |

-- Function: int mpc_sub (mpc_t ROP, mpc_t OP1, mpc_t OP2, mpc_rnd_t | |

RND) | |

-- Function: int mpc_sub_fr (mpc_t ROP, mpc_t OP1, mpfr_t OP2, | |

mpc_rnd_t RND) | |

-- Function: int mpc_fr_sub (mpc_t ROP, mpfr_t OP1, mpc_t OP2, | |

mpc_rnd_t RND) | |

-- Function: int mpc_sub_ui (mpc_t ROP, mpc_t OP1, unsigned long int | |

OP2, mpc_rnd_t RND) | |

-- Macro: int mpc_ui_sub (mpc_t ROP, unsigned long int OP1, mpc_t OP2, | |

mpc_rnd_t RND) | |

-- Function: int mpc_ui_ui_sub (mpc_t ROP, unsigned long int RE1, | |

unsigned long int IM1, mpc_t OP2, mpc_rnd_t RND) | |

Set ROP to OP1 - OP2 rounded according to RND. For | |

'mpc_ui_ui_sub', OP1 is RE1 + IM1. | |

-- Function: int mpc_neg (mpc_t ROP, mpc_t OP, mpc_rnd_t RND) | |

Set ROP to -OP rounded according to RND. Just changes the sign if | |

ROP and OP are the same variable. | |

-- Function: int mpc_mul (mpc_t ROP, mpc_t OP1, mpc_t OP2, mpc_rnd_t | |

RND) | |

-- Function: int mpc_mul_ui (mpc_t ROP, mpc_t OP1, unsigned long int | |

OP2, mpc_rnd_t RND) | |

-- Function: int mpc_mul_si (mpc_t ROP, mpc_t OP1, long int OP2, | |

mpc_rnd_t RND) | |

-- Function: int mpc_mul_fr (mpc_t ROP, mpc_t OP1, mpfr_t OP2, | |

mpc_rnd_t RND) | |

Set ROP to OP1 times OP2 rounded according to RND. Note: for | |

'mpc_mul', in case OP1 and OP2 have the same value, use 'mpc_sqr' | |

for better efficiency. | |

-- Function: int mpc_mul_i (mpc_t ROP, mpc_t OP, int SGN, mpc_rnd_t | |

RND) | |

Set ROP to OP times the imaginary unit i if SGN is non-negative, | |

set ROP to OP times -i otherwise, in both cases rounded according | |

to RND. | |

-- Function: int mpc_sqr (mpc_t ROP, mpc_t OP, mpc_rnd_t RND) | |

Set ROP to the square of OP rounded according to RND. | |

-- Function: int mpc_fma (mpc_t ROP, mpc_t OP1, mpc_t OP2, mpc_t OP3, | |

mpc_rnd_t RND) | |

Set ROP to OP1*OP2+OP3, rounded according to RND, with only one | |

final rounding. | |

-- Function: int mpc_div (mpc_t ROP, mpc_t OP1, mpc_t OP2, mpc_rnd_t | |

RND) | |

-- Function: int mpc_div_ui (mpc_t ROP, mpc_t OP1, unsigned long int | |

OP2, mpc_rnd_t RND) | |

-- Function: int mpc_div_fr (mpc_t ROP, mpc_t OP1, mpfr_t OP2, | |

mpc_rnd_t RND) | |

-- Function: int mpc_ui_div (mpc_t ROP, unsigned long int OP1, mpc_t | |

OP2, mpc_rnd_t RND) | |

-- Function: int mpc_fr_div (mpc_t ROP, mpfr_t OP1, mpc_t OP2, | |

mpc_rnd_t RND) | |

Set ROP to OP1/OP2 rounded according to RND. | |

-- Function: int mpc_conj (mpc_t ROP, mpc_t OP, mpc_rnd_t RND) | |

Set ROP to the conjugate of OP rounded according to RND. Just | |

changes the sign of the imaginary part if ROP and OP are the same | |

variable. | |

-- Function: int mpc_abs (mpfr_t ROP, mpc_t OP, mpfr_rnd_t RND) | |

Set the floating-point number ROP to the absolute value of OP, | |

rounded in the direction RND. | |

-- Function: int mpc_norm (mpfr_t ROP, mpc_t OP, mpfr_rnd_t RND) | |

Set the floating-point number ROP to the norm of OP (i.e., the | |

square of its absolute value), rounded in the direction RND. | |

-- Function: int mpc_mul_2ui (mpc_t ROP, mpc_t OP1, unsigned long int | |

OP2, mpc_rnd_t RND) | |

-- Function: int mpc_mul_2si (mpc_t ROP, mpc_t OP1, long int OP2, | |

mpc_rnd_t RND) | |

Set ROP to OP1 times 2 raised to OP2 rounded according to RND. | |

Just modifies the exponents of the real and imaginary parts by OP2 | |

when ROP and OP1 are identical. | |

-- Function: int mpc_div_2ui (mpc_t ROP, mpc_t OP1, unsigned long int | |

OP2, mpc_rnd_t RND) | |

-- Function: int mpc_div_2si (mpc_t ROP, mpc_t OP1, long int OP2, | |

mpc_rnd_t RND) | |

Set ROP to OP1 divided by 2 raised to OP2 rounded according to RND. | |

Just modifies the exponents of the real and imaginary parts by OP2 | |

when ROP and OP1 are identical. | |

File: mpc.info, Node: Power Functions and Logarithm, Next: Trigonometric Functions, Prev: Basic Arithmetic, Up: Complex Functions | |

5.8 Power Functions and Logarithm | |

================================= | |

-- Function: int mpc_sqrt (mpc_t ROP, mpc_t OP, mpc_rnd_t RND) | |

Set ROP to the square root of OP rounded according to RND. The | |

returned value ROP has a non-negative real part, and if its real | |

part is zero, a non-negative imaginary part. | |

-- Function: int mpc_pow (mpc_t ROP, mpc_t OP1, mpc_t OP2, mpc_rnd_t | |

RND) | |

-- Function: int mpc_pow_d (mpc_t ROP, mpc_t OP1, double OP2, mpc_rnd_t | |

RND) | |

-- Function: int mpc_pow_ld (mpc_t ROP, mpc_t OP1, long double OP2, | |

mpc_rnd_t RND) | |

-- Function: int mpc_pow_si (mpc_t ROP, mpc_t OP1, long OP2, mpc_rnd_t | |

RND) | |

-- Function: int mpc_pow_ui (mpc_t ROP, mpc_t OP1, unsigned long OP2, | |

mpc_rnd_t RND) | |

-- Function: int mpc_pow_z (mpc_t ROP, mpc_t OP1, mpz_t OP2, mpc_rnd_t | |

RND) | |

-- Function: int mpc_pow_fr (mpc_t ROP, mpc_t OP1, mpfr_t OP2, | |

mpc_rnd_t RND) | |

Set ROP to OP1 raised to the power OP2, rounded according to RND. | |

For 'mpc_pow_d', 'mpc_pow_ld', 'mpc_pow_si', 'mpc_pow_ui', | |

'mpc_pow_z' and 'mpc_pow_fr', the imaginary part of OP2 is | |

considered as +0. When both OP1 and OP2 are zero, the result has | |

real part 1, and imaginary part 0, with sign being the opposite of | |

that of OP2. | |

-- Function: int mpc_exp (mpc_t ROP, mpc_t OP, mpc_rnd_t RND) | |

Set ROP to the exponential of OP, rounded according to RND with the | |

precision of ROP. | |

-- Function: int mpc_log (mpc_t ROP, mpc_t OP, mpc_rnd_t RND) | |

-- Function: int mpc_log10 (mpc_t ROP, mpc_t OP, mpc_rnd_t RND) | |

Set ROP to the natural and base-10 logarithm of OP respectively, | |

rounded according to RND with the precision of ROP. The principal | |

branch is chosen, with the branch cut on the negative real axis, so | |

that the imaginary part of the result lies in ]-\pi , \pi] and | |

]-\pi/log(10) , \pi/log(10)] respectively. | |

File: mpc.info, Node: Trigonometric Functions, Next: Miscellaneous Complex Functions, Prev: Power Functions and Logarithm, Up: Complex Functions | |

5.9 Trigonometric Functions | |

=========================== | |

-- Function: int mpc_sin (mpc_t ROP, mpc_t OP, mpc_rnd_t RND) | |

Set ROP to the sine of OP, rounded according to RND with the | |

precision of ROP. | |

-- Function: int mpc_cos (mpc_t ROP, mpc_t OP, mpc_rnd_t RND) | |

Set ROP to the cosine of OP, rounded according to RND with the | |

precision of ROP. | |

-- Function: int mpc_sin_cos (mpc_t ROP_SIN, mpc_t ROP_COS, mpc_t OP, | |

mpc_rnd_t RND_SIN, mpc_rnd_t RND_COS) | |

Set ROP_SIN to the sine of OP, rounded according to RND_SIN with | |

the precision of ROP_SIN, and ROP_COS to the cosine of OP, rounded | |

according to RND_COS with the precision of ROP_COS. | |

-- Function: int mpc_tan (mpc_t ROP, mpc_t OP, mpc_rnd_t RND) | |

Set ROP to the tangent of OP, rounded according to RND with the | |

precision of ROP. | |

-- Function: int mpc_sinh (mpc_t ROP, mpc_t OP, mpc_rnd_t RND) | |

Set ROP to the hyperbolic sine of OP, rounded according to RND with | |

the precision of ROP. | |

-- Function: int mpc_cosh (mpc_t ROP, mpc_t OP, mpc_rnd_t RND) | |

Set ROP to the hyperbolic cosine of OP, rounded according to RND | |

with the precision of ROP. | |

-- Function: int mpc_tanh (mpc_t ROP, mpc_t OP, mpc_rnd_t RND) | |

Set ROP to the hyperbolic tangent of OP, rounded according to RND | |

with the precision of ROP. | |

-- Function: int mpc_asin (mpc_t ROP, mpc_t OP, mpc_rnd_t RND) | |

-- Function: int mpc_acos (mpc_t ROP, mpc_t OP, mpc_rnd_t RND) | |

-- Function: int mpc_atan (mpc_t ROP, mpc_t OP, mpc_rnd_t RND) | |

Set ROP to the inverse sine, inverse cosine, inverse tangent of OP, | |

rounded according to RND with the precision of ROP. | |

-- Function: int mpc_asinh (mpc_t ROP, mpc_t OP, mpc_rnd_t RND) | |

-- Function: int mpc_acosh (mpc_t ROP, mpc_t OP, mpc_rnd_t RND) | |

-- Function: int mpc_atanh (mpc_t ROP, mpc_t OP, mpc_rnd_t RND) | |

Set ROP to the inverse hyperbolic sine, inverse hyperbolic cosine, | |

inverse hyperbolic tangent of OP, rounded according to RND with the | |

precision of ROP. The branch cut of MPC_ACOSH is (-\infty, 1). | |

File: mpc.info, Node: Miscellaneous Complex Functions, Next: Advanced Functions, Prev: Trigonometric Functions, Up: Complex Functions | |

5.10 Miscellaneous Functions | |

============================ | |

-- Function: int mpc_urandom (mpc_t ROP, gmp_randstate_t STATE) | |

Generate a uniformly distributed random complex in the unit square | |

[0, 1] x [0, 1]. Return 0, unless an exponent in the real or | |

imaginary part is not in the current exponent range, in which case | |

that part is set to NaN and a zero value is returned. The second | |

argument is a 'gmp_randstate_t' structure which should be created | |

using the GMP 'rand_init' function, see the GMP manual. | |

-- Function: const char * mpc_get_version (void) | |

Return the GNU MPC version, as a null-terminated string. | |

-- Macro: MPC_VERSION | |

-- Macro: MPC_VERSION_MAJOR | |

-- Macro: MPC_VERSION_MINOR | |

-- Macro: MPC_VERSION_PATCHLEVEL | |

-- Macro: MPC_VERSION_STRING | |

'MPC_VERSION' is the version of GNU MPC as a preprocessing | |

constant. 'MPC_VERSION_MAJOR', 'MPC_VERSION_MINOR' and | |

'MPC_VERSION_PATCHLEVEL' are respectively the major, minor and | |

patch level of GNU MPC version, as preprocessing constants. | |

'MPC_VERSION_STRING' is the version as a string constant, which can | |

be compared to the result of 'mpc_get_version' to check at run time | |

the header file and library used match: | |

if (strcmp (mpc_get_version (), MPC_VERSION_STRING)) | |

fprintf (stderr, "Warning: header and library do not match\n"); | |

Note: Obtaining different strings is not necessarily an error, as | |

in general, a program compiled with some old GNU MPC version can be | |

dynamically linked with a newer GNU MPC library version (if allowed | |

by the library versioning system). | |

-- Macro: long MPC_VERSION_NUM (MAJOR, MINOR, PATCHLEVEL) | |

Create an integer in the same format as used by 'MPC_VERSION' from | |

the given MAJOR, MINOR and PATCHLEVEL. Here is an example of how | |

to check the GNU MPC version at compile time: | |

#if (!defined(MPC_VERSION) || (MPC_VERSION<MPC_VERSION_NUM(2,1,0))) | |

# error "Wrong GNU MPC version." | |

#endif | |

File: mpc.info, Node: Advanced Functions, Next: Internals, Prev: Miscellaneous Complex Functions, Up: Complex Functions | |

5.11 Advanced Functions | |

======================= | |

-- Macro: MPC_SET_X_Y (REAL_SUFFIX, IMAG_SUFFIX, ROP, REAL, IMAG, RND) | |

The macro MPC_SET_X_Y is designed to serve as the body of an | |

assignment function and cannot be used by itself. The REAL_SUFFIX | |

and IMAG_SUFFIX parameters are the types of the real and imaginary | |

part, that is, the 'x' in the 'mpfr_set_x' function one would use | |

to set the part; for the mpfr type, use 'fr'. REAL (respectively | |

IMAG) is the value you want to assign to the real (resp. | |

imaginary) part, its type must conform to REAL_SUFFIX (resp. | |

IMAG_SUFFIX). RND is the 'mpc_rnd_t' rounding mode. The return | |

value is the usual inexact value (*note Return Value: | |

return-value.). | |

For instance, you can define mpc_set_ui_fr as follows: | |

int mpc_set_ui_fr (mpc_t rop, long int re, double im, mpc_rnd_t rnd) | |

MPC_SET_X_Y (ui, fr, rop, re, im, rnd); | |

File: mpc.info, Node: Internals, Prev: Advanced Functions, Up: Complex Functions | |

5.12 Internals | |

============== | |

These macros and functions are mainly designed for the implementation of | |

GNU MPC, but may be useful for users too. However, no upward | |

compatibility is guaranteed. You need to include 'mpc-impl.h' to use | |

them. | |

The macro 'MPC_MAX_PREC(z)' gives the maximum of the precisions of | |

the real and imaginary parts of a complex number. | |

File: mpc.info, Node: References, Next: Concept Index, Prev: Complex Functions, Up: Top | |

References | |

********** | |

* Torbjo"rn Granlund et al. 'gmp' - GNU multiprecision library. | |

Version 4.2.4, <http://gmplib.org/>. | |

* Guillaume Hanrot, Vincent Lefe`vre, Patrick Pe'lissier, Paul | |

Zimmermann et al. 'mpfr' - A library for multiple-precision | |

floating-point computations with exact rounding. Version 2.4.1, | |

<http://www.mpfr.org>. | |

* IEEE standard for binary floating-point arithmetic, Technical | |

Report ANSI-IEEE Standard 754-1985, New York, 1985. Approved March | |

21, 1985: IEEE Standards Board; approved July 26, 1985: American | |

National Standards Institute, 18 pages. | |

* Donald E. Knuth, "The Art of Computer Programming", vol 2, | |

"Seminumerical Algorithms", 2nd edition, Addison-Wesley, 1981. | |

* ISO/IEC 9899:1999, Programming languages â€” C. | |

File: mpc.info, Node: Concept Index, Next: Function Index, Prev: References, Up: Top | |

Concept Index | |

************* | |

�[index�] | |

* Menu: | |

* Arithmetic functions: Basic Arithmetic. (line 6) | |

* Comparison functions: Complex Comparison. (line 6) | |

* Complex arithmetic functions: Basic Arithmetic. (line 6) | |

* Complex assignment functions: Assigning Complex Numbers. | |

(line 6) | |

* Complex comparisons functions: Complex Comparison. (line 6) | |

* Complex functions: Complex Functions. (line 6) | |

* Complex number: GNU MPC Basics. (line 15) | |

* Conditions for copying GNU MPC: Copying. (line 6) | |

* Conversion functions: Converting Complex Numbers. | |

(line 6) | |

* Copying conditions: Copying. (line 6) | |

* Installation: Installing GNU MPC. (line 6) | |

* Logarithm: Power Functions and Logarithm. | |

(line 6) | |

* Miscellaneous complex functions: Miscellaneous Complex Functions. | |

(line 6) | |

* 'mpc.h': GNU MPC Basics. (line 6) | |

* Power functions: Power Functions and Logarithm. | |

(line 6) | |

* Precision: GNU MPC Basics. (line 19) | |

* Projection and Decomposing Functions: Projection & Decomposing. | |

(line 6) | |

* Reporting bugs: Reporting Bugs. (line 6) | |

* Rounding Mode: GNU MPC Basics. (line 24) | |

* String and stream input and output: String and Stream Input and Output. | |

(line 6) | |

* Trigonometric functions: Trigonometric Functions. | |

(line 6) | |

* User-defined precision: Complex Functions. (line 12) | |

File: mpc.info, Node: Function Index, Next: GNU Free Documentation License, Prev: Concept Index, Up: Top | |

Function Index | |

************** | |

�[index�] | |

* Menu: | |

* _Complex: Converting Complex Numbers. | |

(line 9) | |

* mpc_abs: Basic Arithmetic. (line 81) | |

* mpc_acos: Trigonometric Functions. | |

(line 37) | |

* mpc_acosh: Trigonometric Functions. | |

(line 43) | |

* mpc_add: Basic Arithmetic. (line 11) | |

* mpc_add_fr: Basic Arithmetic. (line 15) | |

* mpc_add_ui: Basic Arithmetic. (line 13) | |

* mpc_arg: Projection & Decomposing. | |

(line 20) | |

* mpc_asin: Trigonometric Functions. | |

(line 36) | |

* mpc_asinh: Trigonometric Functions. | |

(line 42) | |

* mpc_atan: Trigonometric Functions. | |

(line 38) | |

* mpc_atanh: Trigonometric Functions. | |

(line 44) | |

* mpc_clear: Initializing Complex Numbers. | |

(line 21) | |

* mpc_cmp: Complex Comparison. (line 6) | |

* mpc_cmp_si: Complex Comparison. (line 9) | |

* mpc_cmp_si_si: Complex Comparison. (line 7) | |

* mpc_conj: Basic Arithmetic. (line 76) | |

* mpc_cos: Trigonometric Functions. | |

(line 10) | |

* mpc_cosh: Trigonometric Functions. | |

(line 28) | |

* mpc_div: Basic Arithmetic. (line 64) | |

* mpc_div_2si: Basic Arithmetic. (line 99) | |

* mpc_div_2ui: Basic Arithmetic. (line 97) | |

* mpc_div_fr: Basic Arithmetic. (line 68) | |

* mpc_div_ui: Basic Arithmetic. (line 66) | |

* mpc_exp: Power Functions and Logarithm. | |

(line 32) | |

* mpc_fma: Basic Arithmetic. (line 59) | |

* mpc_free_str: String and Stream Input and Output. | |

(line 66) | |

* mpc_fr_div: Basic Arithmetic. (line 72) | |

* mpc_fr_sub: Basic Arithmetic. (line 23) | |

* mpc_get_ldc: Converting Complex Numbers. | |

(line 10) | |

* mpc_get_prec: Initializing Complex Numbers. | |

(line 49) | |

* mpc_get_prec2: Initializing Complex Numbers. | |

(line 53) | |

* mpc_get_str: String and Stream Input and Output. | |

(line 48) | |

* mpc_get_version: Miscellaneous Complex Functions. | |

(line 14) | |

* mpc_imag: Projection & Decomposing. | |

(line 10) | |

* mpc_imagref: Projection & Decomposing. | |

(line 15) | |

* mpc_init2: Initializing Complex Numbers. | |

(line 10) | |

* mpc_init3: Initializing Complex Numbers. | |

(line 15) | |

* mpc_inp_str: String and Stream Input and Output. | |

(line 74) | |

* mpc_log: Power Functions and Logarithm. | |

(line 36) | |

* mpc_log10: Power Functions and Logarithm. | |

(line 37) | |

* mpc_mul: Basic Arithmetic. (line 38) | |

* mpc_mul_2si: Basic Arithmetic. (line 91) | |

* mpc_mul_2ui: Basic Arithmetic. (line 89) | |

* mpc_mul_fr: Basic Arithmetic. (line 44) | |

* mpc_mul_i: Basic Arithmetic. (line 50) | |

* mpc_mul_si: Basic Arithmetic. (line 42) | |

* mpc_mul_ui: Basic Arithmetic. (line 40) | |

* mpc_neg: Basic Arithmetic. (line 34) | |

* mpc_norm: Basic Arithmetic. (line 85) | |

* mpc_out_str: String and Stream Input and Output. | |

(line 109) | |

* mpc_pow: Power Functions and Logarithm. | |

(line 11) | |

* mpc_pow_d: Power Functions and Logarithm. | |

(line 13) | |

* mpc_pow_fr: Power Functions and Logarithm. | |

(line 23) | |

* mpc_pow_ld: Power Functions and Logarithm. | |

(line 15) | |

* mpc_pow_si: Power Functions and Logarithm. | |

(line 17) | |

* mpc_pow_ui: Power Functions and Logarithm. | |

(line 19) | |

* mpc_pow_z: Power Functions and Logarithm. | |

(line 21) | |

* mpc_proj: Projection & Decomposing. | |

(line 24) | |

* mpc_real: Projection & Decomposing. | |

(line 6) | |

* mpc_realref: Projection & Decomposing. | |

(line 14) | |

* 'mpc_rnd_t': GNU MPC Basics. (line 24) | |

* mpc_set: Assigning Complex Numbers. | |

(line 16) | |

* mpc_set_d: Assigning Complex Numbers. | |

(line 25) | |

* mpc_set_dc: Assigning Complex Numbers. | |

(line 27) | |

* mpc_set_d_d: Assigning Complex Numbers. | |

(line 54) | |

* mpc_set_f: Assigning Complex Numbers. | |

(line 33) | |

* mpc_set_fr: Assigning Complex Numbers. | |

(line 34) | |

* mpc_set_fr_fr: Assigning Complex Numbers. | |

(line 64) | |

* mpc_set_f_f: Assigning Complex Numbers. | |

(line 62) | |

* mpc_set_ld: Assigning Complex Numbers. | |

(line 26) | |

* mpc_set_ldc: Assigning Complex Numbers. | |

(line 29) | |

* mpc_set_ld_ld: Assigning Complex Numbers. | |

(line 56) | |

* mpc_set_nan: Assigning Complex Numbers. | |

(line 79) | |

* mpc_set_prec: Initializing Complex Numbers. | |

(line 41) | |

* mpc_set_q: Assigning Complex Numbers. | |

(line 32) | |

* mpc_set_q_q: Assigning Complex Numbers. | |

(line 60) | |

* mpc_set_si: Assigning Complex Numbers. | |

(line 22) | |

* mpc_set_si_si: Assigning Complex Numbers. | |

(line 48) | |

* mpc_set_sj: Assigning Complex Numbers. | |

(line 24) | |

* mpc_set_sj_sj: Assigning Complex Numbers. | |

(line 52) | |

* mpc_set_str: String and Stream Input and Output. | |

(line 35) | |

* mpc_set_ui: Assigning Complex Numbers. | |

(line 20) | |

* mpc_set_ui_ui: Assigning Complex Numbers. | |

(line 46) | |

* mpc_set_uj: Assigning Complex Numbers. | |

(line 23) | |

* mpc_set_uj_uj: Assigning Complex Numbers. | |

(line 50) | |

* MPC_SET_X_Y: Advanced Functions. (line 6) | |

* mpc_set_z: Assigning Complex Numbers. | |

(line 31) | |

* mpc_set_z_z: Assigning Complex Numbers. | |

(line 58) | |

* mpc_sin: Trigonometric Functions. | |

(line 6) | |

* mpc_sinh: Trigonometric Functions. | |

(line 24) | |

* mpc_sin_cos: Trigonometric Functions. | |

(line 14) | |

* mpc_sqr: Basic Arithmetic. (line 56) | |

* mpc_sqrt: Power Functions and Logarithm. | |

(line 6) | |

* mpc_strtoc: String and Stream Input and Output. | |

(line 6) | |

* mpc_sub: Basic Arithmetic. (line 19) | |

* mpc_sub_fr: Basic Arithmetic. (line 21) | |

* mpc_sub_ui: Basic Arithmetic. (line 25) | |

* mpc_swap: Assigning Complex Numbers. | |

(line 82) | |

* 'mpc_t': GNU MPC Basics. (line 15) | |

* mpc_tan: Trigonometric Functions. | |

(line 20) | |

* mpc_tanh: Trigonometric Functions. | |

(line 32) | |

* mpc_ui_div: Basic Arithmetic. (line 70) | |

* mpc_ui_sub: Basic Arithmetic. (line 27) | |

* mpc_ui_ui_sub: Basic Arithmetic. (line 29) | |

* mpc_urandom: Miscellaneous Complex Functions. | |

(line 6) | |

* MPC_VERSION: Miscellaneous Complex Functions. | |

(line 17) | |

* MPC_VERSION_MAJOR: Miscellaneous Complex Functions. | |

(line 18) | |

* MPC_VERSION_MINOR: Miscellaneous Complex Functions. | |

(line 19) | |

* MPC_VERSION_NUM: Miscellaneous Complex Functions. | |

(line 36) | |

* MPC_VERSION_PATCHLEVEL: Miscellaneous Complex Functions. | |

(line 20) | |

* MPC_VERSION_STRING: Miscellaneous Complex Functions. | |

(line 21) | |

* 'mpfr_prec_t': GNU MPC Basics. (line 19) | |

File: mpc.info, Node: GNU Free Documentation License, Prev: Function Index, Up: Top | |

Appendix A GNU Free Documentation License | |

***************************************** | |

Version 1.3, 3 November 2008 | |

Copyright (C) 2000, 2001, 2002, 2007, 2008 Free Software Foundation, Inc. | |

<http://fsf.org/> | |

Everyone is permitted to copy and distribute verbatim copies | |

of this license document, but changing it is not allowed. | |

0. PREAMBLE | |

The purpose of this License is to make a manual, textbook, or other | |

functional and useful document "free" in the sense of freedom: to | |

assure everyone the effective freedom to copy and redistribute it, | |

with or without modifying it, either commercially or | |

noncommercially. Secondarily, this License preserves for the | |

author and publisher a way to get credit for their work, while not | |

being considered responsible for modifications made by others. | |

This License is a kind of "copyleft", which means that derivative | |

works of the document must themselves be free in the same sense. | |

It complements the GNU General Public License, which is a copyleft | |

license designed for free software. | |

We have designed this License in order to use it for manuals for | |

free software, because free software needs free documentation: a | |

free program should come with manuals providing the same freedoms | |

that the software does. But this License is not limited to | |

software manuals; it can be used for any textual work, regardless | |

of subject matter or whether it is published as a printed book. We | |

recommend this License principally for works whose purpose is | |

instruction or reference. | |

1. APPLICABILITY AND DEFINITIONS | |

This License applies to any manual or other work, in any medium, | |

that contains a notice placed by the copyright holder saying it can | |

be distributed under the terms of this License. Such a notice | |

grants a world-wide, royalty-free license, unlimited in duration, | |

to use that work under the conditions stated herein. The | |

"Document", below, refers to any such manual or work. Any member | |

of the public is a licensee, and is addressed as "you". You accept | |

the license if you copy, modify or distribute the work in a way | |

requiring permission under copyright law. | |

A "Modified Version" of the Document means any work containing the | |

Document or a portion of it, either copied verbatim, or with | |

modifications and/or translated into another language. | |

A "Secondary Section" is a named appendix or a front-matter section | |

of the Document that deals exclusively with the relationship of the | |

publishers or authors of the Document to the Document's overall | |

subject (or to related matters) and contains nothing that could | |

fall directly within that overall subject. (Thus, if the Document | |

is in part a textbook of mathematics, a Secondary Section may not | |

explain any mathematics.) The relationship could be a matter of | |

historical connection with the subject or with related matters, or | |

of legal, commercial, philosophical, ethical or political position | |

regarding them. | |

The "Invariant Sections" are certain Secondary Sections whose | |

titles are designated, as being those of Invariant Sections, in the | |

notice that says that the Document is released under this License. | |

If a section does not fit the above definition of Secondary then it | |

is not allowed to be designated as Invariant. The Document may | |

contain zero Invariant Sections. If the Document does not identify | |

any Invariant Sections then there are none. | |

The "Cover Texts" are certain short passages of text that are | |

listed, as Front-Cover Texts or Back-Cover Texts, in the notice | |

that says that the Document is released under this License. A | |

Front-Cover Text may be at most 5 words, and a Back-Cover Text may | |

be at most 25 words. | |

A "Transparent" copy of the Document means a machine-readable copy, | |

represented in a format whose specification is available to the | |

general public, that is suitable for revising the document | |

straightforwardly with generic text editors or (for images composed | |

of pixels) generic paint programs or (for drawings) some widely | |

available drawing editor, and that is suitable for input to text | |

formatters or for automatic translation to a variety of formats | |

suitable for input to text formatters. A copy made in an otherwise | |

Transparent file format whose markup, or absence of markup, has | |

been arranged to thwart or discourage subsequent modification by | |

readers is not Transparent. An image format is not Transparent if | |

used for any substantial amount of text. A copy that is not | |

"Transparent" is called "Opaque". | |

Examples of suitable formats for Transparent copies include plain | |

ASCII without markup, Texinfo input format, LaTeX input format, | |

SGML or XML using a publicly available DTD, and standard-conforming | |

simple HTML, PostScript or PDF designed for human modification. | |

Examples of transparent image formats include PNG, XCF and JPG. | |

Opaque formats include proprietary formats that can be read and | |

edited only by proprietary word processors, SGML or XML for which | |

the DTD and/or processing tools are not generally available, and | |

the machine-generated HTML, PostScript or PDF produced by some word | |

processors for output purposes only. | |

The "Title Page" means, for a printed book, the title page itself, | |

plus such following pages as are needed to hold, legibly, the | |

material this License requires to appear in the title page. For | |

works in formats which do not have any title page as such, "Title | |

Page" means the text near the most prominent appearance of the | |

work's title, preceding the beginning of the body of the text. | |

The "publisher" means any person or entity that distributes copies | |

of the Document to the public. | |

A section "Entitled XYZ" means a named subunit of the Document | |

whose title either is precisely XYZ or contains XYZ in parentheses | |

following text that translates XYZ in another language. (Here XYZ | |

stands for a specific section name mentioned below, such as | |

"Acknowledgements", "Dedications", "Endorsements", or "History".) | |

To "Preserve the Title" of such a section when you modify the | |

Document means that it remains a section "Entitled XYZ" according | |

to this definition. | |

The Document may include Warranty Disclaimers next to the notice | |

which states that this License applies to the Document. These | |

Warranty Disclaimers are considered to be included by reference in | |

this License, but only as regards disclaiming warranties: any other | |

implication that these Warranty Disclaimers may have is void and | |

has no effect on the meaning of this License. | |

2. VERBATIM COPYING | |

You may copy and distribute the Document in any medium, either | |

commercially or noncommercially, provided that this License, the | |

copyright notices, and the license notice saying this License | |

applies to the Document are reproduced in all copies, and that you | |

add no other conditions whatsoever to those of this License. You | |

may not use technical measures to obstruct or control the reading | |

or further copying of the copies you make or distribute. However, | |

you may accept compensation in exchange for copies. If you | |

distribute a large enough number of copies you must also follow the | |

conditions in section 3. | |

You may also lend copies, under the same conditions stated above, | |

and you may publicly display copies. | |

3. COPYING IN QUANTITY | |

If you publish printed copies (or copies in media that commonly | |

have printed covers) of the Document, numbering more than 100, and | |

the Document's license notice requires Cover Texts, you must | |

enclose the copies in covers that carry, clearly and legibly, all | |

these Cover Texts: Front-Cover Texts on the front cover, and | |

Back-Cover Texts on the back cover. Both covers must also clearly | |

and legibly identify you as the publisher of these copies. The | |

front cover must present the full title with all words of the title | |

equally prominent and visible. You may add other material on the | |

covers in addition. Copying with changes limited to the covers, as | |

long as they preserve the title of the Document and satisfy these | |

conditions, can be treated as verbatim copying in other respects. | |

If the required texts for either cover are too voluminous to fit | |

legibly, you should put the first ones listed (as many as fit | |

reasonably) on the actual cover, and continue the rest onto | |

adjacent pages. | |

If you publish or distribute Opaque copies of the Document | |

numbering more than 100, you must either include a machine-readable | |

Transparent copy along with each Opaque copy, or state in or with | |

each Opaque copy a computer-network location from which the general | |

network-using public has access to download using public-standard | |

network protocols a complete Transparent copy of the Document, free | |

of added material. If you use the latter option, you must take | |

reasonably prudent steps, when you begin distribution of Opaque | |

copies in quantity, to ensure that this Transparent copy will | |

remain thus accessible at the stated location until at least one | |

year after the last time you distribute an Opaque copy (directly or | |

through your agents or retailers) of that edition to the public. | |

It is requested, but not required, that you contact the authors of | |

the Document well before redistributing any large number of copies, | |

to give them a chance to provide you with an updated version of the | |

Document. | |

4. MODIFICATIONS | |

You may copy and distribute a Modified Version of the Document | |

under the conditions of sections 2 and 3 above, provided that you | |

release the Modified Version under precisely this License, with the | |

Modified Version filling the role of the Document, thus licensing | |

distribution and modification of the Modified Version to whoever | |

possesses a copy of it. In addition, you must do these things in | |

the Modified Version: | |

A. Use in the Title Page (and on the covers, if any) a title | |

distinct from that of the Document, and from those of previous | |

versions (which should, if there were any, be listed in the | |

History section of the Document). You may use the same title | |

as a previous version if the original publisher of that | |

version gives permission. | |

B. List on the Title Page, as authors, one or more persons or | |

entities responsible for authorship of the modifications in | |

the Modified Version, together with at least five of the | |

principal authors of the Document (all of its principal | |

authors, if it has fewer than five), unless they release you | |

from this requirement. | |

C. State on the Title page the name of the publisher of the | |

Modified Version, as the publisher. | |

D. Preserve all the copyright notices of the Document. | |

E. Add an appropriate copyright notice for your modifications | |

adjacent to the other copyright notices. | |

F. Include, immediately after the copyright notices, a license | |

notice giving the public permission to use the Modified | |

Version under the terms of this License, in the form shown in | |

the Addendum below. | |

G. Preserve in that license notice the full lists of Invariant | |

Sections and required Cover Texts given in the Document's | |

license notice. | |

H. Include an unaltered copy of this License. | |

I. Preserve the section Entitled "History", Preserve its Title, | |

and add to it an item stating at least the title, year, new | |

authors, and publisher of the Modified Version as given on the | |

Title Page. If there is no section Entitled "History" in the | |

Document, create one stating the title, year, authors, and | |

publisher of the Document as given on its Title Page, then add | |

an item describing the Modified Version as stated in the | |

previous sentence. | |

J. Preserve the network location, if any, given in the Document | |

for public access to a Transparent copy of the Document, and | |

likewise the network locations given in the Document for | |

previous versions it was based on. These may be placed in the | |

"History" section. You may omit a network location for a work | |

that was published at least four years before the Document | |

itself, or if the original publisher of the version it refers | |

to gives permission. | |

K. For any section Entitled "Acknowledgements" or "Dedications", | |

Preserve the Title of the section, and preserve in the section | |

all the substance and tone of each of the contributor | |

acknowledgements and/or dedications given therein. | |

L. Preserve all the Invariant Sections of the Document, unaltered | |

in their text and in their titles. Section numbers or the | |

equivalent are not considered part of the section titles. | |

M. Delete any section Entitled "Endorsements". Such a section | |

may not be included in the Modified Version. | |

N. Do not retitle any existing section to be Entitled | |

"Endorsements" or to conflict in title with any Invariant | |

Section. | |

O. Preserve any Warranty Disclaimers. | |

If the Modified Version includes new front-matter sections or | |

appendices that qualify as Secondary Sections and contain no | |

material copied from the Document, you may at your option designate | |

some or all of these sections as invariant. To do this, add their | |

titles to the list of Invariant Sections in the Modified Version's | |

license notice. These titles must be distinct from any other | |

section titles. | |

You may add a section Entitled "Endorsements", provided it contains | |

nothing but endorsements of your Modified Version by various | |

parties--for example, statements of peer review or that the text | |

has been approved by an organization as the authoritative | |

definition of a standard. | |

You may add a passage of up to five words as a Front-Cover Text, | |

and a passage of up to 25 words as a Back-Cover Text, to the end of | |

the list of Cover Texts in the Modified Version. Only one passage | |

of Front-Cover Text and one of Back-Cover Text may be added by (or | |

through arrangements made by) any one entity. If the Document | |

already includes a cover text for the same cover, previously added | |

by you or by arrangement made by the same entity you are acting on | |

behalf of, you may not add another; but you may replace the old | |

one, on explicit permission from the previous publisher that added | |

the old one. | |

The author(s) and publisher(s) of the Document do not by this | |

License give permission to use their names for publicity for or to | |

assert or imply endorsement of any Modified Version. | |

5. COMBINING DOCUMENTS | |

You may combine the Document with other documents released under | |

this License, under the terms defined in section 4 above for | |

modified versions, provided that you include in the combination all | |

of the Invariant Sections of all of the original documents, | |

unmodified, and list them all as Invariant Sections of your | |

combined work in its license notice, and that you preserve all | |

their Warranty Disclaimers. | |

The combined work need only contain one copy of this License, and | |

multiple identical Invariant Sections may be replaced with a single | |

copy. If there are multiple Invariant Sections with the same name | |

but different contents, make the title of each such section unique | |

by adding at the end of it, in parentheses, the name of the | |

original author or publisher of that section if known, or else a | |

unique number. Make the same adjustment to the section titles in | |

the list of Invariant Sections in the license notice of the | |

combined work. | |

In the combination, you must combine any sections Entitled | |

"History" in the various original documents, forming one section | |

Entitled "History"; likewise combine any sections Entitled | |

"Acknowledgements", and any sections Entitled "Dedications". You | |

must delete all sections Entitled "Endorsements." | |

6. COLLECTIONS OF DOCUMENTS | |

You may make a collection consisting of the Document and other | |

documents released under this License, and replace the individual | |

copies of this License in the various documents with a single copy | |

that is included in the collection, provided that you follow the | |

rules of this License for verbatim copying of each of the documents | |

in all other respects. | |

You may extract a single document from such a collection, and | |

distribute it individually under this License, provided you insert | |

a copy of this License into the extracted document, and follow this | |

License in all other respects regarding verbatim copying of that | |

document. | |

7. AGGREGATION WITH INDEPENDENT WORKS | |

A compilation of the Document or its derivatives with other | |

separate and independent documents or works, in or on a volume of a | |

storage or distribution medium, is called an "aggregate" if the | |

copyright resulting from the compilation is not used to limit the | |

legal rights of the compilation's users beyond what the individual | |

works permit. When the Document is included in an aggregate, this | |

License does not apply to the other works in the aggregate which | |

are not themselves derivative works of the Document. | |

If the Cover Text requirement of section 3 is applicable to these | |

copies of the Document, then if the Document is less than one half | |

of the entire aggregate, the Document's Cover Texts may be placed | |

on covers that bracket the Document within the aggregate, or the | |

electronic equivalent of covers if the Document is in electronic | |

form. Otherwise they must appear on printed covers that bracket | |

the whole aggregate. | |

8. TRANSLATION | |

Translation is considered a kind of modification, so you may | |

distribute translations of the Document under the terms of section | |

4. Replacing Invariant Sections with translations requires special | |

permission from their copyright holders, but you may include | |

translations of some or all Invariant Sections in addition to the | |

original versions of these Invariant Sections. You may include a | |

translation of this License, and all the license notices in the | |

Document, and any Warranty Disclaimers, provided that you also | |

include the original English version of this License and the | |

original versions of those notices and disclaimers. In case of a | |

disagreement between the translation and the original version of | |

this License or a notice or disclaimer, the original version will | |

prevail. | |

If a section in the Document is Entitled "Acknowledgements", | |

"Dedications", or "History", the requirement (section 4) to | |

Preserve its Title (section 1) will typically require changing the | |

actual title. | |

9. TERMINATION | |

You may not copy, modify, sublicense, or distribute the Document | |

except as expressly provided under this License. Any attempt | |

otherwise to copy, modify, sublicense, or distribute it is void, | |

and will automatically terminate your rights under this License. | |

However, if you cease all violation of this License, then your | |

license from a particular copyright holder is reinstated (a) | |

provisionally, unless and until the copyright holder explicitly and | |

finally terminates your license, and (b) permanently, if the | |

copyright holder fails to notify you of the violation by some | |

reasonable means prior to 60 days after the cessation. | |

Moreover, your license from a particular copyright holder is | |

reinstated permanently if the copyright holder notifies you of the | |

violation by some reasonable means, this is the first time you have | |

received notice of violation of this License (for any work) from | |

that copyright holder, and you cure the violation prior to 30 days | |

after your receipt of the notice. | |

Termination of your rights under this section does not terminate | |

the licenses of parties who have received copies or rights from you | |

under this License. If your rights have been terminated and not | |

permanently reinstated, receipt of a copy of some or all of the | |

same material does not give you any rights to use it. | |

10. FUTURE REVISIONS OF THIS LICENSE | |

The Free Software Foundation may publish new, revised versions of | |

the GNU Free Documentation License from time to time. Such new | |

versions will be similar in spirit to the present version, but may | |

differ in detail to address new problems or concerns. See | |

<http://www.gnu.org/copyleft/>. | |

Each version of the License is given a distinguishing version | |

number. If the Document specifies that a particular numbered | |

version of this License "or any later version" applies to it, you | |

have the option of following the terms and conditions either of | |

that specified version or of any later version that has been | |

published (not as a draft) by the Free Software Foundation. If the | |

Document does not specify a version number of this License, you may | |

choose any version ever published (not as a draft) by the Free | |

Software Foundation. If the Document specifies that a proxy can | |

decide which future versions of this License can be used, that | |

proxy's public statement of acceptance of a version permanently | |

authorizes you to choose that version for the Document. | |

11. RELICENSING | |

"Massive Multiauthor Collaboration Site" (or "MMC Site") means any | |

World Wide Web server that publishes copyrightable works and also | |

provides prominent facilities for anybody to edit those works. A | |

public wiki that anybody can edit is an example of such a server. | |

A "Massive Multiauthor Collaboration" (or "MMC") contained in the | |

site means any set of copyrightable works thus published on the MMC | |

site. | |

"CC-BY-SA" means the Creative Commons Attribution-Share Alike 3.0 | |

license published by Creative Commons Corporation, a not-for-profit | |

corporation with a principal place of business in San Francisco, | |

California, as well as future copyleft versions of that license | |

published by that same organization. | |

"Incorporate" means to publish or republish a Document, in whole or | |

in part, as part of another Document. | |

An MMC is "eligible for relicensing" if it is licensed under this | |

License, and if all works that were first published under this | |

License somewhere other than this MMC, and subsequently | |

incorporated in whole or in part into the MMC, (1) had no cover | |

texts or invariant sections, and (2) were thus incorporated prior | |

to November 1, 2008. | |

The operator of an MMC Site may republish an MMC contained in the | |

site under CC-BY-SA on the same site at any time before August 1, | |

2009, provided the MMC is eligible for relicensing. | |

ADDENDUM: How to use this License for your documents | |

==================================================== | |

To use this License in a document you have written, include a copy of | |

the License in the document and put the following copyright and license | |

notices just after the title page: | |

Copyright (C) YEAR YOUR NAME. | |

Permission is granted to copy, distribute and/or modify this document | |

under the terms of the GNU Free Documentation License, Version 1.3 | |

or any later version published by the Free Software Foundation; | |

with no Invariant Sections, no Front-Cover Texts, and no Back-Cover | |

Texts. A copy of the license is included in the section entitled ``GNU | |

Free Documentation License''. | |

If you have Invariant Sections, Front-Cover Texts and Back-Cover | |

Texts, replace the "with...Texts." line with this: | |

with the Invariant Sections being LIST THEIR TITLES, with | |

the Front-Cover Texts being LIST, and with the Back-Cover Texts | |

being LIST. | |

If you have Invariant Sections without Cover Texts, or some other | |

combination of the three, merge those two alternatives to suit the | |

situation. | |

If your document contains nontrivial examples of program code, we | |

recommend releasing these examples in parallel under your choice of free | |

software license, such as the GNU General Public License, to permit | |

their use in free software. | |

Tag Table: | |

Node: Top736 | |

Node: Copying1443 | |

Node: Introduction to GNU MPC2215 | |

Node: Installing GNU MPC2934 | |

Node: Reporting Bugs8019 | |

Node: GNU MPC Basics9363 | |

Ref: return-value13040 | |

Node: Complex Functions14491 | |

Node: Initializing Complex Numbers15651 | |

Node: Assigning Complex Numbers18038 | |

Node: Converting Complex Numbers22438 | |

Node: String and Stream Input and Output23063 | |

Node: Complex Comparison29620 | |

Node: Projection & Decomposing30695 | |

Node: Basic Arithmetic32072 | |

Node: Power Functions and Logarithm36645 | |

Node: Trigonometric Functions38712 | |

Node: Miscellaneous Complex Functions40937 | |

Node: Advanced Functions43113 | |

Node: Internals44186 | |

Node: References44637 | |

Node: Concept Index45540 | |

Node: Function Index47854 | |

Node: GNU Free Documentation License61638 | |

End Tag Table |