Context Navigation

gmp.info-2 @ 22254

Visit:

Revision 22254, 94.2 KB checked in by ghudson, 19 years ago (diff)
This commit was generated by cvs2svn to compensate for changes in r22253, which included commits to RCS files with non-trunk default branches.

Line
1	This is gmp.info, produced by makeinfo version 4.6 from gmp.texi.
2
3	This manual describes how to install and use the GNU multiple precision
4	arithmetic library, version 4.1.4.
5
6	Copyright 1991, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
7	2001, 2002, 2003, 2004 Free Software Foundation, Inc.
8
9	Permission is granted to copy, distribute and/or modify this
10	document under the terms of the GNU Free Documentation License, Version
11	1.1 or any later version published by the Free Software Foundation;
12	with no Invariant Sections, with the Front-Cover Texts being "A GNU
13	Manual", and with the Back-Cover Texts being "You have freedom to copy
14	and modify this GNU Manual, like GNU software". A copy of the license
15	is included in *Note GNU Free Documentation License::.
16	INFO-DIR-SECTION GNU libraries
17	START-INFO-DIR-ENTRY
18	* gmp: (gmp). GNU Multiple Precision Arithmetic Library.
19	END-INFO-DIR-ENTRY
20
21
22	File: gmp.info, Node: Assembler Floating Point, Next: Assembler SIMD Instructions, Prev: Assembler Cache Handling, Up: Assembler Coding
23
24	Floating Point
25	--------------
26
27	Floating point arithmetic is used in GMP for multiplications on CPUs
28	with poor integer multipliers. It's mostly useful for `mpn_mul_1',
29	`mpn_addmul_1' and `mpn_submul_1' on 64-bit machines, and
30	`mpn_mul_basecase' on both 32-bit and 64-bit machines.
31
32	With IEEE 53-bit double precision floats, integer multiplications
33	producing up to 53 bits will give exact results. Breaking a 64x64
34	multiplication into eight 16x32->48 bit pieces is convenient. With
35	some care though six 21x32->53 bit products can be used, if one of the
36	lower two 21-bit pieces also uses the sign bit.
37
38	For the `mpn_mul_1' family of functions on a 64-bit machine, the
39	invariant single limb is split at the start, into 3 or 4 pieces.
40	Inside the loop, the bignum operand is split into 32-bit pieces. Fast
41	conversion of these unsigned 32-bit pieces to floating point is highly
42	machine-dependent. In some cases, reading the data into the integer
43	unit, zero-extending to 64-bits, then transferring to the floating
44	point unit back via memory is the only option.
45
46	Converting partial products back to 64-bit limbs is usually best
47	done as a signed conversion. Since all values are smaller than 2^53,
48	signed and unsigned are the same, but most processors lack unsigned
49	conversions.
50
51
52
53	Here is a diagram showing 16x32 bit products for an `mpn_mul_1' or
54	`mpn_addmul_1' with a 64-bit limb. The single limb operand V is split
55	into four 16-bit parts. The multi-limb operand U is split in the loop
56	into two 32-bit parts.
57
58	+---+---+---+---+
59	\|v48\|v32\|v16\|v00\| V operand
60	+---+---+---+---+
61
62	+-------+---+---+
63	x \| u32 \| u00 \| U operand (one limb)
64	+---------------+
65
66	---------------------------------
67
68	+-----------+
69	\| u00 x v00 \| p00 48-bit products
70	+-----------+
71	+-----------+
72	\| u00 x v16 \| p16
73	+-----------+
74	+-----------+
75	\| u00 x v32 \| p32
76	+-----------+
77	+-----------+
78	\| u00 x v48 \| p48
79	+-----------+
80	+-----------+
81	\| u32 x v00 \| r32
82	+-----------+
83	+-----------+
84	\| u32 x v16 \| r48
85	+-----------+
86	+-----------+
87	\| u32 x v32 \| r64
88	+-----------+
89	+-----------+
90	\| u32 x v48 \| r80
91	+-----------+
92
93	p32 and r32 can be summed using floating-point addition, and
94	likewise p48 and r48. p00 and p16 can be summed with r64 and r80 from
95	the previous iteration.
96
97	For each loop then, four 49-bit quantities are transfered to the
98	integer unit, aligned as follows,
99
100	\|-----64bits----\|-----64bits----\|
101	+------------+
102	\| p00 + r64' \| i00
103	+------------+
104	+------------+
105	\| p16 + r80' \| i16
106	+------------+
107	+------------+
108	\| p32 + r32 \| i32
109	+------------+
110	+------------+
111	\| p48 + r48 \| i48
112	+------------+
113
114	The challenge then is to sum these efficiently and add in a carry
115	limb, generating a low 64-bit result limb and a high 33-bit carry limb
116	(i48 extends 33 bits into the high half).
117
118
119	File: gmp.info, Node: Assembler SIMD Instructions, Next: Assembler Software Pipelining, Prev: Assembler Floating Point, Up: Assembler Coding
120
121	SIMD Instructions
122	-----------------
123
124	The single-instruction multiple-data support in current microprocessors
125	is aimed at signal processing algorithms where each data point can be
126	treated more or less independently. There's generally not much support
127	for propagating the sort of carries that arise in GMP.
128
129	SIMD multiplications of say four 16x16 bit multiplies only do as much
130	work as one 32x32 from GMP's point of view, and need some shifts and
131	adds besides. But of course if say the SIMD form is fully pipelined
132	and uses less instruction decoding then it may still be worthwhile.
133
134	On the 80x86 chips, MMX has so far found a use in `mpn_rshift' and
135	`mpn_lshift' since it allows 64-bit operations, and is used in a special
136	case for 16-bit multipliers in the P55 `mpn_mul_1'. 3DNow and SSE
137	haven't found a use so far.
138
139
140	File: gmp.info, Node: Assembler Software Pipelining, Next: Assembler Loop Unrolling, Prev: Assembler SIMD Instructions, Up: Assembler Coding
141
142	Software Pipelining
143	-------------------
144
145	Software pipelining consists of scheduling instructions around the
146	branch point in a loop. For example a loop taking a checksum of an
147	array of limbs might have a load and an add, but the load wouldn't be
148	for that add, rather for the one next time around the loop. Each load
149	then is effectively scheduled back in the previous iteration, allowing
150	latency to be hidden.
151
152	Naturally this is wanted only when doing things like loads or
153	multiplies that take a few cycles to complete, and only where a CPU has
154	multiple functional units so that other work can be done while waiting.
155
156	A pipeline with several stages will have a data value in progress at
157	each stage and each loop iteration moves them along one stage. This is
158	like juggling.
159
160	Within the loop some moves between registers may be necessary to
161	have the right values in the right places for each iteration. Loop
162	unrolling can help this, with each unrolled block able to use different
163	registers for different values, even if some shuffling is still needed
164	just before going back to the top of the loop.
165
166
167	File: gmp.info, Node: Assembler Loop Unrolling, Prev: Assembler Software Pipelining, Up: Assembler Coding
168
169	Loop Unrolling
170	--------------
171
172	Loop unrolling consists of replicating code so that several limbs are
173	processed in each loop. At a minimum this reduces loop overheads by a
174	corresponding factor, but it can also allow better register usage, for
175	example alternately using one register combination and then another.
176	Judicious use of `m4' macros can help avoid lots of duplication in the
177	source code.
178
179	Unrolling is commonly done to a power of 2 multiple so the number of
180	unrolled loops and the number of remaining limbs can be calculated with
181	a shift and mask. But other multiples can be used too, just by
182	subtracting each N limbs processed from a counter and waiting for less
183	than N remaining (or offsetting the counter by N so it goes negative
184	when there's less than N remaining).
185
186	The limbs not a multiple of the unrolling can be handled in various
187	ways, for example
188
189	* A simple loop at the end (or the start) to process the excess.
190	Care will be wanted that it isn't too much slower than the
191	unrolled part.
192
193	* A set of binary tests, for example after an 8-limb unrolling, test
194	for 4 more limbs to process, then a further 2 more or not, and
195	finally 1 more or not. This will probably take more code space
196	than a simple loop.
197
198	* A `switch' statement, providing separate code for each possible
199	excess, for example an 8-limb unrolling would have separate code
200	for 0 remaining, 1 remaining, etc, up to 7 remaining. This might
201	take a lot of code, but may be the best way to optimize all cases
202	in combination with a deep pipelined loop.
203
204	* A computed jump into the middle of the loop, thus making the first
205	iteration handle the excess. This should make times smoothly
206	increase with size, which is attractive, but setups for the jump
207	and adjustments for pointers can be tricky and could become quite
208	difficult in combination with deep pipelining.
209
210	One way to write the setups and finishups for a pipelined unrolled
211	loop is simply to duplicate the loop at the start and the end, then
212	delete instructions at the start which have no valid antecedents, and
213	delete instructions at the end whose results are unwanted. Sizes not a
214	multiple of the unrolling can then be handled as desired.
215
216
217	File: gmp.info, Node: Internals, Next: Contributors, Prev: Algorithms, Up: Top
218
219	Internals
220	*********
221
222	*This chapter is provided only for informational purposes and the
223	various internals described here may change in future GMP releases.
224	Applications expecting to be compatible with future releases should use
225	only the documented interfaces described in previous chapters.*
226
227	* Menu:
228
229	* Integer Internals::
230	* Rational Internals::
231	* Float Internals::
232	* Raw Output Internals::
233	* C++ Interface Internals::
234
235
236	File: gmp.info, Node: Integer Internals, Next: Rational Internals, Prev: Internals, Up: Internals
237
238	Integer Internals
239	=================
240
241	`mpz_t' variables represent integers using sign and magnitude, in space
242	dynamically allocated and reallocated. The fields are as follows.
243
244	`_mp_size'
245	The number of limbs, or the negative of that when representing a
246	negative integer. Zero is represented by `_mp_size' set to zero,
247	in which case the `_mp_d' data is unused.
248
249	`_mp_d'
250	A pointer to an array of limbs which is the magnitude. These are
251	stored "little endian" as per the `mpn' functions, so `_mp_d[0]'
252	is the least significant limb and `_mp_d[ABS(_mp_size)-1]' is the
253	most significant. Whenever `_mp_size' is non-zero, the most
254	significant limb is non-zero.
255
256	Currently there's always at least one limb allocated, so for
257	instance `mpz_set_ui' never needs to reallocate, and `mpz_get_ui'
258	can fetch `_mp_d[0]' unconditionally (though its value is then
259	only wanted if `_mp_size' is non-zero).
260
261	`_mp_alloc'
262	`_mp_alloc' is the number of limbs currently allocated at `_mp_d',
263	and naturally `_mp_alloc >= ABS(_mp_size)'. When an `mpz' routine
264	is about to (or might be about to) increase `_mp_size', it checks
265	`_mp_alloc' to see whether there's enough space, and reallocates
266	if not. `MPZ_REALLOC' is generally used for this.
267
268	The various bitwise logical functions like `mpz_and' behave as if
269	negative values were twos complement. But sign and magnitude is always
270	used internally, and necessary adjustments are made during the
271	calculations. Sometimes this isn't pretty, but sign and magnitude are
272	best for other routines.
273
274	Some internal temporary variables are setup with `MPZ_TMP_INIT' and
275	these have `_mp_d' space obtained from `TMP_ALLOC' rather than the
276	memory allocation functions. Care is taken to ensure that these are
277	big enough that no reallocation is necessary (since it would have
278	unpredictable consequences).
279
280
281	File: gmp.info, Node: Rational Internals, Next: Float Internals, Prev: Integer Internals, Up: Internals
282
283	Rational Internals
284	==================
285
286	`mpq_t' variables represent rationals using an `mpz_t' numerator and
287	denominator (*note Integer Internals::).
288
289	The canonical form adopted is denominator positive (and non-zero),
290	no common factors between numerator and denominator, and zero uniquely
291	represented as 0/1.
292
293	It's believed that casting out common factors at each stage of a
294	calculation is best in general. A GCD is an O(N^2) operation so it's
295	better to do a few small ones immediately than to delay and have to do
296	a big one later. Knowing the numerator and denominator have no common
297	factors can be used for example in `mpq_mul' to make only two cross
298	GCDs necessary, not four.
299
300	This general approach to common factors is badly sub-optimal in the
301	presence of simple factorizations or little prospect for cancellation,
302	but GMP has no way to know when this will occur. As per *Note
303	Efficiency::, that's left to applications. The `mpq_t' framework might
304	still suit, with `mpq_numref' and `mpq_denref' for direct access to the
305	numerator and denominator, or of course `mpz_t' variables can be used
306	directly.
307
308
309	File: gmp.info, Node: Float Internals, Next: Raw Output Internals, Prev: Rational Internals, Up: Internals
310
311	Float Internals
312	===============
313
314	Efficient calculation is the primary aim of GMP floats and the use of
315	whole limbs and simple rounding facilitates this.
316
317	`mpf_t' floats have a variable precision mantissa and a single
318	machine word signed exponent. The mantissa is represented using sign
319	and magnitude.
320
321	most least
322	significant significant
323	limb limb
324
325	_mp_d
326	\|---- _mp_exp ---> \|
327	_____ _____ _____ _____ _____
328	\|_____\|_____\|_____\|_____\|_____\|
329	. <------------ radix point
330
331	<-------- _mp_size --------->
332
333	The fields are as follows.
334
335	`_mp_size'
336	The number of limbs currently in use, or the negative of that when
337	representing a negative value. Zero is represented by `_mp_size'
338	and `_mp_exp' both set to zero, and in that case the `_mp_d' data
339	is unused. (In the future `_mp_exp' might be undefined when
340	representing zero.)
341
342	`_mp_prec'
343	The precision of the mantissa, in limbs. In any calculation the
344	aim is to produce `_mp_prec' limbs of result (the most significant
345	being non-zero).
346
347	`_mp_d'
348	A pointer to the array of limbs which is the absolute value of the
349	mantissa. These are stored "little endian" as per the `mpn'
350	functions, so `_mp_d[0]' is the least significant limb and
351	`_mp_d[ABS(_mp_size)-1]' the most significant.
352
353	The most significant limb is always non-zero, but there are no
354	other restrictions on its value, in particular the highest 1 bit
355	can be anywhere within the limb.
356
357	`_mp_prec+1' limbs are allocated to `_mp_d', the extra limb being
358	for convenience (see below). There are no reallocations during a
359	calculation, only in a change of precision with `mpf_set_prec'.
360
361	`_mp_exp'
362	The exponent, in limbs, determining the location of the implied
363	radix point. Zero means the radix point is just above the most
364	significant limb. Positive values mean a radix point offset
365	towards the lower limbs and hence a value >= 1, as for example in
366	the diagram above. Negative exponents mean a radix point further
367	above the highest limb.
368
369	Naturally the exponent can be any value, it doesn't have to fall
370	within the limbs as the diagram shows, it can be a long way above
371	or a long way below. Limbs other than those included in the
372	`{_mp_d,_mp_size}' data are treated as zero.
373
374
375	The following various points should be noted.
376
377	Low Zeros
378	The least significant limbs `_mp_d[0]' etc can be zero, though
379	such low zeros can always be ignored. Routines likely to produce
380	low zeros check and avoid them to save time in subsequent
381	calculations, but for most routines they're quite unlikely and
382	aren't checked.
383
384	Mantissa Size Range
385	The `_mp_size' count of limbs in use can be less than `_mp_prec' if
386	the value can be represented in less. This means low precision
387	values or small integers stored in a high precision `mpf_t' can
388	still be operated on efficiently.
389
390	`_mp_size' can also be greater than `_mp_prec'. Firstly a value is
391	allowed to use all of the `_mp_prec+1' limbs available at `_mp_d',
392	and secondly when `mpf_set_prec_raw' lowers `_mp_prec' it leaves
393	`_mp_size' unchanged and so the size can be arbitrarily bigger than
394	`_mp_prec'.
395
396	Rounding
397	All rounding is done on limb boundaries. Calculating `_mp_prec'
398	limbs with the high non-zero will ensure the application requested
399	minimum precision is obtained.
400
401	The use of simple "trunc" rounding towards zero is efficient,
402	since there's no need to examine extra limbs and increment or
403	decrement.
404
405	Bit Shifts
406	Since the exponent is in limbs, there are no bit shifts in basic
407	operations like `mpf_add' and `mpf_mul'. When differing exponents
408	are encountered all that's needed is to adjust pointers to line up
409	the relevant limbs.
410
411	Of course `mpf_mul_2exp' and `mpf_div_2exp' will require bit
412	shifts, but the choice is between an exponent in limbs which
413	requires shifts there, or one in bits which requires them almost
414	everywhere else.
415
416	Use of `_mp_prec+1' Limbs
417	The extra limb on `_mp_d' (`_mp_prec+1' rather than just
418	`_mp_prec') helps when an `mpf' routine might get a carry from its
419	operation. `mpf_add' for instance will do an `mpn_add' of
420	`_mp_prec' limbs. If there's no carry then that's the result, but
421	if there is a carry then it's stored in the extra limb of space and
422	`_mp_size' becomes `_mp_prec+1'.
423
424	Whenever `_mp_prec+1' limbs are held in a variable, the low limb
425	is not needed for the intended precision, only the `_mp_prec' high
426	limbs. But zeroing it out or moving the rest down is unnecessary.
427	Subsequent routines reading the value will simply take the high
428	limbs they need, and this will be `_mp_prec' if their target has
429	that same precision. This is no more than a pointer adjustment,
430	and must be checked anyway since the destination precision can be
431	different from the sources.
432
433	Copy functions like `mpf_set' will retain a full `_mp_prec+1' limbs
434	if available. This ensures that a variable which has `_mp_size'
435	equal to `_mp_prec+1' will get its full exact value copied.
436	Strictly speaking this is unnecessary since only `_mp_prec' limbs
437	are needed for the application's requested precision, but it's
438	considered that an `mpf_set' from one variable into another of the
439	same precision ought to produce an exact copy.
440
441	Application Precisions
442	`__GMPF_BITS_TO_PREC' converts an application requested precision
443	to an `_mp_prec'. The value in bits is rounded up to a whole limb
444	then an extra limb is added since the most significant limb of
445	`_mp_d' is only non-zero and therefore might contain only one bit.
446
447	`__GMPF_PREC_TO_BITS' does the reverse conversion, and removes the
448	extra limb from `_mp_prec' before converting to bits. The net
449	effect of reading back with `mpf_get_prec' is simply the precision
450	rounded up to a multiple of `mp_bits_per_limb'.
451
452	Note that the extra limb added here for the high only being
453	non-zero is in addition to the extra limb allocated to `_mp_d'.
454	For example with a 32-bit limb, an application request for 250
455	bits will be rounded up to 8 limbs, then an extra added for the
456	high being only non-zero, giving an `_mp_prec' of 9. `_mp_d' then
457	gets 10 limbs allocated. Reading back with `mpf_get_prec' will
458	take `_mp_prec' subtract 1 limb and multiply by 32, giving 256
459	bits.
460
461	Strictly speaking, the fact the high limb has at least one bit
462	means that a float with, say, 3 limbs of 32-bits each will be
463	holding at least 65 bits, but for the purposes of `mpf_t' it's
464	considered simply to be 64 bits, a nice multiple of the limb size.
465
466
467	File: gmp.info, Node: Raw Output Internals, Next: C++ Interface Internals, Prev: Float Internals, Up: Internals
468
469	Raw Output Internals
470	====================
471
472	`mpz_out_raw' uses the following format.
473
474	+------+------------------------+
475	\| size \| data bytes \|
476	+------+------------------------+
477
478	The size is 4 bytes written most significant byte first, being the
479	number of subsequent data bytes, or the twos complement negative of
480	that when a negative integer is represented. The data bytes are the
481	absolute value of the integer, written most significant byte first.
482
483	The most significant data byte is always non-zero, so the output is
484	the same on all systems, irrespective of limb size.
485
486	In GMP 1, leading zero bytes were written to pad the data bytes to a
487	multiple of the limb size. `mpz_inp_raw' will still accept this, for
488	compatibility.
489
490	The use of "big endian" for both the size and data fields is
491	deliberate, it makes the data easy to read in a hex dump of a file.
492	Unfortunately it also means that the limb data must be reversed when
493	reading or writing, so neither a big endian nor little endian system
494	can just read and write `_mp_d'.
495
496
497	File: gmp.info, Node: C++ Interface Internals, Prev: Raw Output Internals, Up: Internals
498
499	C++ Interface Internals
500	=======================
501
502	A system of expression templates is used to ensure something like
503	`a=b+c' turns into a simple call to `mpz_add' etc. For `mpf_class' and
504	`mpfr_class' the scheme also ensures the precision of the final
505	destination is used for any temporaries within a statement like
506	`f=wx+yz'. These are important features which a naive implementation
507	cannot provide.
508
509	A simplified description of the scheme follows. The true scheme is
510	complicated by the fact that expressions have different return types.
511	For detailed information, refer to the source code.
512
513	To perform an operation, say, addition, we first define a "function
514	object" evaluating it,
515
516	struct __gmp_binary_plus
517	{
518	static void eval(mpf_t f, mpf_t g, mpf_t h) { mpf_add(f, g, h); }
519	};
520
521	And an "additive expression" object,
522
523	__gmp_expr<__gmp_binary_expr<mpf_class, mpf_class, __gmp_binary_plus> >
524	operator+(const mpf_class &f, const mpf_class &g)
525	{
526	return __gmp_expr
527	<__gmp_binary_expr<mpf_class, mpf_class, __gmp_binary_plus> >(f, g);
528	}
529
530	The seemingly redundant `__gmp_expr<__gmp_binary_expr<...>>' is used
531	to encapsulate any possible kind of expression into a single template
532	type. In fact even `mpf_class' etc are `typedef' specializations of
533	`__gmp_expr'.
534
535	Next we define assignment of `__gmp_expr' to `mpf_class'.
536
537	template <class T>
538	mpf_class & mpf_class::operator=(const __gmp_expr<T> &expr)
539	{
540	expr.eval(this->get_mpf_t(), this->precision());
541	return *this;
542	}
543
544	template <class Op>
545	void __gmp_expr<__gmp_binary_expr<mpf_class, mpf_class, Op> >::eval
546	(mpf_t f, unsigned long int precision)
547	{
548	Op::eval(f, expr.val1.get_mpf_t(), expr.val2.get_mpf_t());
549	}
550
551	where `expr.val1' and `expr.val2' are references to the expression's
552	operands (here `expr' is the `__gmp_binary_expr' stored within the
553	`__gmp_expr').
554
555	This way, the expression is actually evaluated only at the time of
556	assignment, when the required precision (that of `f') is known.
557	Furthermore the target `mpf_t' is now available, thus we can call
558	`mpf_add' directly with `f' as the output argument.
559
560	Compound expressions are handled by defining operators taking
561	subexpressions as their arguments, like this:
562
563	template <class T, class U>
564	__gmp_expr
565	<__gmp_binary_expr<__gmp_expr<T>, __gmp_expr<U>, __gmp_binary_plus> >
566	operator+(const __gmp_expr<T> &expr1, const __gmp_expr<U> &expr2)
567	{
568	return __gmp_expr
569	<__gmp_binary_expr<__gmp_expr<T>, __gmp_expr<U>, __gmp_binary_plus> >
570	(expr1, expr2);
571	}
572
573	And the corresponding specializations of `__gmp_expr::eval':
574
575	template <class T, class U, class Op>
576	void __gmp_expr
577	<__gmp_binary_expr<__gmp_expr<T>, __gmp_expr<U>, Op> >::eval
578	(mpf_t f, unsigned long int precision)
579	{
580	// declare two temporaries
581	mpf_class temp1(expr.val1, precision), temp2(expr.val2, precision);
582	Op::eval(f, temp1.get_mpf_t(), temp2.get_mpf_t());
583	}
584
585	The expression is thus recursively evaluated to any level of
586	complexity and all subexpressions are evaluated to the precision of `f'.
587
588
589	File: gmp.info, Node: Contributors, Next: References, Prev: Internals, Up: Top
590
591	Contributors
592	************
593
594	Torbjorn Granlund wrote the original GMP library and is still
595	developing and maintaining it. Several other individuals and
596	organizations have contributed to GMP in various ways. Here is a list
597	in chronological order:
598
599	Gunnar Sjoedin and Hans Riesel helped with mathematical problems in
600	early versions of the library.
601
602	Richard Stallman contributed to the interface design and revised the
603	first version of this manual.
604
605	Brian Beuning and Doug Lea helped with testing of early versions of
606	the library and made creative suggestions.
607
608	John Amanatides of York University in Canada contributed the function
609	`mpz_probab_prime_p'.
610
611	Paul Zimmermann of Inria sparked the development of GMP 2, with his
612	comparisons between bignum packages.
613
614	Ken Weber (Kent State University, Universidade Federal do Rio Grande
615	do Sul) contributed `mpz_gcd', `mpz_divexact', `mpn_gcd', and
616	`mpn_bdivmod', partially supported by CNPq (Brazil) grant 301314194-2.
617
618	Per Bothner of Cygnus Support helped to set up GMP to use Cygnus'
619	configure. He has also made valuable suggestions and tested numerous
620	intermediary releases.
621
622	Joachim Hollman was involved in the design of the `mpf' interface,
623	and in the `mpz' design revisions for version 2.
624
625	Bennet Yee contributed the initial versions of `mpz_jacobi' and
626	`mpz_legendre'.
627
628	Andreas Schwab contributed the files `mpn/m68k/lshift.S' and
629	`mpn/m68k/rshift.S' (now in `.asm' form).
630
631	The development of floating point functions of GNU MP 2, were
632	supported in part by the ESPRIT-BRA (Basic Research Activities) 6846
633	project POSSO (POlynomial System SOlving).
634
635	GNU MP 2 was finished and released by SWOX AB, SWEDEN, in
636	cooperation with the IDA Center for Computing Sciences, USA.
637
638	Robert Harley of Inria, France and David Seal of ARM, England,
639	suggested clever improvements for population count.
640
641	Robert Harley also wrote highly optimized Karatsuba and 3-way Toom
642	multiplication functions for GMP 3. He also contributed the ARM
643	assembly code.
644
645	Torsten Ekedahl of the Mathematical department of Stockholm
646	University provided significant inspiration during several phases of
647	the GMP development. His mathematical expertise helped improve several
648	algorithms.
649
650	Paul Zimmermann wrote the Divide and Conquer division code, the REDC
651	code, the REDC-based mpz_powm code, the FFT multiply code, and the
652	Karatsuba square root. The ECMNET project Paul is organizing was a
653	driving force behind many of the optimizations in GMP 3.
654
655	Linus Nordberg wrote the new configure system based on autoconf and
656	implemented the new random functions.
657
658	Kent Boortz made the Macintosh port.
659
660	Kevin Ryde worked on a number of things: optimized x86 code, m4 asm
661	macros, parameter tuning, speed measuring, the configure system,
662	function inlining, divisibility tests, bit scanning, Jacobi symbols,
663	Fibonacci and Lucas number functions, printf and scanf functions, perl
664	interface, demo expression parser, the algorithms chapter in the
665	manual, `gmpasm-mode.el', and various miscellaneous improvements
666	elsewhere.
667
668	Steve Root helped write the optimized alpha 21264 assembly code.
669
670	Gerardo Ballabio wrote the `gmpxx.h' C++ class interface and the C++
671	`istream' input routines.
672
673	GNU MP 4.0 was finished and released by Torbjorn Granlund and Kevin
674	Ryde. Torbjorn's work was partially funded by the IDA Center for
675	Computing Sciences, USA.
676
677	(This list is chronological, not ordered after significance. If you
678	have contributed to GMP but are not listed above, please tell
679	<tege@swox.com> about the omission!)
680
681	Thanks goes to Hans Thorsen for donating an SGI system for the GMP
682	test system environment.
683
684
685	File: gmp.info, Node: References, Next: GNU Free Documentation License, Prev: Contributors, Up: Top
686
687	References
688	**********
689
690	Books
691	=====
692
693	* Jonathan M. Borwein and Peter B. Borwein, "Pi and the AGM: A Study
694	in Analytic Number Theory and Computational Complexity", Wiley,
695	John & Sons, 1998.
696
697	* Henri Cohen, "A Course in Computational Algebraic Number Theory",
698	Graduate Texts in Mathematics number 138, Springer-Verlag, 1993.
699	`http://www.math.u-bordeaux.fr/~cohen'
700
701	* Donald E. Knuth, "The Art of Computer Programming", volume 2,
702	"Seminumerical Algorithms", 3rd edition, Addison-Wesley, 1998.
703	`http://www-cs-faculty.stanford.edu/~knuth/taocp.html'
704
705	* John D. Lipson, "Elements of Algebra and Algebraic Computing", The
706	Benjamin Cummings Publishing Company Inc, 1981.
707
708	* Alfred J. Menezes, Paul C. van Oorschot and Scott A. Vanstone,
709	"Handbook of Applied Cryptography",
710	`http://www.cacr.math.uwaterloo.ca/hac/'
711
712	* Richard M. Stallman, "Using and Porting GCC", Free Software
713	Foundation, 1999, available online
714	`http://www.gnu.org/software/gcc/onlinedocs/', and in the GCC
715	package `ftp://ftp.gnu.org/gnu/gcc/'
716
717	Papers
718	======
719
720	* Yves Bertot, Nicolas Magaud and Paul Zimmermann, "A Proof of GMP
721	Square Root", Journal of Automated Reasoning, volume 29, 2002, pp.
722	225-252. Also available online as INRIA Research Report 4475,
723	June 2001, `http://www.inria.fr/rrrt/rr-4475.html'
724
725	* Christoph Burnikel and Joachim Ziegler, "Fast Recursive Division",
726	Max-Planck-Institut fuer Informatik Research Report
727	MPI-I-98-1-022,
728	`http://data.mpi-sb.mpg.de/internet/reports.nsf/NumberView/1998-1-022'
729
730	* Torbjorn Granlund and Peter L. Montgomery, "Division by Invariant
731	Integers using Multiplication", in Proceedings of the SIGPLAN
732	PLDI'94 Conference, June 1994. Also available
733	`ftp://ftp.cwi.nl/pub/pmontgom/divcnst.psa4.gz' (and .psl.gz).
734
735	* Peter L. Montgomery, "Modular Multiplication Without Trial
736	Division", in Mathematics of Computation, volume 44, number 170,
737	April 1985.
738
739	* Tudor Jebelean, "An algorithm for exact division", Journal of
740	Symbolic Computation, volume 15, 1993, pp. 169-180. Research
741	report version available
742	`ftp://ftp.risc.uni-linz.ac.at/pub/techreports/1992/92-35.ps.gz'
743
744	* Tudor Jebelean, "Exact Division with Karatsuba Complexity -
745	Extended Abstract", RISC-Linz technical report 96-31,
746	`ftp://ftp.risc.uni-linz.ac.at/pub/techreports/1996/96-31.ps.gz'
747
748	* Tudor Jebelean, "Practical Integer Division with Karatsuba
749	Complexity", ISSAC 97, pp. 339-341. Technical report available
750	`ftp://ftp.risc.uni-linz.ac.at/pub/techreports/1996/96-29.ps.gz'
751
752	* Tudor Jebelean, "A Generalization of the Binary GCD Algorithm",
753	ISSAC 93, pp. 111-116. Technical report version available
754	`ftp://ftp.risc.uni-linz.ac.at/pub/techreports/1993/93-01.ps.gz'
755
756	* Tudor Jebelean, "A Double-Digit Lehmer-Euclid Algorithm for
757	Finding the GCD of Long Integers", Journal of Symbolic
758	Computation, volume 19, 1995, pp. 145-157. Technical report
759	version also available
760	`ftp://ftp.risc.uni-linz.ac.at/pub/techreports/1992/92-69.ps.gz'
761
762	* Werner Krandick and Tudor Jebelean, "Bidirectional Exact Integer
763	Division", Journal of Symbolic Computation, volume 21, 1996, pp.
764	441-455. Early technical report version also available
765	`ftp://ftp.risc.uni-linz.ac.at/pub/techreports/1994/94-50.ps.gz'
766
767	* R. Moenck and A. Borodin, "Fast Modular Transforms via Division",
768	Proceedings of the 13th Annual IEEE Symposium on Switching and
769	Automata Theory, October 1972, pp. 90-96. Reprinted as "Fast
770	Modular Transforms", Journal of Computer and System Sciences,
771	volume 8, number 3, June 1974, pp. 366-386.
772
773	* Arnold Scho"nhage and Volker Strassen, "Schnelle Multiplikation
774	grosser Zahlen", Computing 7, 1971, pp. 281-292.
775
776	* Kenneth Weber, "The accelerated integer GCD algorithm", ACM
777	Transactions on Mathematical Software, volume 21, number 1, March
778	1995, pp. 111-122.
779
780	* Paul Zimmermann, "Karatsuba Square Root", INRIA Research Report
781	3805, November 1999, `http://www.inria.fr/RRRT/RR-3805.html'
782
783	* Paul Zimmermann, "A Proof of GMP Fast Division and Square Root
784	Implementations",
785	`http://www.loria.fr/~zimmerma/papers/proof-div-sqrt.ps.gz'
786
787	* Dan Zuras, "On Squaring and Multiplying Large Integers", ARITH-11:
788	IEEE Symposium on Computer Arithmetic, 1993, pp. 260 to 271.
789	Reprinted as "More on Multiplying and Squaring Large Integers",
790	IEEE Transactions on Computers, volume 43, number 8, August 1994,
791	pp. 899-908.
792
793
794	File: gmp.info, Node: GNU Free Documentation License, Next: Concept Index, Prev: References, Up: Top
795
796	GNU Free Documentation License
797	******************************
798
799	Version 1.2, November 2002
800	Copyright (C) 2000,2001,2002 Free Software Foundation, Inc.
801	59 Temple Place, Suite 330, Boston, MA 02111-1307, USA
802
803	Everyone is permitted to copy and distribute verbatim copies
804	of this license document, but changing it is not allowed.
805
806	0. PREAMBLE
807
808	The purpose of this License is to make a manual, textbook, or other
809	functional and useful document "free" in the sense of freedom: to
810	assure everyone the effective freedom to copy and redistribute it,
811	with or without modifying it, either commercially or
812	noncommercially. Secondarily, this License preserves for the
813	author and publisher a way to get credit for their work, while not
814	being considered responsible for modifications made by others.
815
816	This License is a kind of "copyleft", which means that derivative
817	works of the document must themselves be free in the same sense.
818	It complements the GNU General Public License, which is a copyleft
819	license designed for free software.
820
821	We have designed this License in order to use it for manuals for
822	free software, because free software needs free documentation: a
823	free program should come with manuals providing the same freedoms
824	that the software does. But this License is not limited to
825	software manuals; it can be used for any textual work, regardless
826	of subject matter or whether it is published as a printed book.
827	We recommend this License principally for works whose purpose is
828	instruction or reference.
829
830	1. APPLICABILITY AND DEFINITIONS
831
832	This License applies to any manual or other work, in any medium,
833	that contains a notice placed by the copyright holder saying it
834	can be distributed under the terms of this License. Such a notice
835	grants a world-wide, royalty-free license, unlimited in duration,
836	to use that work under the conditions stated herein. The
837	"Document", below, refers to any such manual or work. Any member
838	of the public is a licensee, and is addressed as "you". You
839	accept the license if you copy, modify or distribute the work in a
840	way requiring permission under copyright law.
841
842	A "Modified Version" of the Document means any work containing the
843	Document or a portion of it, either copied verbatim, or with
844	modifications and/or translated into another language.
845
846	A "Secondary Section" is a named appendix or a front-matter section
847	of the Document that deals exclusively with the relationship of the
848	publishers or authors of the Document to the Document's overall
849	subject (or to related matters) and contains nothing that could
850	fall directly within that overall subject. (Thus, if the Document
851	is in part a textbook of mathematics, a Secondary Section may not
852	explain any mathematics.) The relationship could be a matter of
853	historical connection with the subject or with related matters, or
854	of legal, commercial, philosophical, ethical or political position
855	regarding them.
856
857	The "Invariant Sections" are certain Secondary Sections whose
858	titles are designated, as being those of Invariant Sections, in
859	the notice that says that the Document is released under this
860	License. If a section does not fit the above definition of
861	Secondary then it is not allowed to be designated as Invariant.
862	The Document may contain zero Invariant Sections. If the Document
863	does not identify any Invariant Sections then there are none.
864
865	The "Cover Texts" are certain short passages of text that are
866	listed, as Front-Cover Texts or Back-Cover Texts, in the notice
867	that says that the Document is released under this License. A
868	Front-Cover Text may be at most 5 words, and a Back-Cover Text may
869	be at most 25 words.
870
871	A "Transparent" copy of the Document means a machine-readable copy,
872	represented in a format whose specification is available to the
873	general public, that is suitable for revising the document
874	straightforwardly with generic text editors or (for images
875	composed of pixels) generic paint programs or (for drawings) some
876	widely available drawing editor, and that is suitable for input to
877	text formatters or for automatic translation to a variety of
878	formats suitable for input to text formatters. A copy made in an
879	otherwise Transparent file format whose markup, or absence of
880	markup, has been arranged to thwart or discourage subsequent
881	modification by readers is not Transparent. An image format is
882	not Transparent if used for any substantial amount of text. A
883	copy that is not "Transparent" is called "Opaque".
884
885	Examples of suitable formats for Transparent copies include plain
886	ASCII without markup, Texinfo input format, LaTeX input format,
887	SGML or XML using a publicly available DTD, and
888	standard-conforming simple HTML, PostScript or PDF designed for
889	human modification. Examples of transparent image formats include
890	PNG, XCF and JPG. Opaque formats include proprietary formats that
891	can be read and edited only by proprietary word processors, SGML or
892	XML for which the DTD and/or processing tools are not generally
893	available, and the machine-generated HTML, PostScript or PDF
894	produced by some word processors for output purposes only.
895
896	The "Title Page" means, for a printed book, the title page itself,
897	plus such following pages as are needed to hold, legibly, the
898	material this License requires to appear in the title page. For
899	works in formats which do not have any title page as such, "Title
900	Page" means the text near the most prominent appearance of the
901	work's title, preceding the beginning of the body of the text.
902
903	A section "Entitled XYZ" means a named subunit of the Document
904	whose title either is precisely XYZ or contains XYZ in parentheses
905	following text that translates XYZ in another language. (Here XYZ
906	stands for a specific section name mentioned below, such as
907	"Acknowledgements", "Dedications", "Endorsements", or "History".)
908	To "Preserve the Title" of such a section when you modify the
909	Document means that it remains a section "Entitled XYZ" according
910	to this definition.
911
912	The Document may include Warranty Disclaimers next to the notice
913	which states that this License applies to the Document. These
914	Warranty Disclaimers are considered to be included by reference in
915	this License, but only as regards disclaiming warranties: any other
916	implication that these Warranty Disclaimers may have is void and
917	has no effect on the meaning of this License.
918
919	2. VERBATIM COPYING
920
921	You may copy and distribute the Document in any medium, either
922	commercially or noncommercially, provided that this License, the
923	copyright notices, and the license notice saying this License
924	applies to the Document are reproduced in all copies, and that you
925	add no other conditions whatsoever to those of this License. You
926	may not use technical measures to obstruct or control the reading
927	or further copying of the copies you make or distribute. However,
928	you may accept compensation in exchange for copies. If you
929	distribute a large enough number of copies you must also follow
930	the conditions in section 3.
931
932	You may also lend copies, under the same conditions stated above,
933	and you may publicly display copies.
934
935	3. COPYING IN QUANTITY
936
937	If you publish printed copies (or copies in media that commonly
938	have printed covers) of the Document, numbering more than 100, and
939	the Document's license notice requires Cover Texts, you must
940	enclose the copies in covers that carry, clearly and legibly, all
941	these Cover Texts: Front-Cover Texts on the front cover, and
942	Back-Cover Texts on the back cover. Both covers must also clearly
943	and legibly identify you as the publisher of these copies. The
944	front cover must present the full title with all words of the
945	title equally prominent and visible. You may add other material
946	on the covers in addition. Copying with changes limited to the
947	covers, as long as they preserve the title of the Document and
948	satisfy these conditions, can be treated as verbatim copying in
949	other respects.
950
951	If the required texts for either cover are too voluminous to fit
952	legibly, you should put the first ones listed (as many as fit
953	reasonably) on the actual cover, and continue the rest onto
954	adjacent pages.
955
956	If you publish or distribute Opaque copies of the Document
957	numbering more than 100, you must either include a
958	machine-readable Transparent copy along with each Opaque copy, or
959	state in or with each Opaque copy a computer-network location from
960	which the general network-using public has access to download
961	using public-standard network protocols a complete Transparent
962	copy of the Document, free of added material. If you use the
963	latter option, you must take reasonably prudent steps, when you
964	begin distribution of Opaque copies in quantity, to ensure that
965	this Transparent copy will remain thus accessible at the stated
966	location until at least one year after the last time you
967	distribute an Opaque copy (directly or through your agents or
968	retailers) of that edition to the public.
969
970	It is requested, but not required, that you contact the authors of
971	the Document well before redistributing any large number of
972	copies, to give them a chance to provide you with an updated
973	version of the Document.
974
975	4. MODIFICATIONS
976
977	You may copy and distribute a Modified Version of the Document
978	under the conditions of sections 2 and 3 above, provided that you
979	release the Modified Version under precisely this License, with
980	the Modified Version filling the role of the Document, thus
981	licensing distribution and modification of the Modified Version to
982	whoever possesses a copy of it. In addition, you must do these
983	things in the Modified Version:
984
985	A. Use in the Title Page (and on the covers, if any) a title
986	distinct from that of the Document, and from those of
987	previous versions (which should, if there were any, be listed
988	in the History section of the Document). You may use the
989	same title as a previous version if the original publisher of
990	that version gives permission.
991
992	B. List on the Title Page, as authors, one or more persons or
993	entities responsible for authorship of the modifications in
994	the Modified Version, together with at least five of the
995	principal authors of the Document (all of its principal
996	authors, if it has fewer than five), unless they release you
997	from this requirement.
998
999	C. State on the Title page the name of the publisher of the
1000	Modified Version, as the publisher.
1001
1002	D. Preserve all the copyright notices of the Document.
1003
1004	E. Add an appropriate copyright notice for your modifications
1005	adjacent to the other copyright notices.
1006
1007	F. Include, immediately after the copyright notices, a license
1008	notice giving the public permission to use the Modified
1009	Version under the terms of this License, in the form shown in
1010	the Addendum below.
1011
1012	G. Preserve in that license notice the full lists of Invariant
1013	Sections and required Cover Texts given in the Document's
1014	license notice.
1015
1016	H. Include an unaltered copy of this License.
1017
1018	I. Preserve the section Entitled "History", Preserve its Title,
1019	and add to it an item stating at least the title, year, new
1020	authors, and publisher of the Modified Version as given on
1021	the Title Page. If there is no section Entitled "History" in
1022	the Document, create one stating the title, year, authors,
1023	and publisher of the Document as given on its Title Page,
1024	then add an item describing the Modified Version as stated in
1025	the previous sentence.
1026
1027	J. Preserve the network location, if any, given in the Document
1028	for public access to a Transparent copy of the Document, and
1029	likewise the network locations given in the Document for
1030	previous versions it was based on. These may be placed in
1031	the "History" section. You may omit a network location for a
1032	work that was published at least four years before the
1033	Document itself, or if the original publisher of the version
1034	it refers to gives permission.
1035
1036	K. For any section Entitled "Acknowledgements" or "Dedications",
1037	Preserve the Title of the section, and preserve in the
1038	section all the substance and tone of each of the contributor
1039	acknowledgements and/or dedications given therein.
1040
1041	L. Preserve all the Invariant Sections of the Document,
1042	unaltered in their text and in their titles. Section numbers
1043	or the equivalent are not considered part of the section
1044	titles.
1045
1046	M. Delete any section Entitled "Endorsements". Such a section
1047	may not be included in the Modified Version.
1048
1049	N. Do not retitle any existing section to be Entitled
1050	"Endorsements" or to conflict in title with any Invariant
1051	Section.
1052
1053	O. Preserve any Warranty Disclaimers.
1054
1055	If the Modified Version includes new front-matter sections or
1056	appendices that qualify as Secondary Sections and contain no
1057	material copied from the Document, you may at your option
1058	designate some or all of these sections as invariant. To do this,
1059	add their titles to the list of Invariant Sections in the Modified
1060	Version's license notice. These titles must be distinct from any
1061	other section titles.
1062
1063	You may add a section Entitled "Endorsements", provided it contains
1064	nothing but endorsements of your Modified Version by various
1065	parties--for example, statements of peer review or that the text
1066	has been approved by an organization as the authoritative
1067	definition of a standard.
1068
1069	You may add a passage of up to five words as a Front-Cover Text,
1070	and a passage of up to 25 words as a Back-Cover Text, to the end
1071	of the list of Cover Texts in the Modified Version. Only one
1072	passage of Front-Cover Text and one of Back-Cover Text may be
1073	added by (or through arrangements made by) any one entity. If the
1074	Document already includes a cover text for the same cover,
1075	previously added by you or by arrangement made by the same entity
1076	you are acting on behalf of, you may not add another; but you may
1077	replace the old one, on explicit permission from the previous
1078	publisher that added the old one.
1079
1080	The author(s) and publisher(s) of the Document do not by this
1081	License give permission to use their names for publicity for or to
1082	assert or imply endorsement of any Modified Version.
1083
1084	5. COMBINING DOCUMENTS
1085
1086	You may combine the Document with other documents released under
1087	this License, under the terms defined in section 4 above for
1088	modified versions, provided that you include in the combination
1089	all of the Invariant Sections of all of the original documents,
1090	unmodified, and list them all as Invariant Sections of your
1091	combined work in its license notice, and that you preserve all
1092	their Warranty Disclaimers.
1093
1094	The combined work need only contain one copy of this License, and
1095	multiple identical Invariant Sections may be replaced with a single
1096	copy. If there are multiple Invariant Sections with the same name
1097	but different contents, make the title of each such section unique
1098	by adding at the end of it, in parentheses, the name of the
1099	original author or publisher of that section if known, or else a
1100	unique number. Make the same adjustment to the section titles in
1101	the list of Invariant Sections in the license notice of the
1102	combined work.
1103
1104	In the combination, you must combine any sections Entitled
1105	"History" in the various original documents, forming one section
1106	Entitled "History"; likewise combine any sections Entitled
1107	"Acknowledgements", and any sections Entitled "Dedications". You
1108	must delete all sections Entitled "Endorsements."
1109
1110	6. COLLECTIONS OF DOCUMENTS
1111
1112	You may make a collection consisting of the Document and other
1113	documents released under this License, and replace the individual
1114	copies of this License in the various documents with a single copy
1115	that is included in the collection, provided that you follow the
1116	rules of this License for verbatim copying of each of the
1117	documents in all other respects.
1118
1119	You may extract a single document from such a collection, and
1120	distribute it individually under this License, provided you insert
1121	a copy of this License into the extracted document, and follow
1122	this License in all other respects regarding verbatim copying of
1123	that document.
1124
1125	7. AGGREGATION WITH INDEPENDENT WORKS
1126
1127	A compilation of the Document or its derivatives with other
1128	separate and independent documents or works, in or on a volume of
1129	a storage or distribution medium, is called an "aggregate" if the
1130	copyright resulting from the compilation is not used to limit the
1131	legal rights of the compilation's users beyond what the individual
1132	works permit. When the Document is included in an aggregate, this
1133	License does not apply to the other works in the aggregate which
1134	are not themselves derivative works of the Document.
1135
1136	If the Cover Text requirement of section 3 is applicable to these
1137	copies of the Document, then if the Document is less than one half
1138	of the entire aggregate, the Document's Cover Texts may be placed
1139	on covers that bracket the Document within the aggregate, or the
1140	electronic equivalent of covers if the Document is in electronic
1141	form. Otherwise they must appear on printed covers that bracket
1142	the whole aggregate.
1143
1144	8. TRANSLATION
1145
1146	Translation is considered a kind of modification, so you may
1147	distribute translations of the Document under the terms of section
1148	4. Replacing Invariant Sections with translations requires special
1149	permission from their copyright holders, but you may include
1150	translations of some or all Invariant Sections in addition to the
1151	original versions of these Invariant Sections. You may include a
1152	translation of this License, and all the license notices in the
1153	Document, and any Warranty Disclaimers, provided that you also
1154	include the original English version of this License and the
1155	original versions of those notices and disclaimers. In case of a
1156	disagreement between the translation and the original version of
1157	this License or a notice or disclaimer, the original version will
1158	prevail.
1159
1160	If a section in the Document is Entitled "Acknowledgements",
1161	"Dedications", or "History", the requirement (section 4) to
1162	Preserve its Title (section 1) will typically require changing the
1163	actual title.
1164
1165	9. TERMINATION
1166
1167	You may not copy, modify, sublicense, or distribute the Document
1168	except as expressly provided for under this License. Any other
1169	attempt to copy, modify, sublicense or distribute the Document is
1170	void, and will automatically terminate your rights under this
1171	License. However, parties who have received copies, or rights,
1172	from you under this License will not have their licenses
1173	terminated so long as such parties remain in full compliance.
1174
1175	10. FUTURE REVISIONS OF THIS LICENSE
1176
1177	The Free Software Foundation may publish new, revised versions of
1178	the GNU Free Documentation License from time to time. Such new
1179	versions will be similar in spirit to the present version, but may
1180	differ in detail to address new problems or concerns. See
1181	`http://www.gnu.org/copyleft/'.
1182
1183	Each version of the License is given a distinguishing version
1184	number. If the Document specifies that a particular numbered
1185	version of this License "or any later version" applies to it, you
1186	have the option of following the terms and conditions either of
1187	that specified version or of any later version that has been
1188	published (not as a draft) by the Free Software Foundation. If
1189	the Document does not specify a version number of this License,
1190	you may choose any version ever published (not as a draft) by the
1191	Free Software Foundation.
1192
1193	ADDENDUM: How to use this License for your documents
1194	====================================================
1195
1196	To use this License in a document you have written, include a copy of
1197	the License in the document and put the following copyright and license
1198	notices just after the title page:
1199
1200	Copyright (C) YEAR YOUR NAME.
1201	Permission is granted to copy, distribute and/or modify this document
1202	under the terms of the GNU Free Documentation License, Version 1.2
1203	or any later version published by the Free Software Foundation;
1204	with no Invariant Sections, no Front-Cover Texts, and no Back-Cover
1205	Texts. A copy of the license is included in the section entitled ``GNU
1206	Free Documentation License''.
1207
1208	If you have Invariant Sections, Front-Cover Texts and Back-Cover
1209	Texts, replace the "with...Texts." line with this:
1210
1211	with the Invariant Sections being LIST THEIR TITLES, with
1212	the Front-Cover Texts being LIST, and with the Back-Cover Texts
1213	being LIST.
1214
1215	If you have Invariant Sections without Cover Texts, or some other
1216	combination of the three, merge those two alternatives to suit the
1217	situation.
1218
1219	If your document contains nontrivial examples of program code, we
1220	recommend releasing these examples in parallel under your choice of
1221	free software license, such as the GNU General Public License, to
1222	permit their use in free software.
1223
1224
1225	File: gmp.info, Node: Concept Index, Next: Function Index, Prev: GNU Free Documentation License, Up: Top
1226
1227	Concept Index
1228	*************
1229
1230	* Menu:
1231
1232	* --exec-prefix: Build Options.
1233	* --prefix: Build Options.
1234	* 68000: Known Build Problems.
1235	* ABI: ABI and ISA.
1236	* About this manual: Introduction to GMP.
1237	* Algorithms: Algorithms.
1238	* alloca: Build Options.
1239	* Allocation of memory: Custom Allocation.
1240	* Anonymous FTP of latest version: Introduction to GMP.
1241	* Application Binary Interface: ABI and ISA.
1242	* Arithmetic functions <1>: Float Arithmetic.
1243	* Arithmetic functions <2>: Rational Arithmetic.
1244	* Arithmetic functions: Integer Arithmetic.
1245	* Assignment functions <1>: Assigning Floats.
1246	* Assignment functions: Assigning Integers.
1247	* Autoconf detections: Autoconf.
1248	* Basics: GMP Basics.
1249	* Berkeley MP compatible functions: BSD Compatible Functions.
1250	* Binomial coefficient functions: Number Theoretic Functions.
1251	* Bit manipulation functions: Integer Logic and Bit Fiddling.
1252	* Bit shift left: Integer Arithmetic.
1253	* Bit shift right: Integer Division.
1254	* Bits per limb: Useful Macros and Constants.
1255	* BSD MP compatible functions: BSD Compatible Functions.
1256	* Bug reporting: Reporting Bugs.
1257	* Build notes for binary packaging: Notes for Package Builds.
1258	* Build notes for particular systems: Notes for Particular Systems.
1259	* Build options: Build Options.
1260	* Build problems known: Known Build Problems.
1261	* Building GMP: Installing GMP.
1262	* C++ Interface: C++ Class Interface.
1263	* C++ istream input: C++ Formatted Input.
1264	* C++ ostream output: C++ Formatted Output.
1265	* Comparison functions <1>: Integer Comparisons.
1266	* Comparison functions <2>: Float Comparison.
1267	* Comparison functions: Comparing Rationals.
1268	* Compatibility with older versions: Compatibility with older versions.
1269	* Conditions for copying GNU MP: Copying.
1270	* Configuring GMP: Installing GMP.
1271	* Constants: Useful Macros and Constants.
1272	* Contributors: Contributors.
1273	* Conventions for parameters: Parameter Conventions.
1274	* Conventions for variables: Variable Conventions.
1275	* Conversion functions <1>: Converting Integers.
1276	* Conversion functions <2>: Converting Floats.
1277	* Conversion functions: Rational Conversions.
1278	* Copying conditions: Copying.
1279	* CPUs supported: Introduction to GMP.
1280	* Custom allocation: Custom Allocation.
1281	* Debugging: Debugging.
1282	* Demonstration programs: Demonstration Programs.
1283	* DESTDIR: Known Build Problems.
1284	* Digits in an integer: Miscellaneous Integer Functions.
1285	* Division algorithms: Division Algorithms.
1286	* Division functions <1>: Integer Division.
1287	* Division functions <2>: Rational Arithmetic.
1288	* Division functions: Float Arithmetic.
1289	* Efficiency: Efficiency.
1290	* Emacs: Emacs.
1291	* Exact division functions: Integer Division.
1292	* Example programs: Demonstration Programs.
1293	* Exec prefix: Build Options.
1294	* Exponentiation functions <1>: Integer Exponentiation.
1295	* Exponentiation functions: Float Arithmetic.
1296	* Export: Integer Import and Export.
1297	* Extended GCD: Number Theoretic Functions.
1298	* Factorial functions: Number Theoretic Functions.
1299	* FDL, GNU Free Documentation License: GNU Free Documentation License.
1300	* Fibonacci sequence functions: Number Theoretic Functions.
1301	* Float arithmetic functions: Float Arithmetic.
1302	* Float assignment functions: Assigning Floats.
1303	* Float comparison functions: Float Comparison.
1304	* Float conversion functions: Converting Floats.
1305	* Float functions: Floating-point Functions.
1306	* Float init and assign functions: Simultaneous Float Init & Assign.
1307	* Float initialization functions: Initializing Floats.
1308	* Float input and output functions: I/O of Floats.
1309	* Float miscellaneous functions: Miscellaneous Float Functions.
1310	* Float sign tests: Float Comparison.
1311	* Floating point mode: Notes for Particular Systems.
1312	* Floating-point functions: Floating-point Functions.
1313	* Floating-point number: Nomenclature and Types.
1314	* Formatted input: Formatted Input.
1315	* Formatted output: Formatted Output.
1316	* FTP of latest version: Introduction to GMP.
1317	* Function classes: Function Classes.
1318	* GMP version number: Useful Macros and Constants.
1319	* gmp.h: Headers and Libraries.
1320	* gmpxx.h: C++ Interface General.
1321	* GNU Free Documentation License: GNU Free Documentation License.
1322	* Greatest common divisor algorithms: Greatest Common Divisor Algorithms.
1323	* Greatest common divisor functions: Number Theoretic Functions.
1324	* Hardware floating point mode: Notes for Particular Systems.
1325	* Headers: Headers and Libraries.
1326	* Home page: Introduction to GMP.
1327	* I/O functions <1>: I/O of Rationals.
1328	* I/O functions <2>: I/O of Floats.
1329	* I/O functions: I/O of Integers.
1330	* Import: Integer Import and Export.
1331	* Initialization and assignment functions <1>: Simultaneous Integer Init & Assign.
1332	* Initialization and assignment functions <2>: Initializing Rationals.
1333	* Initialization and assignment functions: Simultaneous Float Init & Assign.
1334	* Initialization functions <1>: Initializing Floats.
1335	* Initialization functions: Initializing Integers.
1336	* Input functions <1>: I/O of Integers.
1337	* Input functions <2>: I/O of Rationals.
1338	* Input functions: I/O of Floats.
1339	* Install prefix: Build Options.
1340	* Installing GMP: Installing GMP.
1341	* Instruction Set Architecture: ABI and ISA.
1342	* Integer: Nomenclature and Types.
1343	* Integer arithmetic functions: Integer Arithmetic.
1344	* Integer assignment functions: Assigning Integers.
1345	* Integer bit manipulation functions: Integer Logic and Bit Fiddling.
1346	* Integer comparison functions: Integer Comparisons.
1347	* Integer conversion functions: Converting Integers.
1348	* Integer division functions: Integer Division.
1349	* Integer exponentiation functions: Integer Exponentiation.
1350	* Integer export: Integer Import and Export.
1351	* Integer functions: Integer Functions.
1352	* Integer import: Integer Import and Export.
1353	* Integer init and assign: Simultaneous Integer Init & Assign.
1354	* Integer initialization functions: Initializing Integers.
1355	* Integer input and output functions: I/O of Integers.
1356	* Integer miscellaneous functions: Miscellaneous Integer Functions.
1357	* Integer random number functions: Integer Random Numbers.
1358	* Integer root functions: Integer Roots.
1359	* Integer sign tests: Integer Comparisons.
1360	* Introduction: Introduction to GMP.
1361	* ISA: ABI and ISA.
1362	* istream input: C++ Formatted Input.
1363	* Jacobi symbol functions: Number Theoretic Functions.
1364	* Kronecker symbol functions: Number Theoretic Functions.
1365	* Latest version of GMP: Introduction to GMP.
1366	* Least common multiple functions: Number Theoretic Functions.
1367	* Libraries: Headers and Libraries.
1368	* Libtool versioning: Notes for Package Builds.
1369	* License conditions: Copying.
1370	* Limb: Nomenclature and Types.
1371	* Limb size: Useful Macros and Constants.
1372	* Linking: Headers and Libraries.
1373	* Logical functions: Integer Logic and Bit Fiddling.
1374	* Low-level functions: Low-level Functions.
1375	* Lucas number functions: Number Theoretic Functions.
1376	* Mailing lists: Introduction to GMP.
1377	* Memory allocation: Custom Allocation.
1378	* Memory Management: Memory Management.
1379	* Miscellaneous float functions: Miscellaneous Float Functions.
1380	* Miscellaneous integer functions: Miscellaneous Integer Functions.
1381	* Modular inverse functions: Number Theoretic Functions.
1382	* Most significant bit: Miscellaneous Integer Functions.
1383	* mp.h: BSD Compatible Functions.
1384	* MPFR: Build Options.
1385	* mpfrxx.h: C++ Interface MPFR.
1386	* Multi-threading: Reentrancy.
1387	* Multiplication algorithms: Multiplication Algorithms.
1388	* Nails: Low-level Functions.
1389	* Nomenclature: Nomenclature and Types.
1390	* Number theoretic functions: Number Theoretic Functions.
1391	* Numerator and denominator: Applying Integer Functions.
1392	* ostream output: C++ Formatted Output.
1393	* Output functions <1>: I/O of Integers.
1394	* Output functions <2>: I/O of Floats.
1395	* Output functions: I/O of Rationals.
1396	* Packaged builds: Notes for Package Builds.
1397	* PalmOS: Known Build Problems.
1398	* Parameter conventions: Parameter Conventions.
1399	* Particular systems: Notes for Particular Systems.
1400	* perl: Demonstration Programs.
1401	* Powering algorithms: Powering Algorithms.
1402	* Powering functions <1>: Integer Exponentiation.
1403	* Powering functions: Float Arithmetic.
1404	* Precision of floats: Floating-point Functions.
1405	* Precision of hardware floating point: Notes for Particular Systems.
1406	* Prefix: Build Options.
1407	* Prime testing functions: Number Theoretic Functions.
1408	* printf formatted output: Formatted Output.
1409	* Profiling: Profiling.
1410	* Radix conversion algorithms: Radix Conversion Algorithms.
1411	* Random number functions <1>: Integer Random Numbers.
1412	* Random number functions: Random Number Functions.
1413	* Random number seeding: Random State Seeding.
1414	* Random number state: Random State Initialization.
1415	* Rational arithmetic functions: Rational Arithmetic.
1416	* Rational comparison functions: Comparing Rationals.
1417	* Rational conversion functions: Rational Conversions.
1418	* Rational init and assign: Initializing Rationals.
1419	* Rational input and output functions: I/O of Rationals.
1420	* Rational number: Nomenclature and Types.
1421	* Rational number functions: Rational Number Functions.
1422	* Rational numerator and denominator: Applying Integer Functions.
1423	* Rational sign tests: Comparing Rationals.
1424	* Reentrancy: Reentrancy.
1425	* References: References.
1426	* Reporting bugs: Reporting Bugs.
1427	* Root extraction algorithms: Root Extraction Algorithms.
1428	* Root extraction functions <1>: Float Arithmetic.
1429	* Root extraction functions: Integer Roots.
1430	* Sample programs: Demonstration Programs.
1431	* scanf formatted input: Formatted Input.
1432	* Shared library versioning: Notes for Package Builds.
1433	* Sign tests <1>: Comparing Rationals.
1434	* Sign tests <2>: Float Comparison.
1435	* Sign tests: Integer Comparisons.
1436	* Size in digits: Miscellaneous Integer Functions.
1437	* Sparc: Notes for Particular Systems.
1438	* Stack overflow segfaults: Build Options.
1439	* Stripped libraries: Known Build Problems.
1440	* Systems: Notes for Particular Systems.
1441	* Thread safety: Reentrancy.
1442	* Types: Nomenclature and Types.
1443	* Upward compatibility: Compatibility with older versions.
1444	* Useful macros and constants: Useful Macros and Constants.
1445	* User-defined precision: Floating-point Functions.
1446	* Valgrind: Debugging.
1447	* Variable conventions: Variable Conventions.
1448	* Version number: Useful Macros and Constants.
1449	* Web page: Introduction to GMP.
1450	* x87: Notes for Particular Systems.
1451
1452
1453	File: gmp.info, Node: Function Index, Prev: Concept Index, Up: Top
1454
1455	Function and Type Index
1456	***********************
1457
1458	* Menu:
1459
1460	* __GNU_MP_VERSION: Useful Macros and Constants.
1461	* __GNU_MP_VERSION_MINOR: Useful Macros and Constants.
1462	* __GNU_MP_VERSION_PATCHLEVEL: Useful Macros and Constants.
1463	* _mpz_realloc: Initializing Integers.
1464	* abs <1>: C++ Interface Integers.
1465	* abs <2>: C++ Interface Floats.
1466	* abs: C++ Interface Rationals.
1467	* allocate_function: Custom Allocation.
1468	* ceil: C++ Interface Floats.
1469	* cmp <1>: C++ Interface Floats.
1470	* cmp <2>: C++ Interface Integers.
1471	* cmp <3>: C++ Interface Rationals.
1472	* cmp <4>: C++ Interface Floats.
1473	* cmp: C++ Interface Rationals.
1474	* deallocate_function: Custom Allocation.
1475	* floor: C++ Interface Floats.
1476	* gcd: BSD Compatible Functions.
1477	* gmp_asprintf: Formatted Output Functions.
1478	* gmp_errno: Random State Initialization.
1479	* GMP_ERROR_INVALID_ARGUMENT: Random State Initialization.
1480	* GMP_ERROR_UNSUPPORTED_ARGUMENT: Random State Initialization.
1481	* gmp_fprintf: Formatted Output Functions.
1482	* gmp_fscanf: Formatted Input Functions.
1483	* GMP_LIMB_BITS: Low-level Functions.
1484	* GMP_NAIL_BITS: Low-level Functions.
1485	* GMP_NAIL_MASK: Low-level Functions.
1486	* GMP_NUMB_BITS: Low-level Functions.
1487	* GMP_NUMB_MASK: Low-level Functions.
1488	* GMP_NUMB_MAX: Low-level Functions.
1489	* gmp_obstack_printf: Formatted Output Functions.
1490	* gmp_obstack_vprintf: Formatted Output Functions.
1491	* gmp_printf: Formatted Output Functions.
1492	* GMP_RAND_ALG_DEFAULT: Random State Initialization.
1493	* GMP_RAND_ALG_LC: Random State Initialization.
1494	* gmp_randclass: C++ Interface Random Numbers.
1495	* gmp_randclass::get_f: C++ Interface Random Numbers.
1496	* gmp_randclass::get_z_bits: C++ Interface Random Numbers.
1497	* gmp_randclass::get_z_range: C++ Interface Random Numbers.
1498	* gmp_randclass::gmp_randclass: C++ Interface Random Numbers.
1499	* gmp_randclass::seed: C++ Interface Random Numbers.
1500	* gmp_randclear: Random State Initialization.
1501	* gmp_randinit: Random State Initialization.
1502	* gmp_randinit_default: Random State Initialization.
1503	* gmp_randinit_lc_2exp: Random State Initialization.
1504	* gmp_randinit_lc_2exp_size: Random State Initialization.
1505	* gmp_randseed: Random State Seeding.
1506	* gmp_randseed_ui: Random State Seeding.
1507	* gmp_scanf: Formatted Input Functions.
1508	* gmp_snprintf: Formatted Output Functions.
1509	* gmp_sprintf: Formatted Output Functions.
1510	* gmp_sscanf: Formatted Input Functions.
1511	* gmp_vasprintf: Formatted Output Functions.
1512	* gmp_version: Useful Macros and Constants.
1513	* gmp_vfprintf: Formatted Output Functions.
1514	* gmp_vfscanf: Formatted Input Functions.
1515	* gmp_vprintf: Formatted Output Functions.
1516	* gmp_vscanf: Formatted Input Functions.
1517	* gmp_vsnprintf: Formatted Output Functions.
1518	* gmp_vsprintf: Formatted Output Functions.
1519	* gmp_vsscanf: Formatted Input Functions.
1520	* hypot: C++ Interface Floats.
1521	* itom: BSD Compatible Functions.
1522	* madd: BSD Compatible Functions.
1523	* mcmp: BSD Compatible Functions.
1524	* mdiv: BSD Compatible Functions.
1525	* mfree: BSD Compatible Functions.
1526	* min: BSD Compatible Functions.
1527	* mout: BSD Compatible Functions.
1528	* move: BSD Compatible Functions.
1529	* mp_bits_per_limb: Useful Macros and Constants.
1530	* mp_limb_t: Nomenclature and Types.
1531	* mp_set_memory_functions: Custom Allocation.
1532	* mpf_abs: Float Arithmetic.
1533	* mpf_add: Float Arithmetic.
1534	* mpf_add_ui: Float Arithmetic.
1535	* mpf_ceil: Miscellaneous Float Functions.
1536	* mpf_class: C++ Interface General.
1537	* mpf_class::fits_sint_p: C++ Interface Floats.
1538	* mpf_class::fits_slong_p: C++ Interface Floats.
1539	* mpf_class::fits_sshort_p: C++ Interface Floats.
1540	* mpf_class::fits_uint_p: C++ Interface Floats.
1541	* mpf_class::fits_ulong_p: C++ Interface Floats.
1542	* mpf_class::fits_ushort_p: C++ Interface Floats.
1543	* mpf_class::get_d: C++ Interface Floats.
1544	* mpf_class::get_mpf_t: C++ Interface General.
1545	* mpf_class::get_prec: C++ Interface Floats.
1546	* mpf_class::get_si: C++ Interface Floats.
1547	* mpf_class::get_ui: C++ Interface Floats.
1548	* mpf_class::mpf_class: C++ Interface Floats.
1549	* mpf_class::operator=: C++ Interface Floats.
1550	* mpf_class::set_prec: C++ Interface Floats.
1551	* mpf_class::set_prec_raw: C++ Interface Floats.
1552	* mpf_clear: Initializing Floats.
1553	* mpf_cmp: Float Comparison.
1554	* mpf_cmp_d: Float Comparison.
1555	* mpf_cmp_si: Float Comparison.
1556	* mpf_cmp_ui: Float Comparison.
1557	* mpf_div: Float Arithmetic.
1558	* mpf_div_2exp: Float Arithmetic.
1559	* mpf_div_ui: Float Arithmetic.
1560	* mpf_eq: Float Comparison.
1561	* mpf_fits_sint_p: Miscellaneous Float Functions.
1562	* mpf_fits_slong_p: Miscellaneous Float Functions.
1563	* mpf_fits_sshort_p: Miscellaneous Float Functions.
1564	* mpf_fits_uint_p: Miscellaneous Float Functions.
1565	* mpf_fits_ulong_p: Miscellaneous Float Functions.
1566	* mpf_fits_ushort_p: Miscellaneous Float Functions.
1567	* mpf_floor: Miscellaneous Float Functions.
1568	* mpf_get_d: Converting Floats.
1569	* mpf_get_d_2exp: Converting Floats.
1570	* mpf_get_default_prec: Initializing Floats.
1571	* mpf_get_prec: Initializing Floats.
1572	* mpf_get_si: Converting Floats.
1573	* mpf_get_str: Converting Floats.
1574	* mpf_get_ui: Converting Floats.
1575	* mpf_init: Initializing Floats.
1576	* mpf_init2: Initializing Floats.
1577	* mpf_init_set: Simultaneous Float Init & Assign.
1578	* mpf_init_set_d: Simultaneous Float Init & Assign.
1579	* mpf_init_set_si: Simultaneous Float Init & Assign.
1580	* mpf_init_set_str: Simultaneous Float Init & Assign.
1581	* mpf_init_set_ui: Simultaneous Float Init & Assign.
1582	* mpf_inp_str: I/O of Floats.
1583	* mpf_integer_p: Miscellaneous Float Functions.
1584	* mpf_mul: Float Arithmetic.
1585	* mpf_mul_2exp: Float Arithmetic.
1586	* mpf_mul_ui: Float Arithmetic.
1587	* mpf_neg: Float Arithmetic.
1588	* mpf_out_str: I/O of Floats.
1589	* mpf_pow_ui: Float Arithmetic.
1590	* mpf_random2: Miscellaneous Float Functions.
1591	* mpf_reldiff: Float Comparison.
1592	* mpf_set: Assigning Floats.
1593	* mpf_set_d: Assigning Floats.
1594	* mpf_set_default_prec: Initializing Floats.
1595	* mpf_set_prec: Initializing Floats.
1596	* mpf_set_prec_raw: Initializing Floats.
1597	* mpf_set_q: Assigning Floats.
1598	* mpf_set_si: Assigning Floats.
1599	* mpf_set_str: Assigning Floats.
1600	* mpf_set_ui: Assigning Floats.
1601	* mpf_set_z: Assigning Floats.
1602	* mpf_sgn: Float Comparison.
1603	* mpf_sqrt: Float Arithmetic.
1604	* mpf_sqrt_ui: Float Arithmetic.
1605	* mpf_sub: Float Arithmetic.
1606	* mpf_sub_ui: Float Arithmetic.
1607	* mpf_swap: Assigning Floats.
1608	* mpf_t: Nomenclature and Types.
1609	* mpf_trunc: Miscellaneous Float Functions.
1610	* mpf_ui_div: Float Arithmetic.
1611	* mpf_ui_sub: Float Arithmetic.
1612	* mpf_urandomb: Miscellaneous Float Functions.
1613	* mpfr_class: C++ Interface MPFR.
1614	* mpn_add: Low-level Functions.
1615	* mpn_add_1: Low-level Functions.
1616	* mpn_add_n: Low-level Functions.
1617	* mpn_addmul_1: Low-level Functions.
1618	* mpn_bdivmod: Low-level Functions.
1619	* mpn_cmp: Low-level Functions.
1620	* mpn_divexact_by3: Low-level Functions.
1621	* mpn_divexact_by3c: Low-level Functions.
1622	* mpn_divmod: Low-level Functions.
1623	* mpn_divmod_1: Low-level Functions.
1624	* mpn_divrem: Low-level Functions.
1625	* mpn_divrem_1: Low-level Functions.
1626	* mpn_gcd: Low-level Functions.
1627	* mpn_gcd_1: Low-level Functions.
1628	* mpn_gcdext: Low-level Functions.
1629	* mpn_get_str: Low-level Functions.
1630	* mpn_hamdist: Low-level Functions.
1631	* mpn_lshift: Low-level Functions.
1632	* mpn_mod_1: Low-level Functions.
1633	* mpn_mul: Low-level Functions.
1634	* mpn_mul_1: Low-level Functions.
1635	* mpn_mul_n: Low-level Functions.
1636	* mpn_perfect_square_p: Low-level Functions.
1637	* mpn_popcount: Low-level Functions.
1638	* mpn_random: Low-level Functions.
1639	* mpn_random2: Low-level Functions.
1640	* mpn_rshift: Low-level Functions.
1641	* mpn_scan0: Low-level Functions.
1642	* mpn_scan1: Low-level Functions.
1643	* mpn_set_str: Low-level Functions.
1644	* mpn_sqrtrem: Low-level Functions.
1645	* mpn_sub: Low-level Functions.
1646	* mpn_sub_1: Low-level Functions.
1647	* mpn_sub_n: Low-level Functions.
1648	* mpn_submul_1: Low-level Functions.
1649	* mpn_tdiv_qr: Low-level Functions.
1650	* mpq_abs: Rational Arithmetic.
1651	* mpq_add: Rational Arithmetic.
1652	* mpq_canonicalize: Rational Number Functions.
1653	* mpq_class: C++ Interface General.
1654	* mpq_class::canonicalize: C++ Interface Rationals.
1655	* mpq_class::get_d: C++ Interface Rationals.
1656	* mpq_class::get_den: C++ Interface Rationals.
1657	* mpq_class::get_den_mpz_t: C++ Interface Rationals.
1658	* mpq_class::get_mpq_t: C++ Interface General.
1659	* mpq_class::get_num: C++ Interface Rationals.
1660	* mpq_class::get_num_mpz_t: C++ Interface Rationals.
1661	* mpq_class::mpq_class: C++ Interface Rationals.
1662	* mpq_clear: Initializing Rationals.
1663	* mpq_cmp: Comparing Rationals.
1664	* mpq_cmp_si: Comparing Rationals.
1665	* mpq_cmp_ui: Comparing Rationals.
1666	* mpq_denref: Applying Integer Functions.
1667	* mpq_div: Rational Arithmetic.
1668	* mpq_div_2exp: Rational Arithmetic.
1669	* mpq_equal: Comparing Rationals.
1670	* mpq_get_d: Rational Conversions.
1671	* mpq_get_den: Applying Integer Functions.
1672	* mpq_get_num: Applying Integer Functions.
1673	* mpq_get_str: Rational Conversions.
1674	* mpq_init: Initializing Rationals.
1675	* mpq_inp_str: I/O of Rationals.
1676	* mpq_inv: Rational Arithmetic.
1677	* mpq_mul: Rational Arithmetic.
1678	* mpq_mul_2exp: Rational Arithmetic.
1679	* mpq_neg: Rational Arithmetic.
1680	* mpq_numref: Applying Integer Functions.
1681	* mpq_out_str: I/O of Rationals.
1682	* mpq_set: Initializing Rationals.
1683	* mpq_set_d: Rational Conversions.
1684	* mpq_set_den: Applying Integer Functions.
1685	* mpq_set_f: Rational Conversions.
1686	* mpq_set_num: Applying Integer Functions.
1687	* mpq_set_si: Initializing Rationals.
1688	* mpq_set_str: Initializing Rationals.
1689	* mpq_set_ui: Initializing Rationals.
1690	* mpq_set_z: Initializing Rationals.
1691	* mpq_sgn: Comparing Rationals.
1692	* mpq_sub: Rational Arithmetic.
1693	* mpq_swap: Initializing Rationals.
1694	* mpq_t: Nomenclature and Types.
1695	* mpz_abs: Integer Arithmetic.
1696	* mpz_add: Integer Arithmetic.
1697	* mpz_add_ui: Integer Arithmetic.
1698	* mpz_addmul: Integer Arithmetic.
1699	* mpz_addmul_ui: Integer Arithmetic.
1700	* mpz_and: Integer Logic and Bit Fiddling.
1701	* mpz_array_init: Initializing Integers.
1702	* mpz_bin_ui: Number Theoretic Functions.
1703	* mpz_bin_uiui: Number Theoretic Functions.
1704	* mpz_cdiv_q: Integer Division.
1705	* mpz_cdiv_q_2exp: Integer Division.
1706	* mpz_cdiv_q_ui: Integer Division.
1707	* mpz_cdiv_qr: Integer Division.
1708	* mpz_cdiv_qr_ui: Integer Division.
1709	* mpz_cdiv_r: Integer Division.
1710	* mpz_cdiv_r_2exp: Integer Division.
1711	* mpz_cdiv_r_ui: Integer Division.
1712	* mpz_cdiv_ui: Integer Division.
1713	* mpz_class: C++ Interface General.
1714	* mpz_class::fits_sint_p: C++ Interface Integers.
1715	* mpz_class::fits_slong_p: C++ Interface Integers.
1716	* mpz_class::fits_sshort_p: C++ Interface Integers.
1717	* mpz_class::fits_uint_p: C++ Interface Integers.
1718	* mpz_class::fits_ulong_p: C++ Interface Integers.
1719	* mpz_class::fits_ushort_p: C++ Interface Integers.
1720	* mpz_class::get_d: C++ Interface Integers.
1721	* mpz_class::get_mpz_t: C++ Interface General.
1722	* mpz_class::get_si: C++ Interface Integers.
1723	* mpz_class::get_ui: C++ Interface Integers.
1724	* mpz_class::mpz_class: C++ Interface Integers.
1725	* mpz_clear: Initializing Integers.
1726	* mpz_clrbit: Integer Logic and Bit Fiddling.
1727	* mpz_cmp: Integer Comparisons.
1728	* mpz_cmp_d: Integer Comparisons.
1729	* mpz_cmp_si: Integer Comparisons.
1730	* mpz_cmp_ui: Integer Comparisons.
1731	* mpz_cmpabs: Integer Comparisons.
1732	* mpz_cmpabs_d: Integer Comparisons.
1733	* mpz_cmpabs_ui: Integer Comparisons.
1734	* mpz_com: Integer Logic and Bit Fiddling.
1735	* mpz_congruent_2exp_p: Integer Division.
1736	* mpz_congruent_p: Integer Division.
1737	* mpz_congruent_ui_p: Integer Division.
1738	* mpz_divexact: Integer Division.
1739	* mpz_divexact_ui: Integer Division.
1740	* mpz_divisible_2exp_p: Integer Division.
1741	* mpz_divisible_p: Integer Division.
1742	* mpz_divisible_ui_p: Integer Division.
1743	* mpz_even_p: Miscellaneous Integer Functions.
1744	* mpz_export: Integer Import and Export.
1745	* mpz_fac_ui: Number Theoretic Functions.
1746	* mpz_fdiv_q: Integer Division.
1747	* mpz_fdiv_q_2exp: Integer Division.
1748	* mpz_fdiv_q_ui: Integer Division.
1749	* mpz_fdiv_qr: Integer Division.
1750	* mpz_fdiv_qr_ui: Integer Division.
1751	* mpz_fdiv_r: Integer Division.
1752	* mpz_fdiv_r_2exp: Integer Division.
1753	* mpz_fdiv_r_ui: Integer Division.
1754	* mpz_fdiv_ui: Integer Division.
1755	* mpz_fib2_ui: Number Theoretic Functions.
1756	* mpz_fib_ui: Number Theoretic Functions.
1757	* mpz_fits_sint_p: Miscellaneous Integer Functions.
1758	* mpz_fits_slong_p: Miscellaneous Integer Functions.
1759	* mpz_fits_sshort_p: Miscellaneous Integer Functions.
1760	* mpz_fits_uint_p: Miscellaneous Integer Functions.
1761	* mpz_fits_ulong_p: Miscellaneous Integer Functions.
1762	* mpz_fits_ushort_p: Miscellaneous Integer Functions.
1763	* mpz_gcd: Number Theoretic Functions.
1764	* mpz_gcd_ui: Number Theoretic Functions.
1765	* mpz_gcdext: Number Theoretic Functions.
1766	* mpz_get_d: Converting Integers.
1767	* mpz_get_d_2exp: Converting Integers.
1768	* mpz_get_si: Converting Integers.
1769	* mpz_get_str: Converting Integers.
1770	* mpz_get_ui: Converting Integers.
1771	* mpz_getlimbn: Converting Integers.
1772	* mpz_hamdist: Integer Logic and Bit Fiddling.
1773	* mpz_import: Integer Import and Export.
1774	* mpz_init: Initializing Integers.
1775	* mpz_init2: Initializing Integers.
1776	* mpz_init_set: Simultaneous Integer Init & Assign.
1777	* mpz_init_set_d: Simultaneous Integer Init & Assign.
1778	* mpz_init_set_si: Simultaneous Integer Init & Assign.
1779	* mpz_init_set_str: Simultaneous Integer Init & Assign.
1780	* mpz_init_set_ui: Simultaneous Integer Init & Assign.
1781	* mpz_inp_raw: I/O of Integers.
1782	* mpz_inp_str: I/O of Integers.
1783	* mpz_invert: Number Theoretic Functions.
1784	* mpz_ior: Integer Logic and Bit Fiddling.
1785	* mpz_jacobi: Number Theoretic Functions.
1786	* mpz_kronecker: Number Theoretic Functions.
1787	* mpz_kronecker_si: Number Theoretic Functions.
1788	* mpz_kronecker_ui: Number Theoretic Functions.
1789	* mpz_lcm: Number Theoretic Functions.
1790	* mpz_lcm_ui: Number Theoretic Functions.
1791	* mpz_legendre: Number Theoretic Functions.
1792	* mpz_lucnum2_ui: Number Theoretic Functions.
1793	* mpz_lucnum_ui: Number Theoretic Functions.
1794	* mpz_mod: Integer Division.
1795	* mpz_mod_ui: Integer Division.
1796	* mpz_mul: Integer Arithmetic.
1797	* mpz_mul_2exp: Integer Arithmetic.
1798	* mpz_mul_si: Integer Arithmetic.
1799	* mpz_mul_ui: Integer Arithmetic.
1800	* mpz_neg: Integer Arithmetic.
1801	* mpz_nextprime: Number Theoretic Functions.
1802	* mpz_odd_p: Miscellaneous Integer Functions.
1803	* mpz_out_raw: I/O of Integers.
1804	* mpz_out_str: I/O of Integers.
1805	* mpz_perfect_power_p: Integer Roots.
1806	* mpz_perfect_square_p: Integer Roots.
1807	* mpz_popcount: Integer Logic and Bit Fiddling.
1808	* mpz_pow_ui: Integer Exponentiation.
1809	* mpz_powm: Integer Exponentiation.
1810	* mpz_powm_ui: Integer Exponentiation.
1811	* mpz_probab_prime_p: Number Theoretic Functions.
1812	* mpz_random: Integer Random Numbers.
1813	* mpz_random2: Integer Random Numbers.
1814	* mpz_realloc2: Initializing Integers.
1815	* mpz_remove: Number Theoretic Functions.
1816	* mpz_root: Integer Roots.
1817	* mpz_rrandomb: Integer Random Numbers.
1818	* mpz_scan0: Integer Logic and Bit Fiddling.
1819	* mpz_scan1: Integer Logic and Bit Fiddling.
1820	* mpz_set: Assigning Integers.
1821	* mpz_set_d: Assigning Integers.
1822	* mpz_set_f: Assigning Integers.
1823	* mpz_set_q: Assigning Integers.
1824	* mpz_set_si: Assigning Integers.
1825	* mpz_set_str: Assigning Integers.
1826	* mpz_set_ui: Assigning Integers.
1827	* mpz_setbit: Integer Logic and Bit Fiddling.
1828	* mpz_sgn: Integer Comparisons.
1829	* mpz_si_kronecker: Number Theoretic Functions.
1830	* mpz_size: Miscellaneous Integer Functions.
1831	* mpz_sizeinbase: Miscellaneous Integer Functions.
1832	* mpz_sqrt: Integer Roots.
1833	* mpz_sqrtrem: Integer Roots.
1834	* mpz_sub: Integer Arithmetic.
1835	* mpz_sub_ui: Integer Arithmetic.
1836	* mpz_submul: Integer Arithmetic.
1837	* mpz_submul_ui: Integer Arithmetic.
1838	* mpz_swap: Assigning Integers.
1839	* mpz_t: Nomenclature and Types.
1840	* mpz_tdiv_q: Integer Division.
1841	* mpz_tdiv_q_2exp: Integer Division.
1842	* mpz_tdiv_q_ui: Integer Division.
1843	* mpz_tdiv_qr: Integer Division.
1844	* mpz_tdiv_qr_ui: Integer Division.
1845	* mpz_tdiv_r: Integer Division.
1846	* mpz_tdiv_r_2exp: Integer Division.
1847	* mpz_tdiv_r_ui: Integer Division.
1848	* mpz_tdiv_ui: Integer Division.
1849	* mpz_tstbit: Integer Logic and Bit Fiddling.
1850	* mpz_ui_kronecker: Number Theoretic Functions.
1851	* mpz_ui_pow_ui: Integer Exponentiation.
1852	* mpz_ui_sub: Integer Arithmetic.
1853	* mpz_urandomb: Integer Random Numbers.
1854	* mpz_urandomm: Integer Random Numbers.
1855	* mpz_xor: Integer Logic and Bit Fiddling.
1856	* msqrt: BSD Compatible Functions.
1857	* msub: BSD Compatible Functions.
1858	* mtox: BSD Compatible Functions.
1859	* mult: BSD Compatible Functions.
1860	* operator%: C++ Interface Integers.
1861	* operator/: C++ Interface Integers.
1862	* operator<<: C++ Formatted Output.
1863	* operator>> <1>: C++ Formatted Input.
1864	* operator>>: C++ Interface Rationals.
1865	* pow: BSD Compatible Functions.
1866	* reallocate_function: Custom Allocation.
1867	* rpow: BSD Compatible Functions.
1868	* sdiv: BSD Compatible Functions.
1869	* sgn <1>: C++ Interface Rationals.
1870	* sgn <2>: C++ Interface Floats.
1871	* sgn: C++ Interface Integers.
1872	* sqrt <1>: C++ Interface Integers.
1873	* sqrt: C++ Interface Floats.
1874	* trunc: C++ Interface Floats.
1875	* xtom: BSD Compatible Functions.
1876
1877

Note: See TracBrowser for help on using the repository browser.

Download in other formats:

Original Format