| This is mpc.info, produced by makeinfo version 4.13 from mpc.texi. |
| |
| This manual is for GNU MPC, a library for multiple precision complex |
| arithmetic, version 1.0.1 of September 2012. |
| |
| 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.1 |
| |
| * 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.1.tar.gz' |
| |
| 2. `cd mpc-1.0.1' |
| |
| 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 |
| Nomenclature and Types: (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 Assignment Functions: |
| (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 10) |
| * mpc_abs: Basic Arithmetic. (line 82) |
| * mpc_acos: Trigonometric Functions. |
| (line 38) |
| * mpc_acosh: Trigonometric Functions. |
| (line 44) |
| * mpc_add: Basic Arithmetic. (line 13) |
| * mpc_add_fr: Basic Arithmetic. (line 17) |
| * mpc_add_ui: Basic Arithmetic. (line 15) |
| * mpc_arg: Projection & Decomposing. |
| (line 21) |
| * mpc_asin: Trigonometric Functions. |
| (line 37) |
| * mpc_asinh: Trigonometric Functions. |
| (line 43) |
| * mpc_atan: Trigonometric Functions. |
| (line 39) |
| * mpc_atanh: Trigonometric Functions. |
| (line 45) |
| * mpc_clear: Initializing Complex Numbers. |
| (line 22) |
| * mpc_cmp: Complex Comparison. (line 7) |
| * mpc_cmp_si: Complex Comparison. (line 10) |
| * mpc_cmp_si_si: Complex Comparison. (line 9) |
| * mpc_conj: Basic Arithmetic. (line 77) |
| * mpc_cos: Trigonometric Functions. |
| (line 11) |
| * mpc_cosh: Trigonometric Functions. |
| (line 29) |
| * mpc_div: Basic Arithmetic. (line 66) |
| * mpc_div_2si: Basic Arithmetic. (line 101) |
| * mpc_div_2ui: Basic Arithmetic. (line 99) |
| * mpc_div_fr: Basic Arithmetic. (line 70) |
| * mpc_div_ui: Basic Arithmetic. (line 68) |
| * mpc_exp: Power Functions and Logarithm. |
| (line 33) |
| * mpc_fma: Basic Arithmetic. (line 61) |
| * mpc_fr_div: Basic Arithmetic. (line 74) |
| * mpc_fr_sub: Basic Arithmetic. (line 25) |
| * mpc_free_str: String and Stream Input and Output. |
| (line 68) |
| * mpc_get_ldc: Converting Complex Numbers. |
| (line 11) |
| * mpc_get_prec: Initializing Complex Numbers. |
| (line 50) |
| * mpc_get_prec2: Initializing Complex Numbers. |
| (line 55) |
| * mpc_get_str: String and Stream Input and Output. |
| (line 51) |
| * mpc_get_version: Miscellaneous Complex Functions. |
| (line 15) |
| * mpc_imag: Projection & Decomposing. |
| (line 11) |
| * mpc_imagref: Projection & Decomposing. |
| (line 16) |
| * mpc_init2: Initializing Complex Numbers. |
| (line 11) |
| * mpc_init3: Initializing Complex Numbers. |
| (line 17) |
| * mpc_inp_str: String and Stream Input and Output. |
| (line 77) |
| * mpc_log: Power Functions and Logarithm. |
| (line 37) |
| * mpc_log10: Power Functions and Logarithm. |
| (line 38) |
| * mpc_mul: Basic Arithmetic. (line 40) |
| * mpc_mul_2si: Basic Arithmetic. (line 93) |
| * mpc_mul_2ui: Basic Arithmetic. (line 91) |
| * mpc_mul_fr: Basic Arithmetic. (line 46) |
| * mpc_mul_i: Basic Arithmetic. (line 52) |
| * mpc_mul_si: Basic Arithmetic. (line 44) |
| * mpc_mul_ui: Basic Arithmetic. (line 42) |
| * mpc_neg: Basic Arithmetic. (line 35) |
| * mpc_norm: Basic Arithmetic. (line 86) |
| * mpc_out_str: String and Stream Input and Output. |
| (line 112) |
| * mpc_pow: Power Functions and Logarithm. |
| (line 13) |
| * mpc_pow_d: Power Functions and Logarithm. |
| (line 15) |
| * mpc_pow_fr: Power Functions and Logarithm. |
| (line 25) |
| * mpc_pow_ld: Power Functions and Logarithm. |
| (line 17) |
| * mpc_pow_si: Power Functions and Logarithm. |
| (line 19) |
| * mpc_pow_ui: Power Functions and Logarithm. |
| (line 21) |
| * mpc_pow_z: Power Functions and Logarithm. |
| (line 23) |
| * mpc_proj: Projection & Decomposing. |
| (line 25) |
| * mpc_real: Projection & Decomposing. |
| (line 7) |
| * mpc_realref: Projection & Decomposing. |
| (line 15) |
| * mpc_rnd_t: GNU MPC Basics. (line 24) |
| * mpc_set: Assigning Complex Numbers. |
| (line 17) |
| * mpc_set_d: Assigning Complex Numbers. |
| (line 26) |
| * mpc_set_d_d: Assigning Complex Numbers. |
| (line 56) |
| * mpc_set_dc: Assigning Complex Numbers. |
| (line 29) |
| * mpc_set_f: Assigning Complex Numbers. |
| (line 34) |
| * mpc_set_f_f: Assigning Complex Numbers. |
| (line 64) |
| * mpc_set_fr: Assigning Complex Numbers. |
| (line 35) |
| * mpc_set_fr_fr: Assigning Complex Numbers. |
| (line 66) |
| * mpc_set_ld: Assigning Complex Numbers. |
| (line 27) |
| * mpc_set_ld_ld: Assigning Complex Numbers. |
| (line 58) |
| * mpc_set_ldc: Assigning Complex Numbers. |
| (line 31) |
| * mpc_set_nan: Assigning Complex Numbers. |
| (line 80) |
| * mpc_set_prec: Initializing Complex Numbers. |
| (line 42) |
| * mpc_set_q: Assigning Complex Numbers. |
| (line 33) |
| * mpc_set_q_q: Assigning Complex Numbers. |
| (line 62) |
| * mpc_set_si: Assigning Complex Numbers. |
| (line 23) |
| * mpc_set_si_si: Assigning Complex Numbers. |
| (line 50) |
| * mpc_set_sj: Assigning Complex Numbers. |
| (line 25) |
| * mpc_set_sj_sj: Assigning Complex Numbers. |
| (line 54) |
| * mpc_set_str: String and Stream Input and Output. |
| (line 38) |
| * mpc_set_ui: Assigning Complex Numbers. |
| (line 22) |
| * mpc_set_ui_ui: Assigning Complex Numbers. |
| (line 48) |
| * mpc_set_uj: Assigning Complex Numbers. |
| (line 24) |
| * mpc_set_uj_uj: Assigning Complex Numbers. |
| (line 52) |
| * MPC_SET_X_Y: Advanced Functions. (line 7) |
| * mpc_set_z: Assigning Complex Numbers. |
| (line 32) |
| * mpc_set_z_z: Assigning Complex Numbers. |
| (line 60) |
| * mpc_sin: Trigonometric Functions. |
| (line 7) |
| * mpc_sin_cos: Trigonometric Functions. |
| (line 16) |
| * mpc_sinh: Trigonometric Functions. |
| (line 25) |
| * mpc_sqr: Basic Arithmetic. (line 57) |
| * mpc_sqrt: Power Functions and Logarithm. |
| (line 7) |
| * mpc_strtoc: String and Stream Input and Output. |
| (line 8) |
| * mpc_sub: Basic Arithmetic. (line 21) |
| * mpc_sub_fr: Basic Arithmetic. (line 23) |
| * mpc_sub_ui: Basic Arithmetic. (line 27) |
| * mpc_swap: Assigning Complex Numbers. |
| (line 83) |
| * mpc_t: GNU MPC Basics. (line 15) |
| * mpc_tan: Trigonometric Functions. |
| (line 21) |
| * mpc_tanh: Trigonometric Functions. |
| (line 33) |
| * mpc_ui_div: Basic Arithmetic. (line 72) |
| * mpc_ui_sub: Basic Arithmetic. (line 29) |
| * mpc_ui_ui_sub: Basic Arithmetic. (line 31) |
| * mpc_urandom: Miscellaneous Complex Functions. |
| (line 7) |
| * MPC_VERSION: Miscellaneous Complex Functions. |
| (line 18) |
| * MPC_VERSION_MAJOR: Miscellaneous Complex Functions. |
| (line 19) |
| * MPC_VERSION_MINOR: Miscellaneous Complex Functions. |
| (line 20) |
| * MPC_VERSION_NUM: Miscellaneous Complex Functions. |
| (line 37) |
| * MPC_VERSION_PATCHLEVEL: Miscellaneous Complex Functions. |
| (line 21) |
| * MPC_VERSION_STRING: Miscellaneous Complex Functions. |
| (line 22) |
| * mpfr_prec_t: GNU MPC Basics. (line 19) |
| |
| |
| File: mpc.info, Node: GNU Free Documentation License, Prev: Function Index, Up: Top |
| |
| Anhang 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: Top738 |
| Node: Copying1445 |
| Node: Introduction to GNU MPC2216 |
| Node: Installing GNU MPC2934 |
| Node: Reporting Bugs8016 |
| Node: GNU MPC Basics9357 |
| Ref: return-value13055 |
| Node: Complex Functions14505 |
| Node: Initializing Complex Numbers15664 |
| Node: Assigning Complex Numbers18052 |
| Node: Converting Complex Numbers22451 |
| Node: String and Stream Input and Output23076 |
| Node: Complex Comparison29655 |
| Node: Projection & Decomposing30734 |
| Node: Basic Arithmetic32109 |
| Node: Power Functions and Logarithm36682 |
| Node: Trigonometric Functions38749 |
| Node: Miscellaneous Complex Functions40974 |
| Node: Advanced Functions43148 |
| Node: Internals44221 |
| Node: References44672 |
| Node: Concept Index45578 |
| Node: Function Index47892 |
| Node: GNU Free Documentation License61676 |
| |
| End Tag Table |