1	/* gmpxx.h -- C++ class wrapper for GMP types. -*- C++ -*-
2
3	Copyright 2001-2003, 2006, 2008, 2011, 2012 Free Software Foundation, Inc.
4
5	This file is part of the GNU MP Library.
6
7	The GNU MP Library is free software; you can redistribute it and/or modify
8	it under the terms of either:
9
10	* the GNU Lesser General Public License as published by the Free
11	Software Foundation; either version 3 of the License, or (at your
12	option) any later version.
13
14	or
15
16	* the GNU General Public License as published by the Free Software
17	Foundation; either version 2 of the License, or (at your option) any
18	later version.
19
20	or both in parallel, as here.
21
22	The GNU MP Library is distributed in the hope that it will be useful, but
23	WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
24	or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
25	for more details.
26
27	You should have received copies of the GNU General Public License and the
28	GNU Lesser General Public License along with the GNU MP Library. If not,
29	see https://www.gnu.org/licenses/. */
30
31	#ifndef __GMP_PLUSPLUS__
32	#define __GMP_PLUSPLUS__
33
34	#include <iosfwd>
35
36	#include <cstring> /* for strlen */
37	#include <limits> /* numeric_limits */
38	#include <utility>
39	#include <algorithm> /* swap */
40	#include <string>
41	#include <stdexcept>
42	#include <cfloat>
43	#include <gmp.h>
44
45	// wrapper for gcc's __builtin_constant_p
46	// __builtin_constant_p has been in gcc since forever,
47	// but g++-3.4 miscompiles it.
48	#if __GMP_GNUC_PREREQ(4, 2)
49	#define __GMPXX_CONSTANT(X) __builtin_constant_p(X)
50	#else
51	#define __GMPXX_CONSTANT(X) false
52	#endif
53	#define __GMPXX_CONSTANT_TRUE(X) (__GMPXX_CONSTANT(X) && (X))
54
55	// Use C++11 features
56	#ifndef __GMPXX_USE_CXX11
57	#if __cplusplus >= 201103L
58	#define __GMPXX_USE_CXX11 1
59	#else
60	#define __GMPXX_USE_CXX11 0
61	#endif
62	#endif
63
64	#if __GMPXX_USE_CXX11
65	#define __GMPXX_NOEXCEPT noexcept
66	#include <type_traits> // for common_type
67	#else
68	#define __GMPXX_NOEXCEPT
69	#endif
70
71	// Max allocations for plain types when converted to GMP types
72	#if GMP_NAIL_BITS != 0 && ! defined _LONG_LONG_LIMB
73	#define __GMPZ_ULI_LIMBS 2
74	#else
75	#define __GMPZ_ULI_LIMBS 1
76	#endif
77
78	#define __GMPXX_BITS_TO_LIMBS(n) (((n) + (GMP_NUMB_BITS - 1)) / GMP_NUMB_BITS)
79	#define __GMPZ_DBL_LIMBS __GMPXX_BITS_TO_LIMBS(DBL_MAX_EXP)+1
80	#define __GMPQ_NUM_DBL_LIMBS __GMPZ_DBL_LIMBS
81	#define __GMPQ_DEN_DBL_LIMBS __GMPXX_BITS_TO_LIMBS(DBL_MANT_DIG+1-DBL_MIN_EXP)+1
82	// The final +1s are a security margin. The current implementation of
83	// mpq_set_d seems to need it for the denominator.
84
85	inline void __mpz_set_ui_safe(mpz_ptr p, unsigned long l)
86	{
87	p->_mp_size = (l != 0);
88	p->_mp_d[0] = l & GMP_NUMB_MASK;
89	#if __GMPZ_ULI_LIMBS > 1
90	l >>= GMP_NUMB_BITS;
91	p->_mp_d[1] = l;
92	p->_mp_size += (l != 0);
93	#endif
94	}
95
96	inline void __mpz_set_si_safe(mpz_ptr p, long l)
97	{
98	if(l < 0)
99	{
100	__mpz_set_ui_safe(p, -static_cast<unsigned long>(l));
101	mpz_neg(p, p);
102	}
103	else
104	__mpz_set_ui_safe(p, l);
105	// Note: we know the high bit of l is 0 so we could do slightly better
106	}
107
108	// Fake temporary variables
109	#define __GMPXX_TMPZ_UI \
110	mpz_t temp; \
111	mp_limb_t limbs[__GMPZ_ULI_LIMBS]; \
112	temp->_mp_d = limbs; \
113	__mpz_set_ui_safe (temp, l)
114	#define __GMPXX_TMPZ_SI \
115	mpz_t temp; \
116	mp_limb_t limbs[__GMPZ_ULI_LIMBS]; \
117	temp->_mp_d = limbs; \
118	__mpz_set_si_safe (temp, l)
119	#define __GMPXX_TMPZ_D \
120	mpz_t temp; \
121	mp_limb_t limbs[__GMPZ_DBL_LIMBS]; \
122	temp->_mp_d = limbs; \
123	temp->_mp_alloc = __GMPZ_DBL_LIMBS; \
124	mpz_set_d (temp, d)
125
126	#define __GMPXX_TMPQ_UI \
127	mpq_t temp; \
128	mp_limb_t limbs[__GMPZ_ULI_LIMBS+1]; \
129	mpq_numref(temp)->_mp_d = limbs; \
130	__mpz_set_ui_safe (mpq_numref(temp), l); \
131	mpq_denref(temp)->_mp_d = limbs + __GMPZ_ULI_LIMBS; \
132	mpq_denref(temp)->_mp_size = 1; \
133	mpq_denref(temp)->_mp_d[0] = 1
134	#define __GMPXX_TMPQ_SI \
135	mpq_t temp; \
136	mp_limb_t limbs[__GMPZ_ULI_LIMBS+1]; \
137	mpq_numref(temp)->_mp_d = limbs; \
138	__mpz_set_si_safe (mpq_numref(temp), l); \
139	mpq_denref(temp)->_mp_d = limbs + __GMPZ_ULI_LIMBS; \
140	mpq_denref(temp)->_mp_size = 1; \
141	mpq_denref(temp)->_mp_d[0] = 1
142	#define __GMPXX_TMPQ_D \
143	mpq_t temp; \
144	mp_limb_t limbs[__GMPQ_NUM_DBL_LIMBS + __GMPQ_DEN_DBL_LIMBS]; \
145	mpq_numref(temp)->_mp_d = limbs; \
146	mpq_numref(temp)->_mp_alloc = __GMPQ_NUM_DBL_LIMBS; \
147	mpq_denref(temp)->_mp_d = limbs + __GMPQ_NUM_DBL_LIMBS; \
148	mpq_denref(temp)->_mp_alloc = __GMPQ_DEN_DBL_LIMBS; \
149	mpq_set_d (temp, d)
150
151	inline unsigned long __gmpxx_abs_ui (signed long l)
152	{
153	return l >= 0 ? static_cast<unsigned long>(l)
154	: -static_cast<unsigned long>(l);
155	}
156
157	/**************** Function objects ****************/
158	/* Any evaluation of a __gmp_expr ends up calling one of these functions
159	all intermediate functions being inline, the evaluation should optimize
160	to a direct call to the relevant function, thus yielding no overhead
161	over the C interface. */
162
163	struct __gmp_unary_plus
164	{
165	static void eval(mpz_ptr z, mpz_srcptr w) { mpz_set(z, w); }
166	static void eval(mpq_ptr q, mpq_srcptr r) { mpq_set(q, r); }
167	static void eval(mpf_ptr f, mpf_srcptr g) { mpf_set(f, g); }
168	};
169
170	struct __gmp_unary_minus
171	{
172	static void eval(mpz_ptr z, mpz_srcptr w) { mpz_neg(z, w); }
173	static void eval(mpq_ptr q, mpq_srcptr r) { mpq_neg(q, r); }
174	static void eval(mpf_ptr f, mpf_srcptr g) { mpf_neg(f, g); }
175	};
176
177	struct __gmp_unary_com
178	{
179	static void eval(mpz_ptr z, mpz_srcptr w) { mpz_com(z, w); }
180	};
181
182	struct __gmp_binary_plus
183	{
184	static void eval(mpz_ptr z, mpz_srcptr w, mpz_srcptr v)
185	{ mpz_add(z, w, v); }
186
187	static void eval(mpz_ptr z, mpz_srcptr w, unsigned long int l)
188	{
189	// Ideally, those checks should happen earlier so that the tree
190	// generated for a+0+b would just be sum(a,b).
191	if (__GMPXX_CONSTANT(l) && l == 0)
192	{
193	if (z != w) mpz_set(z, w);
194	}
195	else
196	mpz_add_ui(z, w, l);
197	}
198	static void eval(mpz_ptr z, unsigned long int l, mpz_srcptr w)
199	{ eval(z, w, l); }
200	static void eval(mpz_ptr z, mpz_srcptr w, signed long int l)
201	{
202	if (l >= 0)
203	eval(z, w, static_cast<unsigned long>(l));
204	else
205	mpz_sub_ui(z, w, -static_cast<unsigned long>(l));
206	}
207	static void eval(mpz_ptr z, signed long int l, mpz_srcptr w)
208	{ eval(z, w, l); }
209	static void eval(mpz_ptr z, mpz_srcptr w, double d)
210	{ __GMPXX_TMPZ_D; mpz_add (z, w, temp); }
211	static void eval(mpz_ptr z, double d, mpz_srcptr w)
212	{ eval(z, w, d); }
213
214	static void eval(mpq_ptr q, mpq_srcptr r, mpq_srcptr s)
215	{ mpq_add(q, r, s); }
216
217	static void eval(mpq_ptr q, mpq_srcptr r, unsigned long int l)
218	{
219	if (__GMPXX_CONSTANT(l) && l == 0)
220	{
221	if (q != r) mpq_set(q, r);
222	}
223	else
224	{
225	if (q == r)
226	mpz_addmul_ui(mpq_numref(q), mpq_denref(q), l);
227	else
228	{
229	mpz_mul_ui(mpq_numref(q), mpq_denref(r), l);
230	mpz_add(mpq_numref(q), mpq_numref(q), mpq_numref(r));
231	mpz_set(mpq_denref(q), mpq_denref(r));
232	}
233	}
234	}
235	static void eval(mpq_ptr q, unsigned long int l, mpq_srcptr r)
236	{ eval(q, r, l); }
237	static inline void eval(mpq_ptr q, mpq_srcptr r, signed long int l);
238	// defined after __gmp_binary_minus
239	static void eval(mpq_ptr q, signed long int l, mpq_srcptr r)
240	{ eval(q, r, l); }
241	static void eval(mpq_ptr q, mpq_srcptr r, double d)
242	{ __GMPXX_TMPQ_D; mpq_add (q, r, temp); }
243	static void eval(mpq_ptr q, double d, mpq_srcptr r)
244	{ eval(q, r, d); }
245
246	static void eval(mpq_ptr q, mpq_srcptr r, mpz_srcptr z)
247	{
248	if (q == r)
249	mpz_addmul(mpq_numref(q), mpq_denref(q), z);
250	else
251	{
252	mpz_mul(mpq_numref(q), mpq_denref(r), z);
253	mpz_add(mpq_numref(q), mpq_numref(q), mpq_numref(r));
254	mpz_set(mpq_denref(q), mpq_denref(r));
255	}
256	}
257	static void eval(mpq_ptr q, mpz_srcptr z, mpq_srcptr r)
258	{ eval(q, r, z); }
259
260	static void eval(mpf_ptr f, mpf_srcptr g, mpf_srcptr h)
261	{ mpf_add(f, g, h); }
262
263	static void eval(mpf_ptr f, mpf_srcptr g, unsigned long int l)
264	{ mpf_add_ui(f, g, l); }
265	static void eval(mpf_ptr f, unsigned long int l, mpf_srcptr g)
266	{ mpf_add_ui(f, g, l); }
267	static void eval(mpf_ptr f, mpf_srcptr g, signed long int l)
268	{
269	if (l >= 0)
270	mpf_add_ui(f, g, l);
271	else
272	mpf_sub_ui(f, g, -static_cast<unsigned long>(l));
273	}
274	static void eval(mpf_ptr f, signed long int l, mpf_srcptr g)
275	{ eval(f, g, l); }
276	static void eval(mpf_ptr f, mpf_srcptr g, double d)
277	{
278	mpf_t temp;
279	mpf_init2(temp, 8*sizeof(double));
280	mpf_set_d(temp, d);
281	mpf_add(f, g, temp);
282	mpf_clear(temp);
283	}
284	static void eval(mpf_ptr f, double d, mpf_srcptr g)
285	{ eval(f, g, d); }
286	};
287
288	struct __gmp_binary_minus
289	{
290	static void eval(mpz_ptr z, mpz_srcptr w, mpz_srcptr v)
291	{ mpz_sub(z, w, v); }
292
293	static void eval(mpz_ptr z, mpz_srcptr w, unsigned long int l)
294	{
295	if (__GMPXX_CONSTANT(l) && l == 0)
296	{
297	if (z != w) mpz_set(z, w);
298	}
299	else
300	mpz_sub_ui(z, w, l);
301	}
302	static void eval(mpz_ptr z, unsigned long int l, mpz_srcptr w)
303	{
304	if (__GMPXX_CONSTANT(l) && l == 0)
305	{
306	mpz_neg(z, w);
307	}
308	else
309	mpz_ui_sub(z, l, w);
310	}
311	static void eval(mpz_ptr z, mpz_srcptr w, signed long int l)
312	{
313	if (l >= 0)
314	eval(z, w, static_cast<unsigned long>(l));
315	else
316	mpz_add_ui(z, w, -static_cast<unsigned long>(l));
317	}
318	static void eval(mpz_ptr z, signed long int l, mpz_srcptr w)
319	{
320	if (l >= 0)
321	eval(z, static_cast<unsigned long>(l), w);
322	else
323	{
324	mpz_add_ui(z, w, -static_cast<unsigned long>(l));
325	mpz_neg(z, z);
326	}
327	}
328	static void eval(mpz_ptr z, mpz_srcptr w, double d)
329	{ __GMPXX_TMPZ_D; mpz_sub (z, w, temp); }
330	static void eval(mpz_ptr z, double d, mpz_srcptr w)
331	{ __GMPXX_TMPZ_D; mpz_sub (z, temp, w); }
332
333	static void eval(mpq_ptr q, mpq_srcptr r, mpq_srcptr s)
334	{ mpq_sub(q, r, s); }
335
336	static void eval(mpq_ptr q, mpq_srcptr r, unsigned long int l)
337	{
338	if (__GMPXX_CONSTANT(l) && l == 0)
339	{
340	if (q != r) mpq_set(q, r);
341	}
342	else
343	{
344	if (q == r)
345	mpz_submul_ui(mpq_numref(q), mpq_denref(q), l);
346	else
347	{
348	mpz_mul_ui(mpq_numref(q), mpq_denref(r), l);
349	mpz_sub(mpq_numref(q), mpq_numref(r), mpq_numref(q));
350	mpz_set(mpq_denref(q), mpq_denref(r));
351	}
352	}
353	}
354	static void eval(mpq_ptr q, unsigned long int l, mpq_srcptr r)
355	{ eval(q, r, l); mpq_neg(q, q); }
356	static void eval(mpq_ptr q, mpq_srcptr r, signed long int l)
357	{
358	if (l >= 0)
359	eval(q, r, static_cast<unsigned long>(l));
360	else
361	__gmp_binary_plus::eval(q, r, -static_cast<unsigned long>(l));
362	}
363	static void eval(mpq_ptr q, signed long int l, mpq_srcptr r)
364	{ eval(q, r, l); mpq_neg(q, q); }
365	static void eval(mpq_ptr q, mpq_srcptr r, double d)
366	{ __GMPXX_TMPQ_D; mpq_sub (q, r, temp); }
367	static void eval(mpq_ptr q, double d, mpq_srcptr r)
368	{ __GMPXX_TMPQ_D; mpq_sub (q, temp, r); }
369
370	static void eval(mpq_ptr q, mpq_srcptr r, mpz_srcptr z)
371	{
372	if (q == r)
373	mpz_submul(mpq_numref(q), mpq_denref(q), z);
374	else
375	{
376	mpz_mul(mpq_numref(q), mpq_denref(r), z);
377	mpz_sub(mpq_numref(q), mpq_numref(r), mpq_numref(q));
378	mpz_set(mpq_denref(q), mpq_denref(r));
379	}
380	}
381	static void eval(mpq_ptr q, mpz_srcptr z, mpq_srcptr r)
382	{ eval(q, r, z); mpq_neg(q, q); }
383
384	static void eval(mpf_ptr f, mpf_srcptr g, mpf_srcptr h)
385	{ mpf_sub(f, g, h); }
386
387	static void eval(mpf_ptr f, mpf_srcptr g, unsigned long int l)
388	{ mpf_sub_ui(f, g, l); }
389	static void eval(mpf_ptr f, unsigned long int l, mpf_srcptr g)
390	{ mpf_ui_sub(f, l, g); }
391	static void eval(mpf_ptr f, mpf_srcptr g, signed long int l)
392	{
393	if (l >= 0)
394	mpf_sub_ui(f, g, l);
395	else
396	mpf_add_ui(f, g, -static_cast<unsigned long>(l));
397	}
398	static void eval(mpf_ptr f, signed long int l, mpf_srcptr g)
399	{
400	if (l >= 0)
401	mpf_sub_ui(f, g, l);
402	else
403	mpf_add_ui(f, g, -static_cast<unsigned long>(l));
404	mpf_neg(f, f);
405	}
406	static void eval(mpf_ptr f, mpf_srcptr g, double d)
407	{
408	mpf_t temp;
409	mpf_init2(temp, 8*sizeof(double));
410	mpf_set_d(temp, d);
411	mpf_sub(f, g, temp);
412	mpf_clear(temp);
413	}
414	static void eval(mpf_ptr f, double d, mpf_srcptr g)
415	{
416	mpf_t temp;
417	mpf_init2(temp, 8*sizeof(double));
418	mpf_set_d(temp, d);
419	mpf_sub(f, temp, g);
420	mpf_clear(temp);
421	}
422	};
423
424	// defined here so it can reference __gmp_binary_minus
425	inline void
426	__gmp_binary_plus::eval(mpq_ptr q, mpq_srcptr r, signed long int l)
427	{
428	if (l >= 0)
429	eval(q, r, static_cast<unsigned long>(l));
430	else
431	__gmp_binary_minus::eval(q, r, -static_cast<unsigned long>(l));
432	}
433
434	struct __gmp_binary_lshift
435	{
436	static void eval(mpz_ptr z, mpz_srcptr w, mp_bitcnt_t l)
437	{
438	if (__GMPXX_CONSTANT(l) && (l == 0))
439	{
440	if (z != w) mpz_set(z, w);
441	}
442	else
443	mpz_mul_2exp(z, w, l);
444	}
445	static void eval(mpq_ptr q, mpq_srcptr r, mp_bitcnt_t l)
446	{
447	if (__GMPXX_CONSTANT(l) && (l == 0))
448	{
449	if (q != r) mpq_set(q, r);
450	}
451	else
452	mpq_mul_2exp(q, r, l);
453	}
454	static void eval(mpf_ptr f, mpf_srcptr g, mp_bitcnt_t l)
455	{ mpf_mul_2exp(f, g, l); }
456	};
457
458	struct __gmp_binary_rshift
459	{
460	static void eval(mpz_ptr z, mpz_srcptr w, mp_bitcnt_t l)
461	{
462	if (__GMPXX_CONSTANT(l) && (l == 0))
463	{
464	if (z != w) mpz_set(z, w);
465	}
466	else
467	mpz_fdiv_q_2exp(z, w, l);
468	}
469	static void eval(mpq_ptr q, mpq_srcptr r, mp_bitcnt_t l)
470	{
471	if (__GMPXX_CONSTANT(l) && (l == 0))
472	{
473	if (q != r) mpq_set(q, r);
474	}
475	else
476	mpq_div_2exp(q, r, l);
477	}
478	static void eval(mpf_ptr f, mpf_srcptr g, mp_bitcnt_t l)
479	{ mpf_div_2exp(f, g, l); }
480	};
481
482	struct __gmp_binary_multiplies
483	{
484	static void eval(mpz_ptr z, mpz_srcptr w, mpz_srcptr v)
485	{ mpz_mul(z, w, v); }
486
487	static void eval(mpz_ptr z, mpz_srcptr w, unsigned long int l)
488	{
489	// gcc-3.3 doesn't have __builtin_ctzl. Don't bother optimizing for old gcc.
490	#if __GMP_GNUC_PREREQ(3, 4)
491	if (__GMPXX_CONSTANT(l) && (l & (l-1)) == 0)
492	{
493	if (l == 0)
494	{
495	z->_mp_size = 0;
496	}
497	else
498	{
499	__gmp_binary_lshift::eval(z, w, __builtin_ctzl(l));
500	}
501	}
502	else
503	#endif
504	mpz_mul_ui(z, w, l);
505	}
506	static void eval(mpz_ptr z, unsigned long int l, mpz_srcptr w)
507	{ eval(z, w, l); }
508	static void eval(mpz_ptr z, mpz_srcptr w, signed long int l)
509	{
510	if (__GMPXX_CONSTANT_TRUE(l >= 0))
511	eval(z, w, static_cast<unsigned long>(l));
512	else if (__GMPXX_CONSTANT_TRUE(l <= 0))
513	{
514	eval(z, w, -static_cast<unsigned long>(l));
515	mpz_neg(z, z);
516	}
517	else
518	mpz_mul_si (z, w, l);
519	}
520	static void eval(mpz_ptr z, signed long int l, mpz_srcptr w)
521	{ eval(z, w, l); }
522	static void eval(mpz_ptr z, mpz_srcptr w, double d)
523	{ __GMPXX_TMPZ_D; mpz_mul (z, w, temp); }
524	static void eval(mpz_ptr z, double d, mpz_srcptr w)
525	{ eval(z, w, d); }
526
527	static void eval(mpq_ptr q, mpq_srcptr r, mpq_srcptr s)
528	{ mpq_mul(q, r, s); }
529
530	static void eval(mpq_ptr q, mpq_srcptr r, unsigned long int l)
531	{
532	#if __GMP_GNUC_PREREQ(3, 4)
533	if (__GMPXX_CONSTANT(l) && (l & (l-1)) == 0)
534	{
535	if (l == 0)
536	{
537	mpq_set_ui(q, 0, 1);
538	}
539	else
540	{
541	__gmp_binary_lshift::eval(q, r, __builtin_ctzl(l));
542	}
543	}
544	else
545	#endif
546	{
547	__GMPXX_TMPQ_UI;
548	mpq_mul (q, r, temp);
549	}
550	}
551	static void eval(mpq_ptr q, unsigned long int l, mpq_srcptr r)
552	{ eval(q, r, l); }
553	static void eval(mpq_ptr q, mpq_srcptr r, signed long int l)
554	{
555	if (__GMPXX_CONSTANT_TRUE(l >= 0))
556	eval(q, r, static_cast<unsigned long>(l));
557	else if (__GMPXX_CONSTANT_TRUE(l <= 0))
558	{
559	eval(q, r, -static_cast<unsigned long>(l));
560	mpq_neg(q, q);
561	}
562	else
563	{
564	__GMPXX_TMPQ_SI;
565	mpq_mul (q, r, temp);
566	}
567	}
568	static void eval(mpq_ptr q, signed long int l, mpq_srcptr r)
569	{ eval(q, r, l); }
570	static void eval(mpq_ptr q, mpq_srcptr r, double d)
571	{ __GMPXX_TMPQ_D; mpq_mul (q, r, temp); }
572	static void eval(mpq_ptr q, double d, mpq_srcptr r)
573	{ eval(q, r, d); }
574
575	static void eval(mpf_ptr f, mpf_srcptr g, mpf_srcptr h)
576	{ mpf_mul(f, g, h); }
577
578	static void eval(mpf_ptr f, mpf_srcptr g, unsigned long int l)
579	{ mpf_mul_ui(f, g, l); }
580	static void eval(mpf_ptr f, unsigned long int l, mpf_srcptr g)
581	{ mpf_mul_ui(f, g, l); }
582	static void eval(mpf_ptr f, mpf_srcptr g, signed long int l)
583	{
584	if (l >= 0)
585	mpf_mul_ui(f, g, l);
586	else
587	{
588	mpf_mul_ui(f, g, -static_cast<unsigned long>(l));
589	mpf_neg(f, f);
590	}
591	}
592	static void eval(mpf_ptr f, signed long int l, mpf_srcptr g)
593	{ eval(f, g, l); }
594	static void eval(mpf_ptr f, mpf_srcptr g, double d)
595	{
596	mpf_t temp;
597	mpf_init2(temp, 8*sizeof(double));
598	mpf_set_d(temp, d);
599	mpf_mul(f, g, temp);
600	mpf_clear(temp);
601	}
602	static void eval(mpf_ptr f, double d, mpf_srcptr g)
603	{ eval(f, g, d); }
604	};
605
606	struct __gmp_binary_divides
607	{
608	static void eval(mpz_ptr z, mpz_srcptr w, mpz_srcptr v)
609	{ mpz_tdiv_q(z, w, v); }
610
611	static void eval(mpz_ptr z, mpz_srcptr w, unsigned long int l)
612	{
613	#if __GMP_GNUC_PREREQ(3, 4)
614	// Don't optimize division by 0...
615	if (__GMPXX_CONSTANT(l) && (l & (l-1)) == 0 && l != 0)
616	{
617	if (l == 1)
618	{
619	if (z != w) mpz_set(z, w);
620	}
621	else
622	mpz_tdiv_q_2exp(z, w, __builtin_ctzl(l));
623	// warning: do not use rshift (fdiv)
624	}
625	else
626	#endif
627	mpz_tdiv_q_ui(z, w, l);
628	}
629	static void eval(mpz_ptr z, unsigned long int l, mpz_srcptr w)
630	{
631	if (mpz_sgn(w) >= 0)
632	{
633	if (mpz_fits_ulong_p(w))
634	mpz_set_ui(z, l / mpz_get_ui(w));
635	else
636	mpz_set_ui(z, 0);
637	}
638	else
639	{
640	mpz_neg(z, w);
641	if (mpz_fits_ulong_p(z))
642	{
643	mpz_set_ui(z, l / mpz_get_ui(z));
644	mpz_neg(z, z);
645	}
646	else
647	mpz_set_ui(z, 0);
648	}
649	}
650	static void eval(mpz_ptr z, mpz_srcptr w, signed long int l)
651	{
652	if (l >= 0)
653	eval(z, w, static_cast<unsigned long>(l));
654	else
655	{
656	eval(z, w, -static_cast<unsigned long>(l));
657	mpz_neg(z, z);
658	}
659	}
660	static void eval(mpz_ptr z, signed long int l, mpz_srcptr w)
661	{
662	if (mpz_fits_slong_p(w))
663	mpz_set_si(z, l / mpz_get_si(w));
664	else
665	{
666	/* if w is bigger than a long then the quotient must be zero, unless
667	l==LONG_MIN and w==-LONG_MIN in which case the quotient is -1 */
668	mpz_set_si (z, (mpz_cmpabs_ui (w, __gmpxx_abs_ui(l)) == 0 ? -1 : 0));
669	}
670	}
671	static void eval(mpz_ptr z, mpz_srcptr w, double d)
672	{ __GMPXX_TMPZ_D; mpz_tdiv_q (z, w, temp); }
673	static void eval(mpz_ptr z, double d, mpz_srcptr w)
674	{ __GMPXX_TMPZ_D; mpz_tdiv_q (z, temp, w); }
675
676	static void eval(mpq_ptr q, mpq_srcptr r, mpq_srcptr s)
677	{ mpq_div(q, r, s); }
678
679	static void eval(mpq_ptr q, mpq_srcptr r, unsigned long int l)
680	{
681	#if __GMP_GNUC_PREREQ(3, 4)
682	if (__GMPXX_CONSTANT(l) && (l & (l-1)) == 0 && l != 0)
683	__gmp_binary_rshift::eval(q, r, __builtin_ctzl(l));
684	else
685	#endif
686	{
687	__GMPXX_TMPQ_UI;
688	mpq_div (q, r, temp);
689	}
690	}
691	static void eval(mpq_ptr q, unsigned long int l, mpq_srcptr r)
692	{ __GMPXX_TMPQ_UI; mpq_div (q, temp, r); }
693	static void eval(mpq_ptr q, mpq_srcptr r, signed long int l)
694	{
695	if (__GMPXX_CONSTANT_TRUE(l >= 0))
696	eval(q, r, static_cast<unsigned long>(l));
697	else if (__GMPXX_CONSTANT_TRUE(l <= 0))
698	{
699	eval(q, r, -static_cast<unsigned long>(l));
700	mpq_neg(q, q);
701	}
702	else
703	{
704	__GMPXX_TMPQ_SI;
705	mpq_div (q, r, temp);
706	}
707	}
708	static void eval(mpq_ptr q, signed long int l, mpq_srcptr r)
709	{ __GMPXX_TMPQ_SI; mpq_div (q, temp, r); }
710	static void eval(mpq_ptr q, mpq_srcptr r, double d)
711	{ __GMPXX_TMPQ_D; mpq_div (q, r, temp); }
712	static void eval(mpq_ptr q, double d, mpq_srcptr r)
713	{ __GMPXX_TMPQ_D; mpq_div (q, temp, r); }
714
715	static void eval(mpf_ptr f, mpf_srcptr g, mpf_srcptr h)
716	{ mpf_div(f, g, h); }
717
718	static void eval(mpf_ptr f, mpf_srcptr g, unsigned long int l)
719	{ mpf_div_ui(f, g, l); }
720	static void eval(mpf_ptr f, unsigned long int l, mpf_srcptr g)
721	{ mpf_ui_div(f, l, g); }
722	static void eval(mpf_ptr f, mpf_srcptr g, signed long int l)
723	{
724	if (l >= 0)
725	mpf_div_ui(f, g, l);
726	else
727	{
728	mpf_div_ui(f, g, -static_cast<unsigned long>(l));
729	mpf_neg(f, f);
730	}
731	}
732	static void eval(mpf_ptr f, signed long int l, mpf_srcptr g)
733	{
734	if (l >= 0)
735	mpf_ui_div(f, l, g);
736	else
737	{
738	mpf_ui_div(f, -static_cast<unsigned long>(l), g);
739	mpf_neg(f, f);
740	}
741	}
742	static void eval(mpf_ptr f, mpf_srcptr g, double d)
743	{
744	mpf_t temp;
745	mpf_init2(temp, 8*sizeof(double));
746	mpf_set_d(temp, d);
747	mpf_div(f, g, temp);
748	mpf_clear(temp);
749	}
750	static void eval(mpf_ptr f, double d, mpf_srcptr g)
751	{
752	mpf_t temp;
753	mpf_init2(temp, 8*sizeof(double));
754	mpf_set_d(temp, d);
755	mpf_div(f, temp, g);
756	mpf_clear(temp);
757	}
758	};
759
760	struct __gmp_binary_modulus
761	{
762	static void eval(mpz_ptr z, mpz_srcptr w, mpz_srcptr v)
763	{ mpz_tdiv_r(z, w, v); }
764
765	static void eval(mpz_ptr z, mpz_srcptr w, unsigned long int l)
766	{ mpz_tdiv_r_ui(z, w, l); }
767	static void eval(mpz_ptr z, unsigned long int l, mpz_srcptr w)
768	{
769	if (mpz_sgn(w) >= 0)
770	{
771	if (mpz_fits_ulong_p(w))
772	mpz_set_ui(z, l % mpz_get_ui(w));
773	else
774	mpz_set_ui(z, l);
775	}
776	else
777	{
778	mpz_neg(z, w);
779	if (mpz_fits_ulong_p(z))
780	mpz_set_ui(z, l % mpz_get_ui(z));
781	else
782	mpz_set_ui(z, l);
783	}
784	}
785	static void eval(mpz_ptr z, mpz_srcptr w, signed long int l)
786	{
787	mpz_tdiv_r_ui (z, w, __gmpxx_abs_ui(l));
788	}
789	static void eval(mpz_ptr z, signed long int l, mpz_srcptr w)
790	{
791	if (mpz_fits_slong_p(w))
792	mpz_set_si(z, l % mpz_get_si(w));
793	else
794	{
795	/* if w is bigger than a long then the remainder is l unchanged,
796	unless l==LONG_MIN and w==-LONG_MIN in which case it's 0 */
797	mpz_set_si (z, mpz_cmpabs_ui (w, __gmpxx_abs_ui(l)) == 0 ? 0 : l);
798	}
799	}
800	static void eval(mpz_ptr z, mpz_srcptr w, double d)
801	{ __GMPXX_TMPZ_D; mpz_tdiv_r (z, w, temp); }
802	static void eval(mpz_ptr z, double d, mpz_srcptr w)
803	{ __GMPXX_TMPZ_D; mpz_tdiv_r (z, temp, w); }
804	};
805
806	struct __gmp_binary_and
807	{
808	static void eval(mpz_ptr z, mpz_srcptr w, mpz_srcptr v)
809	{ mpz_and(z, w, v); }
810
811	static void eval(mpz_ptr z, mpz_srcptr w, unsigned long int l)
812	{ __GMPXX_TMPZ_UI; mpz_and (z, w, temp); }
813	static void eval(mpz_ptr z, unsigned long int l, mpz_srcptr w)
814	{ eval(z, w, l); }
815	static void eval(mpz_ptr z, mpz_srcptr w, signed long int l)
816	{ __GMPXX_TMPZ_SI; mpz_and (z, w, temp); }
817	static void eval(mpz_ptr z, signed long int l, mpz_srcptr w)
818	{ eval(z, w, l); }
819	static void eval(mpz_ptr z, mpz_srcptr w, double d)
820	{ __GMPXX_TMPZ_D; mpz_and (z, w, temp); }
821	static void eval(mpz_ptr z, double d, mpz_srcptr w)
822	{ eval(z, w, d); }
823	};
824
825	struct __gmp_binary_ior
826	{
827	static void eval(mpz_ptr z, mpz_srcptr w, mpz_srcptr v)
828	{ mpz_ior(z, w, v); }
829	static void eval(mpz_ptr z, mpz_srcptr w, unsigned long int l)
830	{ __GMPXX_TMPZ_UI; mpz_ior (z, w, temp); }
831	static void eval(mpz_ptr z, unsigned long int l, mpz_srcptr w)
832	{ eval(z, w, l); }
833	static void eval(mpz_ptr z, mpz_srcptr w, signed long int l)
834	{ __GMPXX_TMPZ_SI; mpz_ior (z, w, temp); }
835	static void eval(mpz_ptr z, signed long int l, mpz_srcptr w)
836	{ eval(z, w, l); }
837	static void eval(mpz_ptr z, mpz_srcptr w, double d)
838	{ __GMPXX_TMPZ_D; mpz_ior (z, w, temp); }
839	static void eval(mpz_ptr z, double d, mpz_srcptr w)
840	{ eval(z, w, d); }
841	};
842
843	struct __gmp_binary_xor
844	{
845	static void eval(mpz_ptr z, mpz_srcptr w, mpz_srcptr v)
846	{ mpz_xor(z, w, v); }
847	static void eval(mpz_ptr z, mpz_srcptr w, unsigned long int l)
848	{ __GMPXX_TMPZ_UI; mpz_xor (z, w, temp); }
849	static void eval(mpz_ptr z, unsigned long int l, mpz_srcptr w)
850	{ eval(z, w, l); }
851	static void eval(mpz_ptr z, mpz_srcptr w, signed long int l)
852	{ __GMPXX_TMPZ_SI; mpz_xor (z, w, temp); }
853	static void eval(mpz_ptr z, signed long int l, mpz_srcptr w)
854	{ eval(z, w, l); }
855	static void eval(mpz_ptr z, mpz_srcptr w, double d)
856	{ __GMPXX_TMPZ_D; mpz_xor (z, w, temp); }
857	static void eval(mpz_ptr z, double d, mpz_srcptr w)
858	{ eval(z, w, d); }
859	};
860
861	struct __gmp_binary_equal
862	{
863	static bool eval(mpz_srcptr z, mpz_srcptr w) { return mpz_cmp(z, w) == 0; }
864
865	static bool eval(mpz_srcptr z, unsigned long int l)
866	{ return mpz_cmp_ui(z, l) == 0; }
867	static bool eval(unsigned long int l, mpz_srcptr z)
868	{ return eval(z, l); }
869	static bool eval(mpz_srcptr z, signed long int l)
870	{ return mpz_cmp_si(z, l) == 0; }
871	static bool eval(signed long int l, mpz_srcptr z)
872	{ return eval(z, l); }
873	static bool eval(mpz_srcptr z, double d)
874	{ return mpz_cmp_d(z, d) == 0; }
875	static bool eval(double d, mpz_srcptr z)
876	{ return eval(z, d); }
877
878	static bool eval(mpq_srcptr q, mpq_srcptr r)
879	{ return mpq_equal(q, r) != 0; }
880
881	static bool eval(mpq_srcptr q, unsigned long int l)
882	{ return mpq_cmp_ui(q, l, 1) == 0; }
883	static bool eval(unsigned long int l, mpq_srcptr q)
884	{ return eval(q, l); }
885	static bool eval(mpq_srcptr q, signed long int l)
886	{ return mpq_cmp_si(q, l, 1) == 0; }
887	static bool eval(signed long int l, mpq_srcptr q)
888	{ return eval(q, l); }
889	static bool eval(mpq_srcptr q, double d)
890	{ __GMPXX_TMPQ_D; return mpq_equal (q, temp) != 0; }
891	static bool eval(double d, mpq_srcptr q)
892	{ return eval(q, d); }
893
894	static bool eval(mpf_srcptr f, mpf_srcptr g) { return mpf_cmp(f, g) == 0; }
895
896	static bool eval(mpf_srcptr f, unsigned long int l)
897	{ return mpf_cmp_ui(f, l) == 0; }
898	static bool eval(unsigned long int l, mpf_srcptr f)
899	{ return eval(f, l); }
900	static bool eval(mpf_srcptr f, signed long int l)
901	{ return mpf_cmp_si(f, l) == 0; }
902	static bool eval(signed long int l, mpf_srcptr f)
903	{ return eval(f, l); }
904	static bool eval(mpf_srcptr f, double d)
905	{ return mpf_cmp_d(f, d) == 0; }
906	static bool eval(double d, mpf_srcptr f)
907	{ return eval(f, d); }
908	};
909
910	struct __gmp_binary_less
911	{
912	static bool eval(mpz_srcptr z, mpz_srcptr w) { return mpz_cmp(z, w) < 0; }
913
914	static bool eval(mpz_srcptr z, unsigned long int l)
915	{ return mpz_cmp_ui(z, l) < 0; }
916	static bool eval(unsigned long int l, mpz_srcptr z)
917	{ return mpz_cmp_ui(z, l) > 0; }
918	static bool eval(mpz_srcptr z, signed long int l)
919	{ return mpz_cmp_si(z, l) < 0; }
920	static bool eval(signed long int l, mpz_srcptr z)
921	{ return mpz_cmp_si(z, l) > 0; }
922	static bool eval(mpz_srcptr z, double d)
923	{ return mpz_cmp_d(z, d) < 0; }
924	static bool eval(double d, mpz_srcptr z)
925	{ return mpz_cmp_d(z, d) > 0; }
926
927	static bool eval(mpq_srcptr q, mpq_srcptr r) { return mpq_cmp(q, r) < 0; }
928
929	static bool eval(mpq_srcptr q, unsigned long int l)
930	{ return mpq_cmp_ui(q, l, 1) < 0; }
931	static bool eval(unsigned long int l, mpq_srcptr q)
932	{ return mpq_cmp_ui(q, l, 1) > 0; }
933	static bool eval(mpq_srcptr q, signed long int l)
934	{ return mpq_cmp_si(q, l, 1) < 0; }
935	static bool eval(signed long int l, mpq_srcptr q)
936	{ return mpq_cmp_si(q, l, 1) > 0; }
937	static bool eval(mpq_srcptr q, double d)
938	{ __GMPXX_TMPQ_D; return mpq_cmp (q, temp) < 0; }
939	static bool eval(double d, mpq_srcptr q)
940	{ __GMPXX_TMPQ_D; return mpq_cmp (temp, q) < 0; }
941
942	static bool eval(mpf_srcptr f, mpf_srcptr g) { return mpf_cmp(f, g) < 0; }
943
944	static bool eval(mpf_srcptr f, unsigned long int l)
945	{ return mpf_cmp_ui(f, l) < 0; }
946	static bool eval(unsigned long int l, mpf_srcptr f)
947	{ return mpf_cmp_ui(f, l) > 0; }
948	static bool eval(mpf_srcptr f, signed long int l)
949	{ return mpf_cmp_si(f, l) < 0; }
950	static bool eval(signed long int l, mpf_srcptr f)
951	{ return mpf_cmp_si(f, l) > 0; }
952	static bool eval(mpf_srcptr f, double d)
953	{ return mpf_cmp_d(f, d) < 0; }
954	static bool eval(double d, mpf_srcptr f)
955	{ return mpf_cmp_d(f, d) > 0; }
956	};
957
958	struct __gmp_binary_greater
959	{
960	template <class T, class U>
961	static inline bool eval(T t, U u) { return __gmp_binary_less::eval(u, t); }
962	};
963
964	struct __gmp_unary_increment
965	{
966	static void eval(mpz_ptr z) { mpz_add_ui(z, z, 1); }
967	static void eval(mpq_ptr q)
968	{ mpz_add(mpq_numref(q), mpq_numref(q), mpq_denref(q)); }
969	static void eval(mpf_ptr f) { mpf_add_ui(f, f, 1); }
970	};
971
972	struct __gmp_unary_decrement
973	{
974	static void eval(mpz_ptr z) { mpz_sub_ui(z, z, 1); }
975	static void eval(mpq_ptr q)
976	{ mpz_sub(mpq_numref(q), mpq_numref(q), mpq_denref(q)); }
977	static void eval(mpf_ptr f) { mpf_sub_ui(f, f, 1); }
978	};
979
980	struct __gmp_abs_function
981	{
982	static void eval(mpz_ptr z, mpz_srcptr w) { mpz_abs(z, w); }
983	static void eval(mpq_ptr q, mpq_srcptr r) { mpq_abs(q, r); }
984	static void eval(mpf_ptr f, mpf_srcptr g) { mpf_abs(f, g); }
985	};
986
987	struct __gmp_trunc_function
988	{
989	static void eval(mpf_ptr f, mpf_srcptr g) { mpf_trunc(f, g); }
990	};
991
992	struct __gmp_floor_function
993	{
994	static void eval(mpf_ptr f, mpf_srcptr g) { mpf_floor(f, g); }
995	};
996
997	struct __gmp_ceil_function
998	{
999	static void eval(mpf_ptr f, mpf_srcptr g) { mpf_ceil(f, g); }
1000	};
1001
1002	struct __gmp_sqrt_function
1003	{
1004	static void eval(mpz_ptr z, mpz_srcptr w) { mpz_sqrt(z, w); }
1005	static void eval(mpf_ptr f, mpf_srcptr g) { mpf_sqrt(f, g); }
1006	};
1007
1008	struct __gmp_hypot_function
1009	{
1010	static void eval(mpf_ptr f, mpf_srcptr g, mpf_srcptr h)
1011	{
1012	mpf_t temp;
1013	mpf_init2(temp, mpf_get_prec(f));
1014	mpf_mul(temp, g, g);
1015	mpf_mul(f, h, h);
1016	mpf_add(f, f, temp);
1017	mpf_sqrt(f, f);
1018	mpf_clear(temp);
1019	}
1020
1021	static void eval(mpf_ptr f, mpf_srcptr g, unsigned long int l)
1022	{
1023	mpf_t temp;
1024	mpf_init2(temp, mpf_get_prec(f));
1025	mpf_mul(temp, g, g);
1026	mpf_set_ui(f, l);
1027	mpf_mul_ui(f, f, l);
1028	mpf_add(f, f, temp);
1029	mpf_clear(temp);
1030	mpf_sqrt(f, f);
1031	}
1032	static void eval(mpf_ptr f, unsigned long int l, mpf_srcptr g)
1033	{ eval(f, g, l); }
1034	static void eval(mpf_ptr f, mpf_srcptr g, signed long int l)
1035	{ eval(f, g, __gmpxx_abs_ui(l)); }
1036	static void eval(mpf_ptr f, signed long int l, mpf_srcptr g)
1037	{ eval(f, g, l); }
1038	static void eval(mpf_ptr f, mpf_srcptr g, double d)
1039	{
1040	mpf_t temp;
1041	mpf_init2(temp, mpf_get_prec(f));
1042	mpf_mul(temp, g, g);
1043	mpf_set_d(f, d);
1044	mpf_mul(f, f, f);
1045	mpf_add(f, f, temp);
1046	mpf_sqrt(f, f);
1047	mpf_clear(temp);
1048	}
1049	static void eval(mpf_ptr f, double d, mpf_srcptr g)
1050	{ eval(f, g, d); }
1051	};
1052
1053	struct __gmp_sgn_function
1054	{
1055	static int eval(mpz_srcptr z) { return mpz_sgn(z); }
1056	static int eval(mpq_srcptr q) { return mpq_sgn(q); }
1057	static int eval(mpf_srcptr f) { return mpf_sgn(f); }
1058	};
1059
1060	struct __gmp_cmp_function
1061	{
1062	static int eval(mpz_srcptr z, mpz_srcptr w) { return mpz_cmp(z, w); }
1063
1064	static int eval(mpz_srcptr z, unsigned long int l)
1065	{ return mpz_cmp_ui(z, l); }
1066	static int eval(unsigned long int l, mpz_srcptr z)
1067	{ return -mpz_cmp_ui(z, l); }
1068	static int eval(mpz_srcptr z, signed long int l)
1069	{ return mpz_cmp_si(z, l); }
1070	static int eval(signed long int l, mpz_srcptr z)
1071	{ return -mpz_cmp_si(z, l); }
1072	static int eval(mpz_srcptr z, double d)
1073	{ return mpz_cmp_d(z, d); }
1074	static int eval(double d, mpz_srcptr z)
1075	{ return -mpz_cmp_d(z, d); }
1076
1077	static int eval(mpq_srcptr q, mpq_srcptr r) { return mpq_cmp(q, r); }
1078
1079	static int eval(mpq_srcptr q, unsigned long int l)
1080	{ return mpq_cmp_ui(q, l, 1); }
1081	static int eval(unsigned long int l, mpq_srcptr q)
1082	{ return -mpq_cmp_ui(q, l, 1); }
1083	static int eval(mpq_srcptr q, signed long int l)
1084	{ return mpq_cmp_si(q, l, 1); }
1085	static int eval(signed long int l, mpq_srcptr q)
1086	{ return -mpq_cmp_si(q, l, 1); }
1087	static int eval(mpq_srcptr q, double d)
1088	{ __GMPXX_TMPQ_D; return mpq_cmp (q, temp); }
1089	static int eval(double d, mpq_srcptr q)
1090	{ __GMPXX_TMPQ_D; return mpq_cmp (temp, q); }
1091
1092	static int eval(mpf_srcptr f, mpf_srcptr g) { return mpf_cmp(f, g); }
1093
1094	static int eval(mpf_srcptr f, unsigned long int l)
1095	{ return mpf_cmp_ui(f, l); }
1096	static int eval(unsigned long int l, mpf_srcptr f)
1097	{ return -mpf_cmp_ui(f, l); }
1098	static int eval(mpf_srcptr f, signed long int l)
1099	{ return mpf_cmp_si(f, l); }
1100	static int eval(signed long int l, mpf_srcptr f)
1101	{ return -mpf_cmp_si(f, l); }
1102	static int eval(mpf_srcptr f, double d)
1103	{ return mpf_cmp_d(f, d); }
1104	static int eval(double d, mpf_srcptr f)
1105	{ return -mpf_cmp_d(f, d); }
1106	};
1107
1108	struct __gmp_rand_function
1109	{
1110	static void eval(mpz_ptr z, gmp_randstate_t s, mp_bitcnt_t l)
1111	{ mpz_urandomb(z, s, l); }
1112	static void eval(mpz_ptr z, gmp_randstate_t s, mpz_srcptr w)
1113	{ mpz_urandomm(z, s, w); }
1114	static void eval(mpf_ptr f, gmp_randstate_t s, mp_bitcnt_t prec)
1115	{ mpf_urandomb(f, s, prec); }
1116	};
1117
1118
1119	/**************** Auxiliary classes ****************/
1120
1121	/* this is much the same as gmp_allocated_string in gmp-impl.h
1122	since gmp-impl.h is not publicly available, I redefine it here
1123	I use a different name to avoid possible clashes */
1124
1125	extern "C" {
1126	typedef void (*__gmp_freefunc_t) (void *, size_t);
1127	}
1128	struct __gmp_alloc_cstring
1129	{
1130	char *str;
1131	__gmp_alloc_cstring(char *s) { str = s; }
1132	~__gmp_alloc_cstring()
1133	{
1134	__gmp_freefunc_t freefunc;
1135	mp_get_memory_functions (NULL, NULL, &freefunc);
1136	(*freefunc) (str, std::strlen(str)+1);
1137	}
1138	};
1139
1140
1141	// general expression template class
1142	template <class T, class U>
1143	class __gmp_expr;
1144
1145
1146	// templates for resolving expression types
1147	template <class T>
1148	struct __gmp_resolve_ref
1149	{
1150	typedef T ref_type;
1151	};
1152
1153	template <class T, class U>
1154	struct __gmp_resolve_ref<__gmp_expr<T, U> >
1155	{
1156	typedef const __gmp_expr<T, U> & ref_type;
1157	};
1158
1159
1160	template <class T, class U = T>
1161	struct __gmp_resolve_expr;
1162
1163	template <>
1164	struct __gmp_resolve_expr<mpz_t>
1165	{
1166	typedef mpz_t value_type;
1167	typedef mpz_ptr ptr_type;
1168	typedef mpz_srcptr srcptr_type;
1169	};
1170
1171	template <>
1172	struct __gmp_resolve_expr<mpq_t>
1173	{
1174	typedef mpq_t value_type;
1175	typedef mpq_ptr ptr_type;
1176	typedef mpq_srcptr srcptr_type;
1177	};
1178
1179	template <>
1180	struct __gmp_resolve_expr<mpf_t>
1181	{
1182	typedef mpf_t value_type;
1183	typedef mpf_ptr ptr_type;
1184	typedef mpf_srcptr srcptr_type;
1185	};
1186
1187	template <>
1188	struct __gmp_resolve_expr<mpz_t, mpq_t>
1189	{
1190	typedef mpq_t value_type;
1191	};
1192
1193	template <>
1194	struct __gmp_resolve_expr<mpq_t, mpz_t>
1195	{
1196	typedef mpq_t value_type;
1197	};
1198
1199	template <>
1200	struct __gmp_resolve_expr<mpz_t, mpf_t>
1201	{
1202	typedef mpf_t value_type;
1203	};
1204
1205	template <>
1206	struct __gmp_resolve_expr<mpf_t, mpz_t>
1207	{
1208	typedef mpf_t value_type;
1209	};
1210
1211	template <>
1212	struct __gmp_resolve_expr<mpq_t, mpf_t>
1213	{
1214	typedef mpf_t value_type;
1215	};
1216
1217	template <>
1218	struct __gmp_resolve_expr<mpf_t, mpq_t>
1219	{
1220	typedef mpf_t value_type;
1221	};
1222
1223	#if __GMPXX_USE_CXX11
1224	namespace std {
1225	template <class T, class U, class V, class W>
1226	struct common_type <__gmp_expr<T, U>, __gmp_expr<V, W> >
1227	{
1228	private:
1229	typedef typename __gmp_resolve_expr<T, V>::value_type X;
1230	public:
1231	typedef __gmp_expr<X, X> type;
1232	};
1233
1234	template <class T, class U>
1235	struct common_type <__gmp_expr<T, U>, __gmp_expr<T, U> >
1236	{
1237	typedef __gmp_expr<T, U> type;
1238	};
1239
1240	#define __GMPXX_DECLARE_COMMON_TYPE(typ) \
1241	template <class T, class U> \
1242	struct common_type <__gmp_expr<T, U>, typ > \
1243	{ \
1244	typedef __gmp_expr<T, T> type; \
1245	}; \
1246	\
1247	template <class T, class U> \
1248	struct common_type <typ, __gmp_expr<T, U> > \
1249	{ \
1250	typedef __gmp_expr<T, T> type; \
1251	}
1252
1253	__GMPXX_DECLARE_COMMON_TYPE(signed char);
1254	__GMPXX_DECLARE_COMMON_TYPE(unsigned char);
1255	__GMPXX_DECLARE_COMMON_TYPE(signed int);
1256	__GMPXX_DECLARE_COMMON_TYPE(unsigned int);
1257	__GMPXX_DECLARE_COMMON_TYPE(signed short int);
1258	__GMPXX_DECLARE_COMMON_TYPE(unsigned short int);
1259	__GMPXX_DECLARE_COMMON_TYPE(signed long int);
1260	__GMPXX_DECLARE_COMMON_TYPE(unsigned long int);
1261	__GMPXX_DECLARE_COMMON_TYPE(float);
1262	__GMPXX_DECLARE_COMMON_TYPE(double);
1263	#undef __GMPXX_DECLARE_COMMON_TYPE
1264	}
1265	#endif
1266
1267	// classes for evaluating unary and binary expressions
1268	template <class T, class Op>
1269	struct __gmp_unary_expr
1270	{
1271	const T &val;
1272
1273	__gmp_unary_expr(const T &v) : val(v) { }
1274	private:
1275	__gmp_unary_expr();
1276	};
1277
1278	template <class T, class U, class Op>
1279	struct __gmp_binary_expr
1280	{
1281	typename __gmp_resolve_ref<T>::ref_type val1;
1282	typename __gmp_resolve_ref<U>::ref_type val2;
1283
1284	__gmp_binary_expr(const T &v1, const U &v2) : val1(v1), val2(v2) { }
1285	private:
1286	__gmp_binary_expr();
1287	};
1288
1289
1290
1291	/**************** Macros for in-class declarations ****************/
1292	/* This is just repetitive code that is easier to maintain if it's written
1293	only once */
1294
1295	#define __GMPP_DECLARE_COMPOUND_OPERATOR(fun) \
1296	template <class T, class U> \
1297	__gmp_expr<value_type, value_type> & fun(const __gmp_expr<T, U> &);
1298
1299	#define __GMPN_DECLARE_COMPOUND_OPERATOR(fun) \
1300	__gmp_expr & fun(signed char); \
1301	__gmp_expr & fun(unsigned char); \
1302	__gmp_expr & fun(signed int); \
1303	__gmp_expr & fun(unsigned int); \
1304	__gmp_expr & fun(signed short int); \
1305	__gmp_expr & fun(unsigned short int); \
1306	__gmp_expr & fun(signed long int); \
1307	__gmp_expr & fun(unsigned long int); \
1308	__gmp_expr & fun(float); \
1309	__gmp_expr & fun(double); \
1310	/* __gmp_expr & fun(long double); */
1311
1312	#define __GMP_DECLARE_COMPOUND_OPERATOR(fun) \
1313	__GMPP_DECLARE_COMPOUND_OPERATOR(fun) \
1314	__GMPN_DECLARE_COMPOUND_OPERATOR(fun)
1315
1316	#define __GMP_DECLARE_COMPOUND_OPERATOR_UI(fun) \
1317	__gmp_expr & fun(mp_bitcnt_t);
1318
1319	#define __GMP_DECLARE_INCREMENT_OPERATOR(fun) \
1320	inline __gmp_expr & fun(); \
1321	inline __gmp_expr fun(int);
1322
1323	#define __GMPXX_DEFINE_ARITHMETIC_CONSTRUCTORS \
1324	__gmp_expr(signed char c) { init_si(c); } \
1325	__gmp_expr(unsigned char c) { init_ui(c); } \
1326	__gmp_expr(signed int i) { init_si(i); } \
1327	__gmp_expr(unsigned int i) { init_ui(i); } \
1328	__gmp_expr(signed short int s) { init_si(s); } \
1329	__gmp_expr(unsigned short int s) { init_ui(s); } \
1330	__gmp_expr(signed long int l) { init_si(l); } \
1331	__gmp_expr(unsigned long int l) { init_ui(l); } \
1332	__gmp_expr(float f) { init_d(f); } \
1333	__gmp_expr(double d) { init_d(d); }
1334
1335	#define __GMPXX_DEFINE_ARITHMETIC_ASSIGNMENTS \
1336	__gmp_expr & operator=(signed char c) { assign_si(c); return *this; } \
1337	__gmp_expr & operator=(unsigned char c) { assign_ui(c); return *this; } \
1338	__gmp_expr & operator=(signed int i) { assign_si(i); return *this; } \
1339	__gmp_expr & operator=(unsigned int i) { assign_ui(i); return *this; } \
1340	__gmp_expr & operator=(signed short int s) { assign_si(s); return *this; } \
1341	__gmp_expr & operator=(unsigned short int s) { assign_ui(s); return *this; } \
1342	__gmp_expr & operator=(signed long int l) { assign_si(l); return *this; } \
1343	__gmp_expr & operator=(unsigned long int l) { assign_ui(l); return *this; } \
1344	__gmp_expr & operator=(float f) { assign_d(f); return *this; } \
1345	__gmp_expr & operator=(double d) { assign_d(d); return *this; }
1346
1347	/**************** mpz_class -- wrapper for mpz_t ****************/
1348
1349	template <>
1350	class __gmp_expr<mpz_t, mpz_t>
1351	{
1352	private:
1353	typedef mpz_t value_type;
1354	value_type mp;
1355
1356	// Helper functions used for all arithmetic types
1357	void assign_ui(unsigned long l)
1358	{
1359	if (__GMPXX_CONSTANT_TRUE(l == 0))
1360	mp->_mp_size = 0;
1361	else
1362	mpz_set_ui(mp, l);
1363	}
1364	void assign_si(signed long l)
1365	{
1366	if (__GMPXX_CONSTANT_TRUE(l >= 0))
1367	assign_ui(l);
1368	else if (__GMPXX_CONSTANT_TRUE(l <= 0))
1369	{
1370	assign_ui(-static_cast<unsigned long>(l));
1371	mpz_neg(mp, mp);
1372	}
1373	else
1374	mpz_set_si(mp, l);
1375	}
1376	void assign_d (double d)
1377	{
1378	mpz_set_d (mp, d);
1379	}
1380
1381	void init_ui(unsigned long l)
1382	{
1383	if (__GMPXX_CONSTANT_TRUE(l == 0))
1384	mpz_init(mp);
1385	else
1386	mpz_init_set_ui(mp, l);
1387	}
1388	void init_si(signed long l)
1389	{
1390	if (__GMPXX_CONSTANT_TRUE(l >= 0))
1391	init_ui(l);
1392	else if (__GMPXX_CONSTANT_TRUE(l <= 0))
1393	{
1394	init_ui(-static_cast<unsigned long>(l));
1395	mpz_neg(mp, mp);
1396	}
1397	else
1398	mpz_init_set_si(mp, l);
1399	}
1400	void init_d (double d)
1401	{
1402	mpz_init_set_d (mp, d);
1403	}
1404
1405	public:
1406	mp_bitcnt_t get_prec() const { return mpf_get_default_prec(); }
1407
1408	// constructors and destructor
1409	__gmp_expr() { mpz_init(mp); }
1410
1411	__gmp_expr(const __gmp_expr &z) { mpz_init_set(mp, z.mp); }
1412	#if __GMPXX_USE_CXX11
1413	__gmp_expr(__gmp_expr &&z)
1414	{ *mp = *z.mp; mpz_init(z.mp); }
1415	#endif
1416	template <class T>
1417	__gmp_expr(const __gmp_expr<mpz_t, T> &expr)
1418	{ mpz_init(mp); __gmp_set_expr(mp, expr); }
1419	template <class T, class U>
1420	explicit __gmp_expr(const __gmp_expr<T, U> &expr)
1421	{ mpz_init(mp); __gmp_set_expr(mp, expr); }
1422
1423	__GMPXX_DEFINE_ARITHMETIC_CONSTRUCTORS
1424
1425	explicit __gmp_expr(const char *s, int base = 0)
1426	{
1427	if (mpz_init_set_str (mp, s, base) != 0)
1428	{
1429	mpz_clear (mp);
1430	throw std::invalid_argument ("mpz_set_str");
1431	}
1432	}
1433	explicit __gmp_expr(const std::string &s, int base = 0)
1434	{
1435	if (mpz_init_set_str(mp, s.c_str(), base) != 0)
1436	{
1437	mpz_clear (mp);
1438	throw std::invalid_argument ("mpz_set_str");
1439	}
1440	}
1441
1442	explicit __gmp_expr(mpz_srcptr z) { mpz_init_set(mp, z); }
1443
1444	~__gmp_expr() { mpz_clear(mp); }
1445
1446	void swap(__gmp_expr& z) __GMPXX_NOEXCEPT { std::swap(*mp, *z.mp); }
1447
1448	// assignment operators
1449	__gmp_expr & operator=(const __gmp_expr &z)
1450	{ mpz_set(mp, z.mp); return *this; }
1451	#if __GMPXX_USE_CXX11
1452	__gmp_expr & operator=(__gmp_expr &&z) noexcept
1453	{ swap(z); return *this; }
1454	#endif
1455	template <class T, class U>
1456	__gmp_expr<value_type, value_type> & operator=(const __gmp_expr<T, U> &expr)
1457	{ __gmp_set_expr(mp, expr); return *this; }
1458
1459	__GMPXX_DEFINE_ARITHMETIC_ASSIGNMENTS
1460
1461	__gmp_expr & operator=(const char *s)
1462	{
1463	if (mpz_set_str (mp, s, 0) != 0)
1464	throw std::invalid_argument ("mpz_set_str");
1465	return *this;
1466	}
1467	__gmp_expr & operator=(const std::string &s)
1468	{
1469	if (mpz_set_str(mp, s.c_str(), 0) != 0)
1470	throw std::invalid_argument ("mpz_set_str");
1471	return *this;
1472	}
1473
1474	// string input/output functions
1475	int set_str(const char *s, int base)
1476	{ return mpz_set_str(mp, s, base); }
1477	int set_str(const std::string &s, int base)
1478	{ return mpz_set_str(mp, s.c_str(), base); }
1479	std::string get_str(int base = 10) const
1480	{
1481	__gmp_alloc_cstring temp(mpz_get_str(0, base, mp));
1482	return std::string(temp.str);
1483	}
1484
1485	// conversion functions
1486	mpz_srcptr __get_mp() const { return mp; }
1487	mpz_ptr __get_mp() { return mp; }
1488	mpz_srcptr get_mpz_t() const { return mp; }
1489	mpz_ptr get_mpz_t() { return mp; }
1490
1491	signed long int get_si() const { return mpz_get_si(mp); }
1492	unsigned long int get_ui() const { return mpz_get_ui(mp); }
1493	double get_d() const { return mpz_get_d(mp); }
1494
1495	// bool fits_schar_p() const { return mpz_fits_schar_p(mp); }
1496	// bool fits_uchar_p() const { return mpz_fits_uchar_p(mp); }
1497	bool fits_sint_p() const { return mpz_fits_sint_p(mp); }
1498	bool fits_uint_p() const { return mpz_fits_uint_p(mp); }
1499	bool fits_sshort_p() const { return mpz_fits_sshort_p(mp); }
1500	bool fits_ushort_p() const { return mpz_fits_ushort_p(mp); }
1501	bool fits_slong_p() const { return mpz_fits_slong_p(mp); }
1502	bool fits_ulong_p() const { return mpz_fits_ulong_p(mp); }
1503	// bool fits_float_p() const { return mpz_fits_float_p(mp); }
1504	// bool fits_double_p() const { return mpz_fits_double_p(mp); }
1505	// bool fits_ldouble_p() const { return mpz_fits_ldouble_p(mp); }
1506
1507	#if __GMPXX_USE_CXX11
1508	explicit operator bool() const { return mp->_mp_size != 0; }
1509	#endif
1510
1511	// member operators
1512	__GMP_DECLARE_COMPOUND_OPERATOR(operator+=)
1513	__GMP_DECLARE_COMPOUND_OPERATOR(operator-=)
1514	__GMP_DECLARE_COMPOUND_OPERATOR(operator*=)
1515	__GMP_DECLARE_COMPOUND_OPERATOR(operator/=)
1516	__GMP_DECLARE_COMPOUND_OPERATOR(operator%=)
1517
1518	__GMP_DECLARE_COMPOUND_OPERATOR(operator&=)
1519	__GMP_DECLARE_COMPOUND_OPERATOR(operator|=)
1520	__GMP_DECLARE_COMPOUND_OPERATOR(operator^=)
1521
1522	__GMP_DECLARE_COMPOUND_OPERATOR_UI(operator<<=)
1523	__GMP_DECLARE_COMPOUND_OPERATOR_UI(operator>>=)
1524
1525	__GMP_DECLARE_INCREMENT_OPERATOR(operator++)
1526	__GMP_DECLARE_INCREMENT_OPERATOR(operator--)
1527	};
1528
1529	typedef __gmp_expr<mpz_t, mpz_t> mpz_class;
1530
1531
1532	/**************** mpq_class -- wrapper for mpq_t ****************/
1533
1534	template <>
1535	class __gmp_expr<mpq_t, mpq_t>
1536	{
1537	private:
1538	typedef mpq_t value_type;
1539	value_type mp;
1540
1541	// Helper functions used for all arithmetic types
1542	void assign_ui(unsigned long l) { mpq_set_ui(mp, l, 1); }
1543	void assign_si(signed long l)
1544	{
1545	if (__GMPXX_CONSTANT_TRUE(l >= 0))
1546	assign_ui(l);
1547	else
1548	mpq_set_si(mp, l, 1);
1549	}
1550	void assign_d (double d) { mpq_set_d (mp, d); }
1551
1552	void init_ui(unsigned long l) { mpq_init(mp); get_num() = l; }
1553	void init_si(signed long l) { mpq_init(mp); get_num() = l; }
1554	void init_d (double d) { mpq_init(mp); assign_d (d); }
1555
1556	public:
1557	mp_bitcnt_t get_prec() const { return mpf_get_default_prec(); }
1558	void canonicalize() { mpq_canonicalize(mp); }
1559
1560	// constructors and destructor
1561	__gmp_expr() { mpq_init(mp); }
1562
1563	__gmp_expr(const __gmp_expr &q)
1564	{
1565	mpz_init_set(mpq_numref(mp), mpq_numref(q.mp));
1566	mpz_init_set(mpq_denref(mp), mpq_denref(q.mp));
1567	}
1568	#if __GMPXX_USE_CXX11
1569	__gmp_expr(__gmp_expr &&q)
1570	{ *mp = *q.mp; mpq_init(q.mp); }
1571	#endif
1572	template <class T>
1573	__gmp_expr(const __gmp_expr<mpz_t, T> &expr)
1574	{ mpq_init(mp); __gmp_set_expr(mp, expr); }
1575	template <class T>
1576	__gmp_expr(const __gmp_expr<mpq_t, T> &expr)
1577	{ mpq_init(mp); __gmp_set_expr(mp, expr); }
1578	template <class T, class U>
1579	explicit __gmp_expr(const __gmp_expr<T, U> &expr)
1580	{ mpq_init(mp); __gmp_set_expr(mp, expr); }
1581
1582	__GMPXX_DEFINE_ARITHMETIC_CONSTRUCTORS
1583
1584	explicit __gmp_expr(const char *s, int base = 0)
1585	{
1586	mpq_init (mp);
1587	// If s is the literal 0, we meant to call another constructor.
1588	// If s just happens to evaluate to 0, we would crash, so whatever.
1589	if (s == 0)
1590	{
1591	// Don't turn mpq_class(0,0) into 0
1592	mpz_set_si(mpq_denref(mp), base);
1593	}
1594	else if (mpq_set_str(mp, s, base) != 0)
1595	{
1596	mpq_clear (mp);
1597	throw std::invalid_argument ("mpq_set_str");
1598	}
1599	}
1600	explicit __gmp_expr(const std::string &s, int base = 0)
1601	{
1602	mpq_init(mp);
1603	if (mpq_set_str (mp, s.c_str(), base) != 0)
1604	{
1605	mpq_clear (mp);
1606	throw std::invalid_argument ("mpq_set_str");
1607	}
1608	}
1609	explicit __gmp_expr(mpq_srcptr q)
1610	{
1611	mpz_init_set(mpq_numref(mp), mpq_numref(q));
1612	mpz_init_set(mpq_denref(mp), mpq_denref(q));
1613	}
1614
1615	__gmp_expr(const mpz_class &num, const mpz_class &den)
1616	{
1617	mpz_init_set(mpq_numref(mp), num.get_mpz_t());
1618	mpz_init_set(mpq_denref(mp), den.get_mpz_t());
1619	}
1620
1621	~__gmp_expr() { mpq_clear(mp); }
1622
1623	void swap(__gmp_expr& q) __GMPXX_NOEXCEPT { std::swap(*mp, *q.mp); }
1624
1625	// assignment operators
1626	__gmp_expr & operator=(const __gmp_expr &q)
1627	{ mpq_set(mp, q.mp); return *this; }
1628	#if __GMPXX_USE_CXX11
1629	__gmp_expr & operator=(__gmp_expr &&q) noexcept
1630	{ swap(q); return *this; }
1631	__gmp_expr & operator=(mpz_class &&z) noexcept
1632	{ get_num() = std::move(z); get_den() = 1u; return *this; }
1633	#endif
1634	template <class T, class U>
1635	__gmp_expr<value_type, value_type> & operator=(const __gmp_expr<T, U> &expr)
1636	{ __gmp_set_expr(mp, expr); return *this; }
1637
1638	__GMPXX_DEFINE_ARITHMETIC_ASSIGNMENTS
1639
1640	__gmp_expr & operator=(const char *s)
1641	{
1642	if (mpq_set_str (mp, s, 0) != 0)
1643	throw std::invalid_argument ("mpq_set_str");
1644	return *this;
1645	}
1646	__gmp_expr & operator=(const std::string &s)
1647	{
1648	if (mpq_set_str(mp, s.c_str(), 0) != 0)
1649	throw std::invalid_argument ("mpq_set_str");
1650	return *this;
1651	}
1652
1653	// string input/output functions
1654	int set_str(const char *s, int base)
1655	{ return mpq_set_str(mp, s, base); }
1656	int set_str(const std::string &s, int base)
1657	{ return mpq_set_str(mp, s.c_str(), base); }
1658	std::string get_str(int base = 10) const
1659	{
1660	__gmp_alloc_cstring temp(mpq_get_str(0, base, mp));
1661	return std::string(temp.str);
1662	}
1663
1664	// conversion functions
1665
1666	// casting a reference to an mpz_t to mpz_class & is a dirty hack,
1667	// but works because the internal representation of mpz_class is
1668	// exactly an mpz_t
1669	const mpz_class & get_num() const
1670	{ return reinterpret_cast<const mpz_class &>(*mpq_numref(mp)); }
1671	mpz_class & get_num()
1672	{ return reinterpret_cast<mpz_class &>(*mpq_numref(mp)); }
1673	const mpz_class & get_den() const
1674	{ return reinterpret_cast<const mpz_class &>(*mpq_denref(mp)); }
1675	mpz_class & get_den()
1676	{ return reinterpret_cast<mpz_class &>(*mpq_denref(mp)); }
1677
1678	mpq_srcptr __get_mp() const { return mp; }
1679	mpq_ptr __get_mp() { return mp; }
1680	mpq_srcptr get_mpq_t() const { return mp; }
1681	mpq_ptr get_mpq_t() { return mp; }
1682
1683	mpz_srcptr get_num_mpz_t() const { return mpq_numref(mp); }
1684	mpz_ptr get_num_mpz_t() { return mpq_numref(mp); }
1685	mpz_srcptr get_den_mpz_t() const { return mpq_denref(mp); }
1686	mpz_ptr get_den_mpz_t() { return mpq_denref(mp); }
1687
1688	double get_d() const { return mpq_get_d(mp); }
1689
1690	#if __GMPXX_USE_CXX11
1691	explicit operator bool() const { return mpq_numref(mp)->_mp_size != 0; }
1692	#endif
1693
1694	// compound assignments
1695	__GMP_DECLARE_COMPOUND_OPERATOR(operator+=)
1696	__GMP_DECLARE_COMPOUND_OPERATOR(operator-=)
1697	__GMP_DECLARE_COMPOUND_OPERATOR(operator*=)
1698	__GMP_DECLARE_COMPOUND_OPERATOR(operator/=)
1699
1700	__GMP_DECLARE_COMPOUND_OPERATOR_UI(operator<<=)
1701	__GMP_DECLARE_COMPOUND_OPERATOR_UI(operator>>=)
1702
1703	__GMP_DECLARE_INCREMENT_OPERATOR(operator++)
1704	__GMP_DECLARE_INCREMENT_OPERATOR(operator--)
1705	};
1706
1707	typedef __gmp_expr<mpq_t, mpq_t> mpq_class;
1708
1709
1710	/**************** mpf_class -- wrapper for mpf_t ****************/
1711
1712	template <>
1713	class __gmp_expr<mpf_t, mpf_t>
1714	{
1715	private:
1716	typedef mpf_t value_type;
1717	value_type mp;
1718
1719	// Helper functions used for all arithmetic types
1720	void assign_ui(unsigned long l) { mpf_set_ui(mp, l); }
1721	void assign_si(signed long l)
1722	{
1723	if (__GMPXX_CONSTANT_TRUE(l >= 0))
1724	assign_ui(l);
1725	else
1726	mpf_set_si(mp, l);
1727	}
1728	void assign_d (double d) { mpf_set_d (mp, d); }
1729
1730	void init_ui(unsigned long l)
1731	{
1732	if (__GMPXX_CONSTANT_TRUE(l == 0))
1733	mpf_init(mp);
1734	else
1735	mpf_init_set_ui(mp, l);
1736	}
1737	void init_si(signed long l)
1738	{
1739	if (__GMPXX_CONSTANT_TRUE(l >= 0))
1740	init_ui(l);
1741	else
1742	mpf_init_set_si(mp, l);
1743	}
1744	void init_d (double d) { mpf_init_set_d (mp, d); }
1745
1746	public:
1747	mp_bitcnt_t get_prec() const { return mpf_get_prec(mp); }
1748
1749	void set_prec(mp_bitcnt_t prec) { mpf_set_prec(mp, prec); }
1750	void set_prec_raw(mp_bitcnt_t prec) { mpf_set_prec_raw(mp, prec); }
1751
1752	// constructors and destructor
1753	__gmp_expr() { mpf_init(mp); }
1754
1755	__gmp_expr(const __gmp_expr &f)
1756	{ mpf_init2(mp, f.get_prec()); mpf_set(mp, f.mp); }
1757	#if __GMPXX_USE_CXX11
1758	__gmp_expr(__gmp_expr &&f)
1759	{ *mp = *f.mp; mpf_init2(f.mp, get_prec()); }
1760	#endif
1761	__gmp_expr(const __gmp_expr &f, mp_bitcnt_t prec)
1762	{ mpf_init2(mp, prec); mpf_set(mp, f.mp); }
1763	template <class T, class U>
1764	__gmp_expr(const __gmp_expr<T, U> &expr)
1765	{ mpf_init2(mp, expr.get_prec()); __gmp_set_expr(mp, expr); }
1766	template <class T, class U>
1767	__gmp_expr(const __gmp_expr<T, U> &expr, mp_bitcnt_t prec)
1768	{ mpf_init2(mp, prec); __gmp_set_expr(mp, expr); }
1769
1770	__GMPXX_DEFINE_ARITHMETIC_CONSTRUCTORS
1771
1772	__gmp_expr(signed char c, mp_bitcnt_t prec)
1773	{ mpf_init2(mp, prec); mpf_set_si(mp, c); }
1774	__gmp_expr(unsigned char c, mp_bitcnt_t prec)
1775	{ mpf_init2(mp, prec); mpf_set_ui(mp, c); }
1776
1777	__gmp_expr(signed int i, mp_bitcnt_t prec)
1778	{ mpf_init2(mp, prec); mpf_set_si(mp, i); }
1779	__gmp_expr(unsigned int i, mp_bitcnt_t prec)
1780	{ mpf_init2(mp, prec); mpf_set_ui(mp, i); }
1781
1782	__gmp_expr(signed short int s, mp_bitcnt_t prec)
1783	{ mpf_init2(mp, prec); mpf_set_si(mp, s); }
1784	__gmp_expr(unsigned short int s, mp_bitcnt_t prec)
1785	{ mpf_init2(mp, prec); mpf_set_ui(mp, s); }
1786
1787	__gmp_expr(signed long int l, mp_bitcnt_t prec)
1788	{ mpf_init2(mp, prec); mpf_set_si(mp, l); }
1789	__gmp_expr(unsigned long int l, mp_bitcnt_t prec)
1790	{ mpf_init2(mp, prec); mpf_set_ui(mp, l); }
1791
1792	__gmp_expr(float f, mp_bitcnt_t prec)
1793	{ mpf_init2(mp, prec); mpf_set_d(mp, f); }
1794	__gmp_expr(double d, mp_bitcnt_t prec)
1795	{ mpf_init2(mp, prec); mpf_set_d(mp, d); }
1796	// __gmp_expr(long double ld) { mpf_init_set_d(mp, ld); }
1797	// __gmp_expr(long double ld, mp_bitcnt_t prec)
1798	// { mpf_init2(mp, prec); mpf_set_d(mp, ld); }
1799
1800	explicit __gmp_expr(const char *s)
1801	{
1802	if (mpf_init_set_str (mp, s, 0) != 0)
1803	{
1804	mpf_clear (mp);
1805	throw std::invalid_argument ("mpf_set_str");
1806	}
1807	}
1808	__gmp_expr(const char *s, mp_bitcnt_t prec, int base = 0)
1809	{
1810	mpf_init2(mp, prec);
1811	if (mpf_set_str(mp, s, base) != 0)
1812	{
1813	mpf_clear (mp);
1814	throw std::invalid_argument ("mpf_set_str");
1815	}
1816	}
1817	explicit __gmp_expr(const std::string &s)
1818	{
1819	if (mpf_init_set_str(mp, s.c_str(), 0) != 0)
1820	{
1821	mpf_clear (mp);
1822	throw std::invalid_argument ("mpf_set_str");
1823	}
1824	}
1825	__gmp_expr(const std::string &s, mp_bitcnt_t prec, int base = 0)
1826	{
1827	mpf_init2(mp, prec);
1828	if (mpf_set_str(mp, s.c_str(), base) != 0)
1829	{
1830	mpf_clear (mp);
1831	throw std::invalid_argument ("mpf_set_str");
1832	}
1833	}
1834
1835	explicit __gmp_expr(mpf_srcptr f)
1836	{ mpf_init2(mp, mpf_get_prec(f)); mpf_set(mp, f); }
1837	__gmp_expr(mpf_srcptr f, mp_bitcnt_t prec)
1838	{ mpf_init2(mp, prec); mpf_set(mp, f); }
1839
1840	~__gmp_expr() { mpf_clear(mp); }
1841
1842	void swap(__gmp_expr& f) __GMPXX_NOEXCEPT { std::swap(*mp, *f.mp); }
1843
1844	// assignment operators
1845	__gmp_expr & operator=(const __gmp_expr &f)
1846	{ mpf_set(mp, f.mp); return *this; }
1847	#if __GMPXX_USE_CXX11
1848	__gmp_expr & operator=(__gmp_expr &&f) noexcept
1849	{ swap(f); return *this; }
1850	#endif
1851	template <class T, class U>
1852	__gmp_expr<value_type, value_type> & operator=(const __gmp_expr<T, U> &expr)
1853	{ __gmp_set_expr(mp, expr); return *this; }
1854
1855	__GMPXX_DEFINE_ARITHMETIC_ASSIGNMENTS
1856
1857	__gmp_expr & operator=(const char *s)
1858	{
1859	if (mpf_set_str (mp, s, 0) != 0)
1860	throw std::invalid_argument ("mpf_set_str");
1861	return *this;
1862	}
1863	__gmp_expr & operator=(const std::string &s)
1864	{
1865	if (mpf_set_str(mp, s.c_str(), 0) != 0)
1866	throw std::invalid_argument ("mpf_set_str");
1867	return *this;
1868	}
1869
1870	// string input/output functions
1871	int set_str(const char *s, int base)
1872	{ return mpf_set_str(mp, s, base); }
1873	int set_str(const std::string &s, int base)
1874	{ return mpf_set_str(mp, s.c_str(), base); }
1875	std::string get_str(mp_exp_t &expo, int base = 10, size_t size = 0) const
1876	{
1877	__gmp_alloc_cstring temp(mpf_get_str(0, &expo, base, size, mp));
1878	return std::string(temp.str);
1879	}
1880
1881	// conversion functions
1882	mpf_srcptr __get_mp() const { return mp; }
1883	mpf_ptr __get_mp() { return mp; }
1884	mpf_srcptr get_mpf_t() const { return mp; }
1885	mpf_ptr get_mpf_t() { return mp; }
1886
1887	signed long int get_si() const { return mpf_get_si(mp); }
1888	unsigned long int get_ui() const { return mpf_get_ui(mp); }
1889	double get_d() const { return mpf_get_d(mp); }
1890
1891	// bool fits_schar_p() const { return mpf_fits_schar_p(mp); }
1892	// bool fits_uchar_p() const { return mpf_fits_uchar_p(mp); }
1893	bool fits_sint_p() const { return mpf_fits_sint_p(mp); }
1894	bool fits_uint_p() const { return mpf_fits_uint_p(mp); }
1895	bool fits_sshort_p() const { return mpf_fits_sshort_p(mp); }
1896	bool fits_ushort_p() const { return mpf_fits_ushort_p(mp); }
1897	bool fits_slong_p() const { return mpf_fits_slong_p(mp); }
1898	bool fits_ulong_p() const { return mpf_fits_ulong_p(mp); }
1899	// bool fits_float_p() const { return mpf_fits_float_p(mp); }
1900	// bool fits_double_p() const { return mpf_fits_double_p(mp); }
1901	// bool fits_ldouble_p() const { return mpf_fits_ldouble_p(mp); }
1902
1903	#if __GMPXX_USE_CXX11
1904	explicit operator bool() const { return mp->_mp_size != 0; }
1905	#endif
1906
1907	// compound assignments
1908	__GMP_DECLARE_COMPOUND_OPERATOR(operator+=)
1909	__GMP_DECLARE_COMPOUND_OPERATOR(operator-=)
1910	__GMP_DECLARE_COMPOUND_OPERATOR(operator*=)
1911	__GMP_DECLARE_COMPOUND_OPERATOR(operator/=)
1912
1913	__GMP_DECLARE_COMPOUND_OPERATOR_UI(operator<<=)
1914	__GMP_DECLARE_COMPOUND_OPERATOR_UI(operator>>=)
1915
1916	__GMP_DECLARE_INCREMENT_OPERATOR(operator++)
1917	__GMP_DECLARE_INCREMENT_OPERATOR(operator--)
1918	};
1919
1920	typedef __gmp_expr<mpf_t, mpf_t> mpf_class;
1921
1922
1923
1924	/**************** User-defined literals ****************/
1925
1926	#if __GMPXX_USE_CXX11
1927	inline mpz_class operator"" _mpz(const char* s)
1928	{
1929	return mpz_class(s);
1930	}
1931
1932	inline mpq_class operator"" _mpq(const char* s)
1933	{
1934	mpq_class q;
1935	q.get_num() = s;
1936	return q;
1937	}
1938
1939	inline mpf_class operator"" _mpf(const char* s)
1940	{
1941	return mpf_class(s);
1942	}
1943	#endif
1944
1945	/**************** I/O operators ****************/
1946
1947	// these should (and will) be provided separately
1948
1949	template <class T, class U>
1950	inline std::ostream & operator<<
1951	(std::ostream &o, const __gmp_expr<T, U> &expr)
1952	{
1953	__gmp_expr<T, T> const& temp(expr);
1954	return o << temp.__get_mp();
1955	}
1956
1957	template <class T>
1958	inline std::istream & operator>>(std::istream &i, __gmp_expr<T, T> &expr)
1959	{
1960	return i >> expr.__get_mp();
1961	}
1962
1963	/*
1964	// you might want to uncomment this
1965	inline std::istream & operator>>(std::istream &i, mpq_class &q)
1966	{
1967	i >> q.get_mpq_t();
1968	q.canonicalize();
1969	return i;
1970	}
1971	*/
1972
1973
1974	/**************** Functions for type conversion ****************/
1975
1976	inline void __gmp_set_expr(mpz_ptr z, const mpz_class &w)
1977	{
1978	mpz_set(z, w.get_mpz_t());
1979	}
1980
1981	template <class T>
1982	inline void __gmp_set_expr(mpz_ptr z, const __gmp_expr<mpz_t, T> &expr)
1983	{
1984	expr.eval(z);
1985	}
1986
1987	template <class T>
1988	inline void __gmp_set_expr(mpz_ptr z, const __gmp_expr<mpq_t, T> &expr)
1989	{
1990	mpq_class const& temp(expr);
1991	mpz_set_q(z, temp.get_mpq_t());
1992	}
1993
1994	template <class T>
1995	inline void __gmp_set_expr(mpz_ptr z, const __gmp_expr<mpf_t, T> &expr)
1996	{
1997	mpf_class const& temp(expr);
1998	mpz_set_f(z, temp.get_mpf_t());
1999	}
2000
2001	inline void __gmp_set_expr(mpq_ptr q, const mpz_class &z)
2002	{
2003	mpq_set_z(q, z.get_mpz_t());
2004	}
2005
2006	template <class T>
2007	inline void __gmp_set_expr(mpq_ptr q, const __gmp_expr<mpz_t, T> &expr)
2008	{
2009	__gmp_set_expr(mpq_numref(q), expr);
2010	mpz_set_ui(mpq_denref(q), 1);
2011	}
2012
2013	inline void __gmp_set_expr(mpq_ptr q, const mpq_class &r)
2014	{
2015	mpq_set(q, r.get_mpq_t());
2016	}
2017
2018	template <class T>
2019	inline void __gmp_set_expr(mpq_ptr q, const __gmp_expr<mpq_t, T> &expr)
2020	{
2021	expr.eval(q);
2022	}
2023
2024	template <class T>
2025	inline void __gmp_set_expr(mpq_ptr q, const __gmp_expr<mpf_t, T> &expr)
2026	{
2027	mpf_class const& temp(expr);
2028	mpq_set_f(q, temp.get_mpf_t());
2029	}
2030
2031	template <class T>
2032	inline void __gmp_set_expr(mpf_ptr f, const __gmp_expr<mpz_t, T> &expr)
2033	{
2034	mpz_class const& temp(expr);
2035	mpf_set_z(f, temp.get_mpz_t());
2036	}
2037
2038	template <class T>
2039	inline void __gmp_set_expr(mpf_ptr f, const __gmp_expr<mpq_t, T> &expr)
2040	{
2041	mpq_class const& temp(expr);
2042	mpf_set_q(f, temp.get_mpq_t());
2043	}
2044
2045	inline void __gmp_set_expr(mpf_ptr f, const mpf_class &g)
2046	{
2047	mpf_set(f, g.get_mpf_t());
2048	}
2049
2050	template <class T>
2051	inline void __gmp_set_expr(mpf_ptr f, const __gmp_expr<mpf_t, T> &expr)
2052	{
2053	expr.eval(f);
2054	}
2055
2056
2057	/* Temporary objects */
2058
2059	template <class T>
2060	class __gmp_temp
2061	{
2062	__gmp_expr<T, T> val;
2063	public:
2064	template<class U, class V>
2065	__gmp_temp(U const& u, V) : val (u) {}
2066	typename __gmp_resolve_expr<T>::srcptr_type
2067	__get_mp() const { return val.__get_mp(); }
2068	};
2069
2070	template <>
2071	class __gmp_temp <mpf_t>
2072	{
2073	mpf_class val;
2074	public:
2075	template<class U>
2076	__gmp_temp(U const& u, mpf_ptr res) : val (u, mpf_get_prec(res)) {}
2077	mpf_srcptr __get_mp() const { return val.__get_mp(); }
2078	};
2079
2080	/**************** Specializations of __gmp_expr ****************/
2081	/* The eval() method of __gmp_expr<T, U> evaluates the corresponding
2082	expression and assigns the result to its argument, which is either an
2083	mpz_t, mpq_t, or mpf_t as specified by the T argument.
2084	Compound expressions are evaluated recursively (temporaries are created
2085	to hold intermediate values), while for simple expressions the eval()
2086	method of the appropriate function object (available as the Op argument
2087	of either __gmp_unary_expr<T, Op> or __gmp_binary_expr<T, U, Op>) is
2088	called. */
2089
2090
2091	/**************** Unary expressions ****************/
2092	/* cases:
2093	- simple: argument is mp*_class, that is, __gmp_expr<T, T>
2094	- compound: argument is __gmp_expr<T, U> (with U not equal to T) */
2095
2096
2097	// simple expressions
2098
2099	template <class T, class Op>
2100	class __gmp_expr<T, __gmp_unary_expr<__gmp_expr<T, T>, Op> >
2101	{
2102	private:
2103	typedef __gmp_expr<T, T> val_type;
2104
2105	__gmp_unary_expr<val_type, Op> expr;
2106	public:
2107	explicit __gmp_expr(const val_type &val) : expr(val) { }
2108	void eval(typename __gmp_resolve_expr<T>::ptr_type p) const
2109	{ Op::eval(p, expr.val.__get_mp()); }
2110	const val_type & get_val() const { return expr.val; }
2111	mp_bitcnt_t get_prec() const { return expr.val.get_prec(); }
2112	};
2113
2114
2115	// compound expressions
2116
2117	template <class T, class U, class Op>
2118	class __gmp_expr<T, __gmp_unary_expr<__gmp_expr<T, U>, Op> >
2119	{
2120	private:
2121	typedef __gmp_expr<T, U> val_type;
2122
2123	__gmp_unary_expr<val_type, Op> expr;
2124	public:
2125	explicit __gmp_expr(const val_type &val) : expr(val) { }
2126	void eval(typename __gmp_resolve_expr<T>::ptr_type p) const
2127	{ expr.val.eval(p); Op::eval(p, p); }
2128	const val_type & get_val() const { return expr.val; }
2129	mp_bitcnt_t get_prec() const { return expr.val.get_prec(); }
2130	};
2131
2132
2133	/**************** Binary expressions ****************/
2134	/* simple:
2135	- arguments are both mp*_class
2136	- one argument is mp*_class, one is a built-in type
2137	compound:
2138	- one is mp*_class, one is __gmp_expr<T, U>
2139	- one is __gmp_expr<T, U>, one is built-in
2140	- both arguments are __gmp_expr<...> */
2141
2142
2143	// simple expressions
2144
2145	template <class T, class Op>
2146	class __gmp_expr
2147	<T, __gmp_binary_expr<__gmp_expr<T, T>, __gmp_expr<T, T>, Op> >
2148	{
2149	private:
2150	typedef __gmp_expr<T, T> val1_type;
2151	typedef __gmp_expr<T, T> val2_type;
2152
2153	__gmp_binary_expr<val1_type, val2_type, Op> expr;
2154	public:
2155	__gmp_expr(const val1_type &val1, const val2_type &val2)
2156	: expr(val1, val2) { }
2157	void eval(typename __gmp_resolve_expr<T>::ptr_type p) const
2158	{ Op::eval(p, expr.val1.__get_mp(), expr.val2.__get_mp()); }
2159	const val1_type & get_val1() const { return expr.val1; }
2160	const val2_type & get_val2() const { return expr.val2; }
2161	mp_bitcnt_t get_prec() const
2162	{
2163	mp_bitcnt_t prec1 = expr.val1.get_prec(),
2164	prec2 = expr.val2.get_prec();
2165	return (prec1 > prec2) ? prec1 : prec2;
2166	}
2167	};
2168
2169
2170	// simple expressions, T is a built-in numerical type
2171
2172	template <class T, class U, class Op>
2173	class __gmp_expr<T, __gmp_binary_expr<__gmp_expr<T, T>, U, Op> >
2174	{
2175	private:
2176	typedef __gmp_expr<T, T> val1_type;
2177	typedef U val2_type;
2178
2179	__gmp_binary_expr<val1_type, val2_type, Op> expr;
2180	public:
2181	__gmp_expr(const val1_type &val1, const val2_type &val2)
2182	: expr(val1, val2) { }
2183	void eval(typename __gmp_resolve_expr<T>::ptr_type p) const
2184	{ Op::eval(p, expr.val1.__get_mp(), expr.val2); }
2185	const val1_type & get_val1() const { return expr.val1; }
2186	const val2_type & get_val2() const { return expr.val2; }
2187	mp_bitcnt_t get_prec() const { return expr.val1.get_prec(); }
2188	};
2189
2190	template <class T, class U, class Op>
2191	class __gmp_expr<T, __gmp_binary_expr<U, __gmp_expr<T, T>, Op> >
2192	{
2193	private:
2194	typedef U val1_type;
2195	typedef __gmp_expr<T, T> val2_type;
2196
2197	__gmp_binary_expr<val1_type, val2_type, Op> expr;
2198	public:
2199	__gmp_expr(const val1_type &val1, const val2_type &val2)
2200	: expr(val1, val2) { }
2201	void eval(typename __gmp_resolve_expr<T>::ptr_type p) const
2202	{ Op::eval(p, expr.val1, expr.val2.__get_mp()); }
2203	const val1_type & get_val1() const { return expr.val1; }
2204	const val2_type & get_val2() const { return expr.val2; }
2205	mp_bitcnt_t get_prec() const { return expr.val2.get_prec(); }
2206	};
2207
2208
2209	// compound expressions, one argument is a subexpression
2210
2211	template <class T, class U, class V, class Op>
2212	class __gmp_expr
2213	<T, __gmp_binary_expr<__gmp_expr<T, T>, __gmp_expr<U, V>, Op> >
2214	{
2215	private:
2216	typedef __gmp_expr<T, T> val1_type;
2217	typedef __gmp_expr<U, V> val2_type;
2218
2219	__gmp_binary_expr<val1_type, val2_type, Op> expr;
2220	public:
2221	__gmp_expr(const val1_type &val1, const val2_type &val2)
2222	: expr(val1, val2) { }
2223	void eval(typename __gmp_resolve_expr<T>::ptr_type p) const
2224	{
2225	if(p != expr.val1.__get_mp())
2226	{
2227	__gmp_set_expr(p, expr.val2);
2228	Op::eval(p, expr.val1.__get_mp(), p);
2229	}
2230	else
2231	{
2232	__gmp_temp<T> temp(expr.val2, p);
2233	Op::eval(p, expr.val1.__get_mp(), temp.__get_mp());
2234	}
2235	}
2236	const val1_type & get_val1() const { return expr.val1; }
2237	const val2_type & get_val2() const { return expr.val2; }
2238	mp_bitcnt_t get_prec() const
2239	{
2240	mp_bitcnt_t prec1 = expr.val1.get_prec(),
2241	prec2 = expr.val2.get_prec();
2242	return (prec1 > prec2) ? prec1 : prec2;
2243	}
2244	};
2245
2246	template <class T, class U, class V, class Op>
2247	class __gmp_expr
2248	<T, __gmp_binary_expr<__gmp_expr<U, V>, __gmp_expr<T, T>, Op> >
2249	{
2250	private:
2251	typedef __gmp_expr<U, V> val1_type;
2252	typedef __gmp_expr<T, T> val2_type;
2253
2254	__gmp_binary_expr<val1_type, val2_type, Op> expr;
2255	public:
2256	__gmp_expr(const val1_type &val1, const val2_type &val2)
2257	: expr(val1, val2) { }
2258	void eval(typename __gmp_resolve_expr<T>::ptr_type p) const
2259	{
2260	if(p != expr.val2.__get_mp())
2261	{
2262	__gmp_set_expr(p, expr.val1);
2263	Op::eval(p, p, expr.val2.__get_mp());
2264	}
2265	else
2266	{
2267	__gmp_temp<T> temp(expr.val1, p);
2268	Op::eval(p, temp.__get_mp(), expr.val2.__get_mp());
2269	}
2270	}
2271	const val1_type & get_val1() const { return expr.val1; }
2272	const val2_type & get_val2() const { return expr.val2; }
2273	mp_bitcnt_t get_prec() const
2274	{
2275	mp_bitcnt_t prec1 = expr.val1.get_prec(),
2276	prec2 = expr.val2.get_prec();
2277	return (prec1 > prec2) ? prec1 : prec2;
2278	}
2279	};
2280
2281	template <class T, class U, class Op>
2282	class __gmp_expr
2283	<T, __gmp_binary_expr<__gmp_expr<T, T>, __gmp_expr<T, U>, Op> >
2284	{
2285	private:
2286	typedef __gmp_expr<T, T> val1_type;
2287	typedef __gmp_expr<T, U> val2_type;
2288
2289	__gmp_binary_expr<val1_type, val2_type, Op> expr;
2290	public:
2291	__gmp_expr(const val1_type &val1, const val2_type &val2)
2292	: expr(val1, val2) { }
2293	void eval(typename __gmp_resolve_expr<T>::ptr_type p) const
2294	{
2295	if(p != expr.val1.__get_mp())
2296	{
2297	__gmp_set_expr(p, expr.val2);
2298	Op::eval(p, expr.val1.__get_mp(), p);
2299	}
2300	else
2301	{
2302	__gmp_temp<T> temp(expr.val2, p);
2303	Op::eval(p, expr.val1.__get_mp(), temp.__get_mp());
2304	}
2305	}
2306	const val1_type & get_val1() const { return expr.val1; }
2307	const val2_type & get_val2() const { return expr.val2; }
2308	mp_bitcnt_t get_prec() const
2309	{
2310	mp_bitcnt_t prec1 = expr.val1.get_prec(),
2311	prec2 = expr.val2.get_prec();
2312	return (prec1 > prec2) ? prec1 : prec2;
2313	}
2314	};
2315
2316	template <class T, class U, class Op>
2317	class __gmp_expr
2318	<T, __gmp_binary_expr<__gmp_expr<T, U>, __gmp_expr<T, T>, Op> >
2319	{
2320	private:
2321	typedef __gmp_expr<T, U> val1_type;
2322	typedef __gmp_expr<T, T> val2_type;
2323
2324	__gmp_binary_expr<val1_type, val2_type, Op> expr;
2325	public:
2326	__gmp_expr(const val1_type &val1, const val2_type &val2)
2327	: expr(val1, val2) { }
2328	void eval(typename __gmp_resolve_expr<T>::ptr_type p) const
2329	{
2330	if(p != expr.val2.__get_mp())
2331	{
2332	__gmp_set_expr(p, expr.val1);
2333	Op::eval(p, p, expr.val2.__get_mp());
2334	}
2335	else
2336	{
2337	__gmp_temp<T> temp(expr.val1, p);
2338	Op::eval(p, temp.__get_mp(), expr.val2.__get_mp());
2339	}
2340	}
2341	const val1_type & get_val1() const { return expr.val1; }
2342	const val2_type & get_val2() const { return expr.val2; }
2343	mp_bitcnt_t get_prec() const
2344	{
2345	mp_bitcnt_t prec1 = expr.val1.get_prec(),
2346	prec2 = expr.val2.get_prec();
2347	return (prec1 > prec2) ? prec1 : prec2;
2348	}
2349	};
2350
2351
2352	// one argument is a subexpression, one is a built-in
2353
2354	template <class T, class U, class V, class Op>
2355	class __gmp_expr<T, __gmp_binary_expr<__gmp_expr<T, U>, V, Op> >
2356	{
2357	private:
2358	typedef __gmp_expr<T, U> val1_type;
2359	typedef V val2_type;
2360
2361	__gmp_binary_expr<val1_type, val2_type, Op> expr;
2362	public:
2363	__gmp_expr(const val1_type &val1, const val2_type &val2)
2364	: expr(val1, val2) { }
2365	void eval(typename __gmp_resolve_expr<T>::ptr_type p) const
2366	{
2367	expr.val1.eval(p);
2368	Op::eval(p, p, expr.val2);
2369	}
2370	const val1_type & get_val1() const { return expr.val1; }
2371	const val2_type & get_val2() const { return expr.val2; }
2372	mp_bitcnt_t get_prec() const { return expr.val1.get_prec(); }
2373	};
2374
2375	template <class T, class U, class V, class Op>
2376	class __gmp_expr<T, __gmp_binary_expr<U, __gmp_expr<T, V>, Op> >
2377	{
2378	private:
2379	typedef U val1_type;
2380	typedef __gmp_expr<T, V> val2_type;
2381
2382	__gmp_binary_expr<val1_type, val2_type, Op> expr;
2383	public:
2384	__gmp_expr(const val1_type &val1, const val2_type &val2)
2385	: expr(val1, val2) { }
2386	void eval(typename __gmp_resolve_expr<T>::ptr_type p) const
2387	{
2388	expr.val2.eval(p);
2389	Op::eval(p, expr.val1, p);
2390	}
2391	const val1_type & get_val1() const { return expr.val1; }
2392	const val2_type & get_val2() const { return expr.val2; }
2393	mp_bitcnt_t get_prec() const { return expr.val2.get_prec(); }
2394	};
2395
2396
2397	// both arguments are subexpressions
2398
2399	template <class T, class U, class V, class W, class Op>
2400	class __gmp_expr
2401	<T, __gmp_binary_expr<__gmp_expr<T, U>, __gmp_expr<V, W>, Op> >
2402	{
2403	private:
2404	typedef __gmp_expr<T, U> val1_type;
2405	typedef __gmp_expr<V, W> val2_type;
2406
2407	__gmp_binary_expr<val1_type, val2_type, Op> expr;
2408	public:
2409	__gmp_expr(const val1_type &val1, const val2_type &val2)
2410	: expr(val1, val2) { }
2411	void eval(typename __gmp_resolve_expr<T>::ptr_type p) const
2412	{
2413	__gmp_temp<T> temp2(expr.val2, p);
2414	expr.val1.eval(p);
2415	Op::eval(p, p, temp2.__get_mp());
2416	}
2417	const val1_type & get_val1() const { return expr.val1; }
2418	const val2_type & get_val2() const { return expr.val2; }
2419	mp_bitcnt_t get_prec() const
2420	{
2421	mp_bitcnt_t prec1 = expr.val1.get_prec(),
2422	prec2 = expr.val2.get_prec();
2423	return (prec1 > prec2) ? prec1 : prec2;
2424	}
2425	};
2426
2427	template <class T, class U, class V, class W, class Op>
2428	class __gmp_expr
2429	<T, __gmp_binary_expr<__gmp_expr<U, V>, __gmp_expr<T, W>, Op> >
2430	{
2431	private:
2432	typedef __gmp_expr<U, V> val1_type;
2433	typedef __gmp_expr<T, W> val2_type;
2434
2435	__gmp_binary_expr<val1_type, val2_type, Op> expr;
2436	public:
2437	__gmp_expr(const val1_type &val1, const val2_type &val2)
2438	: expr(val1, val2) { }
2439	void eval(typename __gmp_resolve_expr<T>::ptr_type p) const
2440	{
2441	__gmp_temp<T> temp1(expr.val1, p);
2442	expr.val2.eval(p);
2443	Op::eval(p, temp1.__get_mp(), p);
2444	}
2445	const val1_type & get_val1() const { return expr.val1; }
2446	const val2_type & get_val2() const { return expr.val2; }
2447	mp_bitcnt_t get_prec() const
2448	{
2449	mp_bitcnt_t prec1 = expr.val1.get_prec(),
2450	prec2 = expr.val2.get_prec();
2451	return (prec1 > prec2) ? prec1 : prec2;
2452	}
2453	};
2454
2455	template <class T, class U, class V, class Op>
2456	class __gmp_expr
2457	<T, __gmp_binary_expr<__gmp_expr<T, U>, __gmp_expr<T, V>, Op> >
2458	{
2459	private:
2460	typedef __gmp_expr<T, U> val1_type;
2461	typedef __gmp_expr<T, V> val2_type;
2462
2463	__gmp_binary_expr<val1_type, val2_type, Op> expr;
2464	public:
2465	__gmp_expr(const val1_type &val1, const val2_type &val2)
2466	: expr(val1, val2) { }
2467	void eval(typename __gmp_resolve_expr<T>::ptr_type p) const
2468	{
2469	__gmp_temp<T> temp2(expr.val2, p);
2470	expr.val1.eval(p);
2471	Op::eval(p, p, temp2.__get_mp());
2472	}
2473	const val1_type & get_val1() const { return expr.val1; }
2474	const val2_type & get_val2() const { return expr.val2; }
2475	mp_bitcnt_t get_prec() const
2476	{
2477	mp_bitcnt_t prec1 = expr.val1.get_prec(),
2478	prec2 = expr.val2.get_prec();
2479	return (prec1 > prec2) ? prec1 : prec2;
2480	}
2481	};
2482
2483
2484	/**************** Special cases ****************/
2485
2486	/* Some operations (i.e., add and subtract) with mixed mpz/mpq arguments
2487	can be done directly without first converting the mpz to mpq.
2488	Appropriate specializations of __gmp_expr are required. */
2489
2490
2491	#define __GMPZQ_DEFINE_EXPR(eval_fun) \
2492	\
2493	template <> \
2494	class __gmp_expr<mpq_t, __gmp_binary_expr<mpz_class, mpq_class, eval_fun> > \
2495	{ \
2496	private: \
2497	typedef mpz_class val1_type; \
2498	typedef mpq_class val2_type; \
2499	\
2500	__gmp_binary_expr<val1_type, val2_type, eval_fun> expr; \
2501	public: \
2502	__gmp_expr(const val1_type &val1, const val2_type &val2) \
2503	: expr(val1, val2) { } \
2504	void eval(mpq_ptr q) const \
2505	{ eval_fun::eval(q, expr.val1.get_mpz_t(), expr.val2.get_mpq_t()); } \
2506	const val1_type & get_val1() const { return expr.val1; } \
2507	const val2_type & get_val2() const { return expr.val2; } \
2508	mp_bitcnt_t get_prec() const { return mpf_get_default_prec(); } \
2509	}; \
2510	\
2511	template <> \
2512	class __gmp_expr<mpq_t, __gmp_binary_expr<mpq_class, mpz_class, eval_fun> > \
2513	{ \
2514	private: \
2515	typedef mpq_class val1_type; \
2516	typedef mpz_class val2_type; \
2517	\
2518	__gmp_binary_expr<val1_type, val2_type, eval_fun> expr; \
2519	public: \
2520	__gmp_expr(const val1_type &val1, const val2_type &val2) \
2521	: expr(val1, val2) { } \
2522	void eval(mpq_ptr q) const \
2523	{ eval_fun::eval(q, expr.val1.get_mpq_t(), expr.val2.get_mpz_t()); } \
2524	const val1_type & get_val1() const { return expr.val1; } \
2525	const val2_type & get_val2() const { return expr.val2; } \
2526	mp_bitcnt_t get_prec() const { return mpf_get_default_prec(); } \
2527	}; \
2528	\
2529	template <class T> \
2530	class __gmp_expr \
2531	<mpq_t, __gmp_binary_expr<mpz_class, __gmp_expr<mpq_t, T>, eval_fun> > \
2532	{ \
2533	private: \
2534	typedef mpz_class val1_type; \
2535	typedef __gmp_expr<mpq_t, T> val2_type; \
2536	\
2537	__gmp_binary_expr<val1_type, val2_type, eval_fun> expr; \
2538	public: \
2539	__gmp_expr(const val1_type &val1, const val2_type &val2) \
2540	: expr(val1, val2) { } \
2541	void eval(mpq_ptr q) const \
2542	{ \
2543	mpq_class temp(expr.val2); \
2544	eval_fun::eval(q, expr.val1.get_mpz_t(), temp.get_mpq_t()); \
2545	} \
2546	const val1_type & get_val1() const { return expr.val1; } \
2547	const val2_type & get_val2() const { return expr.val2; } \
2548	mp_bitcnt_t get_prec() const { return mpf_get_default_prec(); } \
2549	}; \
2550	\
2551	template <class T> \
2552	class __gmp_expr \
2553	<mpq_t, __gmp_binary_expr<mpq_class, __gmp_expr<mpz_t, T>, eval_fun> > \
2554	{ \
2555	private: \
2556	typedef mpq_class val1_type; \
2557	typedef __gmp_expr<mpz_t, T> val2_type; \
2558	\
2559	__gmp_binary_expr<val1_type, val2_type, eval_fun> expr; \
2560	public: \
2561	__gmp_expr(const val1_type &val1, const val2_type &val2) \
2562	: expr(val1, val2) { } \
2563	void eval(mpq_ptr q) const \
2564	{ \
2565	mpz_class temp(expr.val2); \
2566	eval_fun::eval(q, expr.val1.get_mpq_t(), temp.get_mpz_t()); \
2567	} \
2568	const val1_type & get_val1() const { return expr.val1; } \
2569	const val2_type & get_val2() const { return expr.val2; } \
2570	mp_bitcnt_t get_prec() const { return mpf_get_default_prec(); } \
2571	}; \
2572	\
2573	template <class T> \
2574	class __gmp_expr \
2575	<mpq_t, __gmp_binary_expr<__gmp_expr<mpz_t, T>, mpq_class, eval_fun> > \
2576	{ \
2577	private: \
2578	typedef __gmp_expr<mpz_t, T> val1_type; \
2579	typedef mpq_class val2_type; \
2580	\
2581	__gmp_binary_expr<val1_type, val2_type, eval_fun> expr; \
2582	public: \
2583	__gmp_expr(const val1_type &val1, const val2_type &val2) \
2584	: expr(val1, val2) { } \
2585	void eval(mpq_ptr q) const \
2586	{ \
2587	mpz_class temp(expr.val1); \
2588	eval_fun::eval(q, temp.get_mpz_t(), expr.val2.get_mpq_t()); \
2589	} \
2590	const val1_type & get_val1() const { return expr.val1; } \
2591	const val2_type & get_val2() const { return expr.val2; } \
2592	mp_bitcnt_t get_prec() const { return mpf_get_default_prec(); } \
2593	}; \
2594	\
2595	template <class T> \
2596	class __gmp_expr \
2597	<mpq_t, __gmp_binary_expr<__gmp_expr<mpq_t, T>, mpz_class, eval_fun> > \
2598	{ \
2599	private: \
2600	typedef __gmp_expr<mpq_t, T> val1_type; \
2601	typedef mpz_class val2_type; \
2602	\
2603	__gmp_binary_expr<val1_type, val2_type, eval_fun> expr; \
2604	public: \
2605	__gmp_expr(const val1_type &val1, const val2_type &val2) \
2606	: expr(val1, val2) { } \
2607	void eval(mpq_ptr q) const \
2608	{ \
2609	mpq_class temp(expr.val1); \
2610	eval_fun::eval(q, temp.get_mpq_t(), expr.val2.get_mpz_t()); \
2611	} \
2612	const val1_type & get_val1() const { return expr.val1; } \
2613	const val2_type & get_val2() const { return expr.val2; } \
2614	mp_bitcnt_t get_prec() const { return mpf_get_default_prec(); } \
2615	}; \
2616	\
2617	template <class T, class U> \
2618	class __gmp_expr<mpq_t, __gmp_binary_expr \
2619	<__gmp_expr<mpz_t, T>, __gmp_expr<mpq_t, U>, eval_fun> > \
2620	{ \
2621	private: \
2622	typedef __gmp_expr<mpz_t, T> val1_type; \
2623	typedef __gmp_expr<mpq_t, U> val2_type; \
2624	\
2625	__gmp_binary_expr<val1_type, val2_type, eval_fun> expr; \
2626	public: \
2627	__gmp_expr(const val1_type &val1, const val2_type &val2) \
2628	: expr(val1, val2) { } \
2629	void eval(mpq_ptr q) const \
2630	{ \
2631	mpz_class temp1(expr.val1); \
2632	expr.val2.eval(q); \
2633	eval_fun::eval(q, temp1.get_mpz_t(), q); \
2634	} \
2635	const val1_type & get_val1() const { return expr.val1; } \
2636	const val2_type & get_val2() const { return expr.val2; } \
2637	mp_bitcnt_t get_prec() const { return mpf_get_default_prec(); } \
2638	}; \
2639	\
2640	template <class T, class U> \
2641	class __gmp_expr<mpq_t, __gmp_binary_expr \
2642	<__gmp_expr<mpq_t, T>, __gmp_expr<mpz_t, U>, eval_fun> > \
2643	{ \
2644	private: \
2645	typedef __gmp_expr<mpq_t, T> val1_type; \
2646	typedef __gmp_expr<mpz_t, U> val2_type; \
2647	\
2648	__gmp_binary_expr<val1_type, val2_type, eval_fun> expr; \
2649	public: \
2650	__gmp_expr(const val1_type &val1, const val2_type &val2) \
2651	: expr(val1, val2) { } \
2652	void eval(mpq_ptr q) const \
2653	{ \
2654	mpz_class temp2(expr.val2); \
2655	expr.val1.eval(q); \
2656	eval_fun::eval(q, q, temp2.get_mpz_t()); \
2657	} \
2658	const val1_type & get_val1() const { return expr.val1; } \
2659	const val2_type & get_val2() const { return expr.val2; } \
2660	mp_bitcnt_t get_prec() const { return mpf_get_default_prec(); } \
2661	};
2662
2663
2664	__GMPZQ_DEFINE_EXPR(__gmp_binary_plus)
2665	__GMPZQ_DEFINE_EXPR(__gmp_binary_minus)
2666
2667
2668
2669	/**************** Macros for defining functions ****************/
2670	/* Results of operators and functions are instances of __gmp_expr<T, U>.
2671	T determines the numerical type of the expression: it can be either
2672	mpz_t, mpq_t, or mpf_t. When the arguments of a binary
2673	expression have different numerical types, __gmp_resolve_expr is used
2674	to determine the "larger" type.
2675	U is either __gmp_unary_expr<V, Op> or __gmp_binary_expr<V, W, Op>,
2676	where V and W are the arguments' types -- they can in turn be
2677	expressions, thus allowing to build compound expressions to any
2678	degree of complexity.
2679	Op is a function object that must have an eval() method accepting
2680	appropriate arguments.
2681	Actual evaluation of a __gmp_expr<T, U> object is done when it gets
2682	assigned to an mp*_class ("lazy" evaluation): this is done by calling
2683	its eval() method. */
2684
2685
2686	// non-member unary operators and functions
2687
2688	#define __GMP_DEFINE_UNARY_FUNCTION(fun, eval_fun) \
2689	\
2690	template <class T, class U> \
2691	inline __gmp_expr<T, __gmp_unary_expr<__gmp_expr<T, U>, eval_fun> > \
2692	fun(const __gmp_expr<T, U> &expr) \
2693	{ \
2694	return __gmp_expr<T, __gmp_unary_expr<__gmp_expr<T, U>, eval_fun> >(expr); \
2695	}
2696
2697	#define __GMP_DEFINE_UNARY_TYPE_FUNCTION(type, fun, eval_fun) \
2698	\
2699	template <class T, class U> \
2700	inline type fun(const __gmp_expr<T, U> &expr) \
2701	{ \
2702	__gmp_expr<T, T> const& temp(expr); \
2703	return eval_fun::eval(temp.__get_mp()); \
2704	}
2705
2706
2707	// non-member binary operators and functions
2708
2709	#define __GMPP_DEFINE_BINARY_FUNCTION(fun, eval_fun) \
2710	\
2711	template <class T, class U, class V, class W> \
2712	inline __gmp_expr<typename __gmp_resolve_expr<T, V>::value_type, \
2713	__gmp_binary_expr<__gmp_expr<T, U>, __gmp_expr<V, W>, eval_fun> > \
2714	fun(const __gmp_expr<T, U> &expr1, const __gmp_expr<V, W> &expr2) \
2715	{ \
2716	return __gmp_expr<typename __gmp_resolve_expr<T, V>::value_type, \
2717	__gmp_binary_expr<__gmp_expr<T, U>, __gmp_expr<V, W>, eval_fun> > \
2718	(expr1, expr2); \
2719	}
2720
2721	#define __GMPNN_DEFINE_BINARY_FUNCTION(fun, eval_fun, type, bigtype) \
2722	\
2723	template <class T, class U> \
2724	inline __gmp_expr \
2725	<T, __gmp_binary_expr<__gmp_expr<T, U>, bigtype, eval_fun> > \
2726	fun(const __gmp_expr<T, U> &expr, type t) \
2727	{ \
2728	return __gmp_expr \
2729	<T, __gmp_binary_expr<__gmp_expr<T, U>, bigtype, eval_fun> >(expr, t); \
2730	} \
2731	\
2732	template <class T, class U> \
2733	inline __gmp_expr \
2734	<T, __gmp_binary_expr<bigtype, __gmp_expr<T, U>, eval_fun> > \
2735	fun(type t, const __gmp_expr<T, U> &expr) \
2736	{ \
2737	return __gmp_expr \
2738	<T, __gmp_binary_expr<bigtype, __gmp_expr<T, U>, eval_fun> >(t, expr); \
2739	}
2740
2741	#define __GMPNS_DEFINE_BINARY_FUNCTION(fun, eval_fun, type) \
2742	__GMPNN_DEFINE_BINARY_FUNCTION(fun, eval_fun, type, signed long int)
2743
2744	#define __GMPNU_DEFINE_BINARY_FUNCTION(fun, eval_fun, type) \
2745	__GMPNN_DEFINE_BINARY_FUNCTION(fun, eval_fun, type, unsigned long int)
2746
2747	#define __GMPND_DEFINE_BINARY_FUNCTION(fun, eval_fun, type) \
2748	__GMPNN_DEFINE_BINARY_FUNCTION(fun, eval_fun, type, double)
2749
2750	#define __GMPNLD_DEFINE_BINARY_FUNCTION(fun, eval_fun, type) \
2751	__GMPNN_DEFINE_BINARY_FUNCTION(fun, eval_fun, type, long double)
2752
2753	#define __GMPN_DEFINE_BINARY_FUNCTION(fun, eval_fun) \
2754	__GMPNS_DEFINE_BINARY_FUNCTION(fun, eval_fun, signed char) \
2755	__GMPNU_DEFINE_BINARY_FUNCTION(fun, eval_fun, unsigned char) \
2756	__GMPNS_DEFINE_BINARY_FUNCTION(fun, eval_fun, signed int) \
2757	__GMPNU_DEFINE_BINARY_FUNCTION(fun, eval_fun, unsigned int) \
2758	__GMPNS_DEFINE_BINARY_FUNCTION(fun, eval_fun, signed short int) \
2759	__GMPNU_DEFINE_BINARY_FUNCTION(fun, eval_fun, unsigned short int) \
2760	__GMPNS_DEFINE_BINARY_FUNCTION(fun, eval_fun, signed long int) \
2761	__GMPNU_DEFINE_BINARY_FUNCTION(fun, eval_fun, unsigned long int) \
2762	__GMPND_DEFINE_BINARY_FUNCTION(fun, eval_fun, float) \
2763	__GMPND_DEFINE_BINARY_FUNCTION(fun, eval_fun, double) \
2764	/* __GMPNLD_DEFINE_BINARY_FUNCTION(fun, eval_fun, long double) */
2765
2766	#define __GMP_DEFINE_BINARY_FUNCTION(fun, eval_fun) \
2767	__GMPP_DEFINE_BINARY_FUNCTION(fun, eval_fun) \
2768	__GMPN_DEFINE_BINARY_FUNCTION(fun, eval_fun)
2769
2770
2771	#define __GMP_DEFINE_BINARY_FUNCTION_UI(fun, eval_fun) \
2772	\
2773	template <class T, class U> \
2774	inline __gmp_expr \
2775	<T, __gmp_binary_expr<__gmp_expr<T, U>, mp_bitcnt_t, eval_fun> > \
2776	fun(const __gmp_expr<T, U> &expr, mp_bitcnt_t l) \
2777	{ \
2778	return __gmp_expr<T, __gmp_binary_expr \
2779	<__gmp_expr<T, U>, mp_bitcnt_t, eval_fun> >(expr, l); \
2780	}
2781
2782
2783	#define __GMPP_DEFINE_BINARY_TYPE_FUNCTION(type, fun, eval_fun) \
2784	\
2785	template <class T, class U, class V, class W> \
2786	inline type fun(const __gmp_expr<T, U> &expr1, \
2787	const __gmp_expr<V, W> &expr2) \
2788	{ \
2789	typedef typename __gmp_resolve_expr<T, V>::value_type eval_type; \
2790	__gmp_expr<eval_type, eval_type> const& temp1(expr1); \
2791	__gmp_expr<eval_type, eval_type> const& temp2(expr2); \
2792	return eval_fun::eval(temp1.__get_mp(), temp2.__get_mp()); \
2793	}
2794
2795	#define __GMPNN_DEFINE_BINARY_TYPE_FUNCTION(type, fun, eval_fun, \
2796	type2, bigtype) \
2797	\
2798	template <class T, class U> \
2799	inline type fun(const __gmp_expr<T, U> &expr, type2 t) \
2800	{ \
2801	__gmp_expr<T, T> const& temp(expr); \
2802	return eval_fun::eval(temp.__get_mp(), static_cast<bigtype>(t)); \
2803	} \
2804	\
2805	template <class T, class U> \
2806	inline type fun(type2 t, const __gmp_expr<T, U> &expr) \
2807	{ \
2808	__gmp_expr<T, T> const& temp(expr); \
2809	return eval_fun::eval(static_cast<bigtype>(t), temp.__get_mp()); \
2810	}
2811
2812	#define __GMPNS_DEFINE_BINARY_TYPE_FUNCTION(type, fun, eval_fun, type2) \
2813	__GMPNN_DEFINE_BINARY_TYPE_FUNCTION(type, fun, eval_fun, \
2814	type2, signed long int)
2815
2816	#define __GMPNU_DEFINE_BINARY_TYPE_FUNCTION(type, fun, eval_fun, type2) \
2817	__GMPNN_DEFINE_BINARY_TYPE_FUNCTION(type, fun, eval_fun, \
2818	type2, unsigned long int)
2819
2820	#define __GMPND_DEFINE_BINARY_TYPE_FUNCTION(type, fun, eval_fun, type2) \
2821	__GMPNN_DEFINE_BINARY_TYPE_FUNCTION(type, fun, eval_fun, type2, double)
2822
2823	#define __GMPNLD_DEFINE_BINARY_TYPE_FUNCTION(type, fun, eval_fun, type2) \
2824	__GMPNN_DEFINE_BINARY_TYPE_FUNCTION(type, fun, eval_fun, type2, long double)
2825
2826	#define __GMPN_DEFINE_BINARY_TYPE_FUNCTION(type, fun, eval_fun) \
2827	__GMPNS_DEFINE_BINARY_TYPE_FUNCTION(type, fun, eval_fun, signed char) \
2828	__GMPNU_DEFINE_BINARY_TYPE_FUNCTION(type, fun, eval_fun, unsigned char) \
2829	__GMPNS_DEFINE_BINARY_TYPE_FUNCTION(type, fun, eval_fun, signed int) \
2830	__GMPNU_DEFINE_BINARY_TYPE_FUNCTION(type, fun, eval_fun, unsigned int) \
2831	__GMPNS_DEFINE_BINARY_TYPE_FUNCTION(type, fun, eval_fun, signed short int) \
2832	__GMPNU_DEFINE_BINARY_TYPE_FUNCTION(type, fun, eval_fun, unsigned short int) \
2833	__GMPNS_DEFINE_BINARY_TYPE_FUNCTION(type, fun, eval_fun, signed long int) \
2834	__GMPNU_DEFINE_BINARY_TYPE_FUNCTION(type, fun, eval_fun, unsigned long int) \
2835	__GMPND_DEFINE_BINARY_TYPE_FUNCTION(type, fun, eval_fun, float) \
2836	__GMPND_DEFINE_BINARY_TYPE_FUNCTION(type, fun, eval_fun, double) \
2837	/* __GMPNLD_DEFINE_BINARY_TYPE_FUNCTION(type, fun, eval_fun, long double) */
2838
2839	#define __GMP_DEFINE_BINARY_TYPE_FUNCTION(type, fun, eval_fun) \
2840	__GMPP_DEFINE_BINARY_TYPE_FUNCTION(type, fun, eval_fun) \
2841	__GMPN_DEFINE_BINARY_TYPE_FUNCTION(type, fun, eval_fun)
2842
2843
2844	// member operators
2845
2846	#define __GMPP_DEFINE_COMPOUND_OPERATOR(type, fun, eval_fun) \
2847	\
2848	template <class T, class U> \
2849	inline type##_class & type##_class::fun(const __gmp_expr<T, U> &expr) \
2850	{ \
2851	__gmp_set_expr(mp, __gmp_expr<type##_t, __gmp_binary_expr \
2852	<type##_class, __gmp_expr<T, U>, eval_fun> >(*this, expr)); \
2853	return *this; \
2854	}
2855
2856	#define __GMPNN_DEFINE_COMPOUND_OPERATOR(type, fun, eval_fun, \
2857	type2, bigtype) \
2858	\
2859	inline type##_class & type##_class::fun(type2 t) \
2860	{ \
2861	__gmp_set_expr(mp, __gmp_expr<type##_t, __gmp_binary_expr \
2862	<type##_class, bigtype, eval_fun> >(*this, t)); \
2863	return *this; \
2864	}
2865
2866	#define __GMPNS_DEFINE_COMPOUND_OPERATOR(type, fun, eval_fun, type2) \
2867	__GMPNN_DEFINE_COMPOUND_OPERATOR(type, fun, eval_fun, \
2868	type2, signed long int)
2869
2870	#define __GMPNU_DEFINE_COMPOUND_OPERATOR(type, fun, eval_fun, type2) \
2871	__GMPNN_DEFINE_COMPOUND_OPERATOR(type, fun, eval_fun, \
2872	type2, unsigned long int)
2873
2874	#define __GMPND_DEFINE_COMPOUND_OPERATOR(type, fun, eval_fun, type2) \
2875	__GMPNN_DEFINE_COMPOUND_OPERATOR(type, fun, eval_fun, type2, double)
2876
2877	#define __GMPNLD_DEFINE_COMPOUND_OPERATOR(type, fun, eval_fun, type2) \
2878	__GMPNN_DEFINE_COMPOUND_OPERATOR(type, fun, eval_fun, type2, long double)
2879
2880	#define __GMPN_DEFINE_COMPOUND_OPERATOR(type, fun, eval_fun) \
2881	__GMPNS_DEFINE_COMPOUND_OPERATOR(type, fun, eval_fun, signed char) \
2882	__GMPNU_DEFINE_COMPOUND_OPERATOR(type, fun, eval_fun, unsigned char) \
2883	__GMPNS_DEFINE_COMPOUND_OPERATOR(type, fun, eval_fun, signed int) \
2884	__GMPNU_DEFINE_COMPOUND_OPERATOR(type, fun, eval_fun, unsigned int) \
2885	__GMPNS_DEFINE_COMPOUND_OPERATOR(type, fun, eval_fun, signed short int) \
2886	__GMPNU_DEFINE_COMPOUND_OPERATOR(type, fun, eval_fun, unsigned short int) \
2887	__GMPNS_DEFINE_COMPOUND_OPERATOR(type, fun, eval_fun, signed long int) \
2888	__GMPNU_DEFINE_COMPOUND_OPERATOR(type, fun, eval_fun, unsigned long int) \
2889	__GMPND_DEFINE_COMPOUND_OPERATOR(type, fun, eval_fun, float) \
2890	__GMPND_DEFINE_COMPOUND_OPERATOR(type, fun, eval_fun, double) \
2891	/* __GMPNLD_DEFINE_COMPOUND_OPERATOR(type, fun, eval_fun, long double) */
2892
2893	#define __GMP_DEFINE_COMPOUND_OPERATOR(type, fun, eval_fun) \
2894	__GMPP_DEFINE_COMPOUND_OPERATOR(type, fun, eval_fun) \
2895	__GMPN_DEFINE_COMPOUND_OPERATOR(type, fun, eval_fun)
2896
2897	#define __GMPZ_DEFINE_COMPOUND_OPERATOR(fun, eval_fun) \
2898	__GMP_DEFINE_COMPOUND_OPERATOR(mpz, fun, eval_fun)
2899
2900	#define __GMPQ_DEFINE_COMPOUND_OPERATOR(fun, eval_fun) \
2901	__GMP_DEFINE_COMPOUND_OPERATOR(mpq, fun, eval_fun)
2902
2903	#define __GMPF_DEFINE_COMPOUND_OPERATOR(fun, eval_fun) \
2904	__GMP_DEFINE_COMPOUND_OPERATOR(mpf, fun, eval_fun)
2905
2906
2907
2908	#define __GMP_DEFINE_COMPOUND_OPERATOR_UI(type, fun, eval_fun) \
2909	\
2910	inline type##_class & type##_class::fun(mp_bitcnt_t l) \
2911	{ \
2912	__gmp_set_expr(mp, __gmp_expr<type##_t, __gmp_binary_expr \
2913	<type##_class, mp_bitcnt_t, eval_fun> >(*this, l)); \
2914	return *this; \
2915	}
2916
2917	#define __GMPZ_DEFINE_COMPOUND_OPERATOR_UI(fun, eval_fun) \
2918	__GMP_DEFINE_COMPOUND_OPERATOR_UI(mpz, fun, eval_fun)
2919
2920	#define __GMPQ_DEFINE_COMPOUND_OPERATOR_UI(fun, eval_fun) \
2921	__GMP_DEFINE_COMPOUND_OPERATOR_UI(mpq, fun, eval_fun)
2922
2923	#define __GMPF_DEFINE_COMPOUND_OPERATOR_UI(fun, eval_fun) \
2924	__GMP_DEFINE_COMPOUND_OPERATOR_UI(mpf, fun, eval_fun)
2925
2926
2927
2928	#define __GMP_DEFINE_INCREMENT_OPERATOR(type, fun, eval_fun) \
2929	\
2930	inline type##_class & type##_class::fun() \
2931	{ \
2932	eval_fun::eval(mp); \
2933	return *this; \
2934	} \
2935	\
2936	inline type##_class type##_class::fun(int) \
2937	{ \
2938	type##_class temp(*this); \
2939	eval_fun::eval(mp); \
2940	return temp; \
2941	}
2942
2943	#define __GMPZ_DEFINE_INCREMENT_OPERATOR(fun, eval_fun) \
2944	__GMP_DEFINE_INCREMENT_OPERATOR(mpz, fun, eval_fun)
2945
2946	#define __GMPQ_DEFINE_INCREMENT_OPERATOR(fun, eval_fun) \
2947	__GMP_DEFINE_INCREMENT_OPERATOR(mpq, fun, eval_fun)
2948
2949	#define __GMPF_DEFINE_INCREMENT_OPERATOR(fun, eval_fun) \
2950	__GMP_DEFINE_INCREMENT_OPERATOR(mpf, fun, eval_fun)
2951
2952
2953
2954	/**************** Arithmetic operators and functions ****************/
2955
2956	// non-member operators and functions
2957
2958	__GMP_DEFINE_UNARY_FUNCTION(operator+, __gmp_unary_plus)
2959	__GMP_DEFINE_UNARY_FUNCTION(operator-, __gmp_unary_minus)
2960	__GMP_DEFINE_UNARY_FUNCTION(operator~, __gmp_unary_com)
2961
2962	__GMP_DEFINE_BINARY_FUNCTION(operator+, __gmp_binary_plus)
2963	__GMP_DEFINE_BINARY_FUNCTION(operator-, __gmp_binary_minus)
2964	__GMP_DEFINE_BINARY_FUNCTION(operator*, __gmp_binary_multiplies)
2965	__GMP_DEFINE_BINARY_FUNCTION(operator/, __gmp_binary_divides)
2966	__GMP_DEFINE_BINARY_FUNCTION(operator%, __gmp_binary_modulus)
2967	__GMP_DEFINE_BINARY_FUNCTION(operator&, __gmp_binary_and)
2968	__GMP_DEFINE_BINARY_FUNCTION(operator|, __gmp_binary_ior)
2969	__GMP_DEFINE_BINARY_FUNCTION(operator^, __gmp_binary_xor)
2970
2971	__GMP_DEFINE_BINARY_FUNCTION_UI(operator<<, __gmp_binary_lshift)
2972	__GMP_DEFINE_BINARY_FUNCTION_UI(operator>>, __gmp_binary_rshift)
2973
2974	__GMP_DEFINE_BINARY_TYPE_FUNCTION(bool, operator==, __gmp_binary_equal)
2975	__GMP_DEFINE_BINARY_TYPE_FUNCTION(bool, operator!=, ! __gmp_binary_equal)
2976	__GMP_DEFINE_BINARY_TYPE_FUNCTION(bool, operator<, __gmp_binary_less)
2977	__GMP_DEFINE_BINARY_TYPE_FUNCTION(bool, operator<=, ! __gmp_binary_greater)
2978	__GMP_DEFINE_BINARY_TYPE_FUNCTION(bool, operator>, __gmp_binary_greater)
2979	__GMP_DEFINE_BINARY_TYPE_FUNCTION(bool, operator>=, ! __gmp_binary_less)
2980
2981	__GMP_DEFINE_UNARY_FUNCTION(abs, __gmp_abs_function)
2982	__GMP_DEFINE_UNARY_FUNCTION(trunc, __gmp_trunc_function)
2983	__GMP_DEFINE_UNARY_FUNCTION(floor, __gmp_floor_function)
2984	__GMP_DEFINE_UNARY_FUNCTION(ceil, __gmp_ceil_function)
2985	__GMP_DEFINE_UNARY_FUNCTION(sqrt, __gmp_sqrt_function)
2986	__GMP_DEFINE_BINARY_FUNCTION(hypot, __gmp_hypot_function)
2987
2988	__GMP_DEFINE_UNARY_TYPE_FUNCTION(int, sgn, __gmp_sgn_function)
2989	__GMP_DEFINE_BINARY_TYPE_FUNCTION(int, cmp, __gmp_cmp_function)
2990
2991	template <class T>
2992	void swap(__gmp_expr<T, T>& x, __gmp_expr<T, T>& y) __GMPXX_NOEXCEPT
2993	{ x.swap(y); }
2994
2995	// member operators for mpz_class
2996
2997	__GMPZ_DEFINE_COMPOUND_OPERATOR(operator+=, __gmp_binary_plus)
2998	__GMPZ_DEFINE_COMPOUND_OPERATOR(operator-=, __gmp_binary_minus)
2999	__GMPZ_DEFINE_COMPOUND_OPERATOR(operator*=, __gmp_binary_multiplies)
3000	__GMPZ_DEFINE_COMPOUND_OPERATOR(operator/=, __gmp_binary_divides)
3001	__GMPZ_DEFINE_COMPOUND_OPERATOR(operator%=, __gmp_binary_modulus)
3002
3003	__GMPZ_DEFINE_COMPOUND_OPERATOR(operator&=, __gmp_binary_and)
3004	__GMPZ_DEFINE_COMPOUND_OPERATOR(operator|=, __gmp_binary_ior)
3005	__GMPZ_DEFINE_COMPOUND_OPERATOR(operator^=, __gmp_binary_xor)
3006
3007	__GMPZ_DEFINE_COMPOUND_OPERATOR_UI(operator<<=, __gmp_binary_lshift)
3008	__GMPZ_DEFINE_COMPOUND_OPERATOR_UI(operator>>=, __gmp_binary_rshift)
3009
3010	__GMPZ_DEFINE_INCREMENT_OPERATOR(operator++, __gmp_unary_increment)
3011	__GMPZ_DEFINE_INCREMENT_OPERATOR(operator--, __gmp_unary_decrement)
3012
3013	// member operators for mpq_class
3014
3015	__GMPQ_DEFINE_COMPOUND_OPERATOR(operator+=, __gmp_binary_plus)
3016	__GMPQ_DEFINE_COMPOUND_OPERATOR(operator-=, __gmp_binary_minus)
3017	__GMPQ_DEFINE_COMPOUND_OPERATOR(operator*=, __gmp_binary_multiplies)
3018	__GMPQ_DEFINE_COMPOUND_OPERATOR(operator/=, __gmp_binary_divides)
3019
3020	__GMPQ_DEFINE_COMPOUND_OPERATOR_UI(operator<<=, __gmp_binary_lshift)
3021	__GMPQ_DEFINE_COMPOUND_OPERATOR_UI(operator>>=, __gmp_binary_rshift)
3022
3023	__GMPQ_DEFINE_INCREMENT_OPERATOR(operator++, __gmp_unary_increment)
3024	__GMPQ_DEFINE_INCREMENT_OPERATOR(operator--, __gmp_unary_decrement)
3025
3026	// member operators for mpf_class
3027
3028	__GMPF_DEFINE_COMPOUND_OPERATOR(operator+=, __gmp_binary_plus)
3029	__GMPF_DEFINE_COMPOUND_OPERATOR(operator-=, __gmp_binary_minus)
3030	__GMPF_DEFINE_COMPOUND_OPERATOR(operator*=, __gmp_binary_multiplies)
3031	__GMPF_DEFINE_COMPOUND_OPERATOR(operator/=, __gmp_binary_divides)
3032
3033	__GMPF_DEFINE_COMPOUND_OPERATOR_UI(operator<<=, __gmp_binary_lshift)
3034	__GMPF_DEFINE_COMPOUND_OPERATOR_UI(operator>>=, __gmp_binary_rshift)
3035
3036	__GMPF_DEFINE_INCREMENT_OPERATOR(operator++, __gmp_unary_increment)
3037	__GMPF_DEFINE_INCREMENT_OPERATOR(operator--, __gmp_unary_decrement)
3038
3039
3040
3041	/**************** Class wrapper for gmp_randstate_t ****************/
3042
3043	class __gmp_urandomb_value { };
3044	class __gmp_urandomm_value { };
3045
3046	template <>
3047	class __gmp_expr<mpz_t, __gmp_urandomb_value>
3048	{
3049	private:
3050	__gmp_randstate_struct *state;
3051	mp_bitcnt_t bits;
3052	public:
3053	__gmp_expr(gmp_randstate_t s, mp_bitcnt_t l) : state(s), bits(l) { }
3054	void eval(mpz_ptr z) const { __gmp_rand_function::eval(z, state, bits); }
3055	mp_bitcnt_t get_prec() const { return mpf_get_default_prec(); }
3056	};
3057
3058	template <>
3059	class __gmp_expr<mpz_t, __gmp_urandomm_value>
3060	{
3061	private:
3062	__gmp_randstate_struct *state;
3063	mpz_class range;
3064	public:
3065	__gmp_expr(gmp_randstate_t s, const mpz_class &z) : state(s), range(z) { }
3066	void eval(mpz_ptr z) const
3067	{ __gmp_rand_function::eval(z, state, range.get_mpz_t()); }
3068	mp_bitcnt_t get_prec() const { return mpf_get_default_prec(); }
3069	};
3070
3071	template <>
3072	class __gmp_expr<mpf_t, __gmp_urandomb_value>
3073	{
3074	private:
3075	__gmp_randstate_struct *state;
3076	mp_bitcnt_t bits;
3077	public:
3078	__gmp_expr(gmp_randstate_t s, mp_bitcnt_t l) : state(s), bits(l) { }
3079	void eval(mpf_ptr f) const
3080	{
3081	__gmp_rand_function::eval(f, state,
3082	(bits>0) ? bits : mpf_get_prec(f));
3083	}
3084	mp_bitcnt_t get_prec() const
3085	{
3086	if (bits == 0)
3087	return mpf_get_default_prec();
3088	else
3089	return bits;
3090	}
3091	};
3092
3093	extern "C" {
3094	typedef void __gmp_randinit_default_t (gmp_randstate_t);
3095	typedef void __gmp_randinit_lc_2exp_t (gmp_randstate_t, mpz_srcptr, unsigned long int, mp_bitcnt_t);
3096	typedef int __gmp_randinit_lc_2exp_size_t (gmp_randstate_t, mp_bitcnt_t);
3097	}
3098
3099	class gmp_randclass
3100	{
3101	private:
3102	gmp_randstate_t state;
3103
3104	// copy construction and assignment not allowed
3105	gmp_randclass(const gmp_randclass &);
3106	void operator=(const gmp_randclass &);
3107	public:
3108	// constructors and destructor
3109	gmp_randclass(gmp_randalg_t alg, unsigned long int size)
3110	{
3111	switch (alg)
3112	{
3113	case GMP_RAND_ALG_LC: // no other cases for now
3114	default:
3115	gmp_randinit(state, alg, size);
3116	break;
3117	}
3118	}
3119
3120	// gmp_randinit_default
3121	gmp_randclass(__gmp_randinit_default_t* f) { f(state); }
3122
3123	// gmp_randinit_lc_2exp
3124	gmp_randclass(__gmp_randinit_lc_2exp_t* f,
3125	mpz_class z, unsigned long int l1, mp_bitcnt_t l2)
3126	{ f(state, z.get_mpz_t(), l1, l2); }
3127
3128	// gmp_randinit_lc_2exp_size
3129	gmp_randclass(__gmp_randinit_lc_2exp_size_t* f,
3130	mp_bitcnt_t size)
3131	{
3132	if (f (state, size) == 0)
3133	throw std::length_error ("gmp_randinit_lc_2exp_size");
3134	}
3135
3136	~gmp_randclass() { gmp_randclear(state); }
3137
3138	// initialize
3139	void seed(); // choose a random seed some way (?)
3140	void seed(unsigned long int s) { gmp_randseed_ui(state, s); }
3141	void seed(const mpz_class &z) { gmp_randseed(state, z.get_mpz_t()); }
3142
3143	// get random number
3144	__gmp_expr<mpz_t, __gmp_urandomb_value> get_z_bits(mp_bitcnt_t l)
3145	{ return __gmp_expr<mpz_t, __gmp_urandomb_value>(state, l); }
3146	__gmp_expr<mpz_t, __gmp_urandomb_value> get_z_bits(const mpz_class &z)
3147	{ return get_z_bits(z.get_ui()); }
3148	// FIXME: z.get_bitcnt_t() ?
3149
3150	__gmp_expr<mpz_t, __gmp_urandomm_value> get_z_range(const mpz_class &z)
3151	{ return __gmp_expr<mpz_t, __gmp_urandomm_value>(state, z); }
3152
3153	__gmp_expr<mpf_t, __gmp_urandomb_value> get_f(mp_bitcnt_t prec = 0)
3154	{ return __gmp_expr<mpf_t, __gmp_urandomb_value>(state, prec); }
3155	};
3156
3157
3158	/**************** Specialize std::numeric_limits ****************/
3159
3160	namespace std {
3161	template <> class numeric_limits<mpz_class>
3162	{
3163	public:
3164	static const bool is_specialized = true;
3165	static mpz_class min() { return mpz_class(); }
3166	static mpz_class max() { return mpz_class(); }
3167	static mpz_class lowest() { return mpz_class(); }
3168	static const int digits = 0;
3169	static const int digits10 = 0;
3170	static const int max_digits10 = 0;
3171	static const bool is_signed = true;
3172	static const bool is_integer = true;
3173	static const bool is_exact = true;
3174	static const int radix = 2;
3175	static mpz_class epsilon() { return mpz_class(); }
3176	static mpz_class round_error() { return mpz_class(); }
3177	static const int min_exponent = 0;
3178	static const int min_exponent10 = 0;
3179	static const int max_exponent = 0;
3180	static const int max_exponent10 = 0;
3181	static const bool has_infinity = false;
3182	static const bool has_quiet_NaN = false;
3183	static const bool has_signaling_NaN = false;
3184	static const float_denorm_style has_denorm = denorm_absent;
3185	static const bool has_denorm_loss = false;
3186	static mpz_class infinity() { return mpz_class(); }
3187	static mpz_class quiet_NaN() { return mpz_class(); }
3188	static mpz_class signaling_NaN() { return mpz_class(); }
3189	static mpz_class denorm_min() { return mpz_class(); }
3190	static const bool is_iec559 = false;
3191	static const bool is_bounded = false;
3192	static const bool is_modulo = false;
3193	static const bool traps = false;
3194	static const bool tinyness_before = false;
3195	static const float_round_style round_style = round_toward_zero;
3196	};
3197
3198	template <> class numeric_limits<mpq_class>
3199	{
3200	public:
3201	static const bool is_specialized = true;
3202	static mpq_class min() { return mpq_class(); }
3203	static mpq_class max() { return mpq_class(); }
3204	static mpq_class lowest() { return mpq_class(); }
3205	static const int digits = 0;
3206	static const int digits10 = 0;
3207	static const int max_digits10 = 0;
3208	static const bool is_signed = true;
3209	static const bool is_integer = false;
3210	static const bool is_exact = true;
3211	static const int radix = 2;
3212	static mpq_class epsilon() { return mpq_class(); }
3213	static mpq_class round_error() { return mpq_class(); }
3214	static const int min_exponent = 0;
3215	static const int min_exponent10 = 0;
3216	static const int max_exponent = 0;
3217	static const int max_exponent10 = 0;
3218	static const bool has_infinity = false;
3219	static const bool has_quiet_NaN = false;
3220	static const bool has_signaling_NaN = false;
3221	static const float_denorm_style has_denorm = denorm_absent;
3222	static const bool has_denorm_loss = false;
3223	static mpq_class infinity() { return mpq_class(); }
3224	static mpq_class quiet_NaN() { return mpq_class(); }
3225	static mpq_class signaling_NaN() { return mpq_class(); }
3226	static mpq_class denorm_min() { return mpq_class(); }
3227	static const bool is_iec559 = false;
3228	static const bool is_bounded = false;
3229	static const bool is_modulo = false;
3230	static const bool traps = false;
3231	static const bool tinyness_before = false;
3232	static const float_round_style round_style = round_toward_zero;
3233	};
3234
3235	template <> class numeric_limits<mpf_class>
3236	{
3237	public:
3238	static const bool is_specialized = true;
3239	static mpf_class min() { return mpf_class(); }
3240	static mpf_class max() { return mpf_class(); }
3241	static mpf_class lowest() { return mpf_class(); }
3242	static const int digits = 0;
3243	static const int digits10 = 0;
3244	static const int max_digits10 = 0;
3245	static const bool is_signed = true;
3246	static const bool is_integer = false;
3247	static const bool is_exact = false;
3248	static const int radix = 2;
3249	static mpf_class epsilon() { return mpf_class(); }
3250	static mpf_class round_error() { return mpf_class(); }
3251	static const int min_exponent = 0;
3252	static const int min_exponent10 = 0;
3253	static const int max_exponent = 0;
3254	static const int max_exponent10 = 0;
3255	static const bool has_infinity = false;
3256	static const bool has_quiet_NaN = false;
3257	static const bool has_signaling_NaN = false;
3258	static const float_denorm_style has_denorm = denorm_absent;
3259	static const bool has_denorm_loss = false;
3260	static mpf_class infinity() { return mpf_class(); }
3261	static mpf_class quiet_NaN() { return mpf_class(); }
3262	static mpf_class signaling_NaN() { return mpf_class(); }
3263	static mpf_class denorm_min() { return mpf_class(); }
3264	static const bool is_iec559 = false;
3265	static const bool is_bounded = false;
3266	static const bool is_modulo = false;
3267	static const bool traps = false;
3268	static const bool tinyness_before = false;
3269	static const float_round_style round_style = round_indeterminate;
3270	};
3271	}
3272
3273
3274	/**************** #undef all private macros ****************/
3275
3276	#undef __GMPP_DECLARE_COMPOUND_OPERATOR
3277	#undef __GMPN_DECLARE_COMPOUND_OPERATOR
3278	#undef __GMP_DECLARE_COMPOUND_OPERATOR
3279	#undef __GMP_DECLARE_COMPOUND_OPERATOR_UI
3280	#undef __GMP_DECLARE_INCREMENT_OPERATOR
3281	#undef __GMPXX_DEFINE_ARITHMETIC_CONSTRUCTORS
3282	#undef __GMPXX_DEFINE_ARITHMETIC_ASSIGNMENTS
3283
3284	#undef __GMPZQ_DEFINE_EXPR
3285
3286	#undef __GMP_DEFINE_UNARY_FUNCTION
3287	#undef __GMP_DEFINE_UNARY_TYPE_FUNCTION
3288
3289	#undef __GMPP_DEFINE_BINARY_FUNCTION
3290	#undef __GMPNN_DEFINE_BINARY_FUNCTION
3291	#undef __GMPNS_DEFINE_BINARY_FUNCTION
3292	#undef __GMPNU_DEFINE_BINARY_FUNCTION
3293	#undef __GMPND_DEFINE_BINARY_FUNCTION
3294	#undef __GMPNLD_DEFINE_BINARY_FUNCTION
3295	#undef __GMPN_DEFINE_BINARY_FUNCTION
3296	#undef __GMP_DEFINE_BINARY_FUNCTION
3297
3298	#undef __GMP_DEFINE_BINARY_FUNCTION_UI
3299
3300	#undef __GMPP_DEFINE_BINARY_TYPE_FUNCTION
3301	#undef __GMPNN_DEFINE_BINARY_TYPE_FUNCTION
3302	#undef __GMPNS_DEFINE_BINARY_TYPE_FUNCTION
3303	#undef __GMPNU_DEFINE_BINARY_TYPE_FUNCTION
3304	#undef __GMPND_DEFINE_BINARY_TYPE_FUNCTION
3305	#undef __GMPNLD_DEFINE_BINARY_TYPE_FUNCTION
3306	#undef __GMPN_DEFINE_BINARY_TYPE_FUNCTION
3307	#undef __GMP_DEFINE_BINARY_TYPE_FUNCTION
3308
3309	#undef __GMPZ_DEFINE_COMPOUND_OPERATOR
3310
3311	#undef __GMPP_DEFINE_COMPOUND_OPERATOR
3312	#undef __GMPNN_DEFINE_COMPOUND_OPERATOR
3313	#undef __GMPNS_DEFINE_COMPOUND_OPERATOR
3314	#undef __GMPNU_DEFINE_COMPOUND_OPERATOR
3315	#undef __GMPND_DEFINE_COMPOUND_OPERATOR
3316	#undef __GMPNLD_DEFINE_COMPOUND_OPERATOR
3317	#undef __GMPN_DEFINE_COMPOUND_OPERATOR
3318	#undef __GMP_DEFINE_COMPOUND_OPERATOR
3319
3320	#undef __GMPQ_DEFINE_COMPOUND_OPERATOR
3321	#undef __GMPF_DEFINE_COMPOUND_OPERATOR
3322
3323	#undef __GMP_DEFINE_COMPOUND_OPERATOR_UI
3324	#undef __GMPZ_DEFINE_COMPOUND_OPERATOR_UI
3325	#undef __GMPQ_DEFINE_COMPOUND_OPERATOR_UI
3326	#undef __GMPF_DEFINE_COMPOUND_OPERATOR_UI
3327
3328	#undef __GMP_DEFINE_INCREMENT_OPERATOR
3329	#undef __GMPZ_DEFINE_INCREMENT_OPERATOR
3330	#undef __GMPQ_DEFINE_INCREMENT_OPERATOR
3331	#undef __GMPF_DEFINE_INCREMENT_OPERATOR
3332
3333	#undef __GMPXX_CONSTANT_TRUE
3334	#undef __GMPXX_CONSTANT
3335
3336	#endif /* __GMP_PLUSPLUS__ */
3337

---

Generated while processing extragear/office/alkimia/libalkimia/alkquoteitem.cpp
Generated on 2014-Aug-04 from project include
Powered by Code Browser 1.7