Aleph-w 3.0
A C++ Library for Data Structures and Algorithms
Loading...
Searching...
No Matches
gmpfrxx.h
Go to the documentation of this file.
1
2
3/*
4 Aleph_w
5
6 Data structures & Algorithms
7 version 2.0.0b
8 https://github.com/lrleon/Aleph-w
9
10 This file is part of Aleph-w library
11
12 Copyright (c) 2002-2026 Leandro Rabindranath Leon
13
14 Permission is hereby granted, free of charge, to any person obtaining a copy
15 of this software and associated documentation files (the "Software"), to deal
16 in the Software without restriction, including without limitation the rights
17 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
18 copies of the Software, and to permit persons to whom the Software is
19 furnished to do so, subject to the following conditions:
20
21 The above copyright notice and this permission notice shall be included in all
22 copies or substantial portions of the Software.
23
24 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
25 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
26 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
27 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
28 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
29 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
30 SOFTWARE.
31*/
32
33/* gmpfrxx.h -- C++ class wrapper for GMP and MPFR types.
34
35this is a re-write of gmpxx.h to replace mpf with mpfr
36and add all the features of mpfr that aren't in mpf
37(modified by Jon Wilkening)
38
39CVS version: 1.18
40
41The original gmpxx.h file is part of the GNU MP Library.
42
43Copyright 2001, 2002, 2003, 2006 Free Software Foundation, Inc.
44
45The GNU MP Library is free software; you can redistribute it and/or modify
46it under the terms of the GNU Lesser General Public License as published by
47the Free Software Foundation; either version 2.1 of the License, or (at your
48option) any later version.
49
50The GNU MP Library is distributed in the hope that it will be useful, but
51WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
52or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
53License for more details.
54
55You should have received a copy of the GNU Lesser General Public License
56along with the GNU MP Library; see the file COPYING.LIB. If not, write to
57the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
58MA 02110-1301, USA. */
59
60/* the C++ compiler must implement the following features:
61 - member templates
62 - partial specialization of templates
63 - namespace support
64 for g++, this means version 2.91 or higher
65 for other compilers, I don't know */
66
67#ifdef __GNUC__
68#if __GNUC__ < 2 || (__GNUC__ == 2 && __GNUC_MINOR__ < 91)
69#error gmpxx.h requires g++ version 2.91 (egcs 1.1.2) or higher
70#endif
71#endif
72
73#ifdef __GMP_PLUSPLUS__
74#ifndef __GMPFR_PLUSPLUS__
75#error gmpfrxx.h cannot be used together with gmpxx.h
76#endif
77#endif
78
79#ifndef __GMP_PLUSPLUS__
80#define __GMP_PLUSPLUS__
81#define __GMPFR_PLUSPLUS__
82
83#include <cstddef>
84#include <iosfwd>
85#include <iostream>
86#include <cstring> /* for strlen */
87#include <string>
88#include <stdexcept>
89#include <gmp.h>
90#include <mpfr.h>
91#include "mpfr_mul_d.h"
92
93// routines in gmpfrxx.cpp
94std::istream& operator>> (std::istream &, mpfr_ptr);
95std::ostream& operator<< (std::ostream &, mpfr_srcptr);
96void mpz_set_mpfr(mpz_ptr w, mpfr_srcptr u);
97void mpq_set_mpfr(mpq_ptr w, mpfr_srcptr u);
98
99// access these as mpfr_class::get_base(), etc.
100class MpFrC {
101 static mpfr_rnd_t rnd;
102 static int base;
103public:
104 static int get_base() { return base; }
105 static void set_base(int b=10) { base = b; }
106 static inline mpfr_rnd_t get_rnd() { return rnd; }
107 static void set_rnd(mpfr_rnd_t r=GMP_RNDN)
108 { mpfr_set_default_rounding_mode(r); rnd = r; }
109 static mpfr_prec_t get_dprec() { return mpfr_get_default_prec(); }
110 static void set_dprec(mpfr_prec_t p=53)
111 { mpfr_set_default_prec(p); }
112};
113
114/**************** Function objects ****************/
115/* Any evaluation of a __gmp_expr ends up calling one of these functions
116 all intermediate functions being inline, the evaluation should optimize
117 to a direct call to the relevant function, thus yielding no overhead
118 over the C interface. */
119
121{
122 static void eval(mpz_ptr z, mpz_srcptr w) { mpz_set(z, w); }
123 static void eval(mpq_ptr q, mpq_srcptr r) { mpq_set(q, r); }
124 static void eval(mpfr_ptr f, mpfr_srcptr g)
125 { mpfr_set(f, g, MpFrC::get_rnd()); }
126};
127
129{
130 static void eval(mpz_ptr z, mpz_srcptr w) { mpz_neg(z, w); }
131 static void eval(mpq_ptr q, mpq_srcptr r) { mpq_neg(q, r); }
132 static void eval(mpfr_ptr f, mpfr_srcptr g)
133 { mpfr_neg(f, g, MpFrC::get_rnd()); }
134};
135
137{
138 static void eval(mpz_ptr z, mpz_srcptr w) { mpz_com(z, w); }
139};
140
142{
143 static void eval(mpz_ptr z, mpz_srcptr w, mpz_srcptr v)
144 { mpz_add(z, w, v); }
145
146 static void eval(mpz_ptr z, mpz_srcptr w, unsigned long int l)
147 { mpz_add_ui(z, w, l); }
148 static void eval(mpz_ptr z, unsigned long int l, mpz_srcptr w)
149 { mpz_add_ui(z, w, l); }
150 static void eval(mpz_ptr z, mpz_srcptr w, signed long int l)
151 {
152 if (l >= 0)
153 mpz_add_ui(z, w, l);
154 else
155 mpz_sub_ui(z, w, -l);
156 }
157 static void eval(mpz_ptr z, signed long int l, mpz_srcptr w)
158 {
159 if (l >= 0)
160 mpz_add_ui(z, w, l);
161 else
162 mpz_sub_ui(z, w, -l);
163 }
164 static void eval(mpz_ptr z, mpz_srcptr w, double d)
165 {
166 mpz_t temp;
167 mpz_init_set_d(temp, d);
168 mpz_add(z, w, temp);
169 mpz_clear(temp);
170 }
171 static void eval(mpz_ptr z, double d, mpz_srcptr w)
172 {
173 mpz_t temp;
174 mpz_init_set_d(temp, d);
175 mpz_add(z, temp, w);
176 mpz_clear(temp);
177 }
178
179 static void eval(mpq_ptr q, mpq_srcptr r, mpq_srcptr s)
180 { mpq_add(q, r, s); }
181
182 static void eval(mpq_ptr q, mpq_srcptr r, unsigned long int l)
183 { mpq_set(q, r); mpz_addmul_ui(mpq_numref(q), mpq_denref(q), l); }
184 static void eval(mpq_ptr q, unsigned long int l, mpq_srcptr r)
185 { mpq_set(q, r); mpz_addmul_ui(mpq_numref(q), mpq_denref(q), l); }
186 static void eval(mpq_ptr q, mpq_srcptr r, signed long int l)
187 {
188 mpq_set(q, r);
189 if (l >= 0)
190 mpz_addmul_ui(mpq_numref(q), mpq_denref(q), l);
191 else
192 mpz_submul_ui(mpq_numref(q), mpq_denref(q), -l);
193 }
194 static void eval(mpq_ptr q, signed long int l, mpq_srcptr r)
195 {
196 mpq_set(q, r);
197 if (l >= 0)
198 mpz_addmul_ui(mpq_numref(q), mpq_denref(q), l);
199 else
200 mpz_submul_ui(mpq_numref(q), mpq_denref(q), -l);
201 }
202 static void eval(mpq_ptr q, mpq_srcptr r, double d)
203 {
204 mpq_t temp;
205 mpq_init(temp);
206 mpq_set_d(temp, d);
207 mpq_add(q, r, temp);
208 mpq_clear(temp);
209 }
210 static void eval(mpq_ptr q, double d, mpq_srcptr r)
211 {
212 mpq_t temp;
213 mpq_init(temp);
214 mpq_set_d(temp, d);
215 mpq_add(q, temp, r);
216 mpq_clear(temp);
217 }
218
219 static void eval(mpq_ptr q, mpq_srcptr r, mpz_srcptr z)
220 { mpq_set(q, r); mpz_addmul(mpq_numref(q), mpq_denref(q), z); }
221 static void eval(mpq_ptr q, mpz_srcptr z, mpq_srcptr r)
222 { mpq_set(q, r); mpz_addmul(mpq_numref(q), mpq_denref(q), z); }
223
224 static void eval(mpfr_ptr f, mpfr_srcptr g, mpfr_srcptr h)
225 { mpfr_add(f, g, h, MpFrC::get_rnd()); }
226 static void eval(mpfr_ptr f, mpfr_srcptr g, unsigned long int l)
227 { mpfr_add_ui(f, g, l, MpFrC::get_rnd()); }
228 static void eval(mpfr_ptr f, unsigned long int l, mpfr_srcptr g)
229 { mpfr_add_ui(f, g, l, MpFrC::get_rnd()); }
230 static void eval(mpfr_ptr f, mpfr_srcptr g, signed long int l)
231 { mpfr_add_si(f, g, l, MpFrC::get_rnd()); }
232 static void eval(mpfr_ptr f, signed long int l, mpfr_srcptr g)
233 { mpfr_add_si(f, g, l, MpFrC::get_rnd()); }
234 static void eval(mpfr_ptr f, mpfr_srcptr g, double d)
235 { mpfr_add_d(f, g, d, MpFrC::get_rnd()); }
236 static void eval(mpfr_ptr f, double d, mpfr_srcptr g)
237 { mpfr_add_d(f, g, d, MpFrC::get_rnd()); }
238};
239
241{
242 static void eval(mpz_ptr z, mpz_srcptr w, mpz_srcptr v)
243 { mpz_sub(z, w, v); }
244
245 static void eval(mpz_ptr z, mpz_srcptr w, unsigned long int l)
246 { mpz_sub_ui(z, w, l); }
247 static void eval(mpz_ptr z, unsigned long int l, mpz_srcptr w)
248 { mpz_ui_sub(z, l, w); }
249 static void eval(mpz_ptr z, mpz_srcptr w, signed long int l)
250 {
251 if (l >= 0)
252 mpz_sub_ui(z, w, l);
253 else
254 mpz_add_ui(z, w, -l);
255 }
256 static void eval(mpz_ptr z, signed long int l, mpz_srcptr w)
257 {
258 if (l >= 0)
259 mpz_ui_sub(z, l, w);
260 else
261 {
262 mpz_add_ui(z, w, -l);
263 mpz_neg(z, z);
264 }
265 }
266 static void eval(mpz_ptr z, mpz_srcptr w, double d)
267 {
268 mpz_t temp;
269 mpz_init_set_d(temp, d);
270 mpz_sub(z, w, temp);
271 mpz_clear(temp);
272 }
273 static void eval(mpz_ptr z, double d, mpz_srcptr w)
274 {
275 mpz_t temp;
276 mpz_init_set_d(temp, d);
277 mpz_sub(z, temp, w);
278 mpz_clear(temp);
279 }
280
281 static void eval(mpq_ptr q, mpq_srcptr r, mpq_srcptr s)
282 { mpq_sub(q, r, s); }
283
284 static void eval(mpq_ptr q, mpq_srcptr r, unsigned long int l)
285 { mpq_set(q, r); mpz_submul_ui(mpq_numref(q), mpq_denref(q), l); }
286 static void eval(mpq_ptr q, unsigned long int l, mpq_srcptr r)
287 { mpq_neg(q, r); mpz_addmul_ui(mpq_numref(q), mpq_denref(q), l); }
288 static void eval(mpq_ptr q, mpq_srcptr r, signed long int l)
289 {
290 mpq_set(q, r);
291 if (l >= 0)
292 mpz_submul_ui(mpq_numref(q), mpq_denref(q), l);
293 else
294 mpz_addmul_ui(mpq_numref(q), mpq_denref(q), -l);
295 }
296 static void eval(mpq_ptr q, signed long int l, mpq_srcptr r)
297 {
298 mpq_neg(q, r);
299 if (l >= 0)
300 mpz_addmul_ui(mpq_numref(q), mpq_denref(q), l);
301 else
302 mpz_submul_ui(mpq_numref(q), mpq_denref(q), -l);
303 }
304 static void eval(mpq_ptr q, mpq_srcptr r, double d)
305 {
306 mpq_t temp;
307 mpq_init(temp);
308 mpq_set_d(temp, d);
309 mpq_sub(q, r, temp);
310 mpq_clear(temp);
311 }
312 static void eval(mpq_ptr q, double d, mpq_srcptr r)
313 {
314 mpq_t temp;
315 mpq_init(temp);
316 mpq_set_d(temp, d);
317 mpq_sub(q, temp, r);
318 mpq_clear(temp);
319 }
320
321 static void eval(mpq_ptr q, mpq_srcptr r, mpz_srcptr z)
322 { mpq_set(q, r); mpz_submul(mpq_numref(q), mpq_denref(q), z); }
323 static void eval(mpq_ptr q, mpz_srcptr z, mpq_srcptr r)
324 { mpq_neg(q, r); mpz_addmul(mpq_numref(q), mpq_denref(q), z); }
325
326 static void eval(mpfr_ptr f, mpfr_srcptr g, mpfr_srcptr h)
327 { mpfr_sub(f, g, h, MpFrC::get_rnd()); }
328
329 static void eval(mpfr_ptr f, mpfr_srcptr g, unsigned long int l)
330 { mpfr_sub_ui(f, g, l, MpFrC::get_rnd()); }
331 static void eval(mpfr_ptr f, unsigned long int l, mpfr_srcptr g)
332 { mpfr_ui_sub(f, l, g, MpFrC::get_rnd()); }
333 static void eval(mpfr_ptr f, mpfr_srcptr g, signed long int l)
334 { mpfr_sub_si(f, g, l, MpFrC::get_rnd()); }
335 static void eval(mpfr_ptr f, signed long int l, mpfr_srcptr g)
336 { mpfr_ui_sub(f, l, g, MpFrC::get_rnd()); }
337 static void eval(mpfr_ptr f, mpfr_srcptr g, double d)
338 { mpfr_sub_d(f, g, d, MpFrC::get_rnd()); }
339 static void eval(mpfr_ptr f, double d, mpfr_srcptr g)
340 { mpfr_d_sub(f, d, g, MpFrC::get_rnd()); }
341};
342
344{
345 static void eval(mpz_ptr z, mpz_srcptr w, mpz_srcptr v)
346 { mpz_mul(z, w, v); }
347
348 static void eval(mpz_ptr z, mpz_srcptr w, unsigned long int l)
349 { mpz_mul_ui(z, w, l); }
350 static void eval(mpz_ptr z, unsigned long int l, mpz_srcptr w)
351 { mpz_mul_ui(z, w, l); }
352 static void eval(mpz_ptr z, mpz_srcptr w, signed long int l)
353 { mpz_mul_si (z, w, l); }
354 static void eval(mpz_ptr z, signed long int l, mpz_srcptr w)
355 { mpz_mul_si (z, w, l); }
356 static void eval(mpz_ptr z, mpz_srcptr w, double d)
357 {
358 mpz_t temp;
359 mpz_init_set_d(temp, d);
360 mpz_mul(z, w, temp);
361 mpz_clear(temp);
362 }
363 static void eval(mpz_ptr z, double d, mpz_srcptr w)
364 {
365 mpz_t temp;
366 mpz_init_set_d(temp, d);
367 mpz_mul(z, temp, w);
368 mpz_clear(temp);
369 }
370
371 static void eval(mpq_ptr q, mpq_srcptr r, mpq_srcptr s)
372 { mpq_mul(q, r, s); }
373
374 static void eval(mpq_ptr q, mpq_srcptr r, unsigned long int l)
375 {
376 mpq_t temp;
377 mpq_init(temp);
378 mpq_set_ui(temp, l, 1);
379 mpq_mul(q, r, temp);
380 mpq_clear(temp);
381 }
382 static void eval(mpq_ptr q, unsigned long int l, mpq_srcptr r)
383 {
384 mpq_t temp;
385 mpq_init(temp);
386 mpq_set_ui(temp, l, 1);
387 mpq_mul(q, temp, r);
388 mpq_clear(temp);
389 }
390 static void eval(mpq_ptr q, mpq_srcptr r, signed long int l)
391 {
392 mpq_t temp;
393 mpq_init(temp);
394 mpq_set_si(temp, l, 1);
395 mpq_mul(q, r, temp);
396 mpq_clear(temp);
397 }
398 static void eval(mpq_ptr q, signed long int l, mpq_srcptr r)
399 {
400 mpq_t temp;
401 mpq_init(temp);
402 mpq_set_si(temp, l, 1);
403 mpq_mul(q, temp, r);
404 mpq_clear(temp);
405 }
406 static void eval(mpq_ptr q, mpq_srcptr r, double d)
407 {
408 mpq_t temp;
409 mpq_init(temp);
410 mpq_set_d(temp, d);
411 mpq_mul(q, r, temp);
412 mpq_clear(temp);
413 }
414 static void eval(mpq_ptr q, double d, mpq_srcptr r)
415 {
416 mpq_t temp;
417 mpq_init(temp);
418 mpq_set_d(temp, d);
419 mpq_mul(q, temp, r);
420 mpq_clear(temp);
421 }
422
423 static void eval(mpfr_ptr f, mpfr_srcptr g, mpfr_srcptr h)
424 { mpfr_mul(f, g, h, MpFrC::get_rnd()); }
425
426 static void eval(mpfr_ptr f, mpfr_srcptr g, unsigned long int l)
427 { mpfr_mul_ui(f, g, l, MpFrC::get_rnd()); }
428 static void eval(mpfr_ptr f, unsigned long int l, mpfr_srcptr g)
429 { mpfr_mul_ui(f, g, l, MpFrC::get_rnd()); }
430 static void eval(mpfr_ptr f, mpfr_srcptr g, signed long int l)
431 { mpfr_mul_si(f, g, l, MpFrC::get_rnd()); }
432 static void eval(mpfr_ptr f, signed long int l, mpfr_srcptr g)
433 { mpfr_mul_si(f, g, l, MpFrC::get_rnd()); }
434 static void eval(mpfr_ptr f, mpfr_srcptr g, double d)
435 { mpfr_mul_d(f, g, d, MpFrC::get_rnd()); }
436 static void eval(mpfr_ptr f, double d, mpfr_srcptr g)
437 { mpfr_mul_d(f, g, d, MpFrC::get_rnd()); }
438};
439
441{
442 static void eval(mpz_ptr z, mpz_srcptr w, mpz_srcptr v)
443 { mpz_tdiv_q(z, w, v); }
444
445 static void eval(mpz_ptr z, mpz_srcptr w, unsigned long int l)
446 { mpz_tdiv_q_ui(z, w, l); }
447 static void eval(mpz_ptr z, unsigned long int l, mpz_srcptr w)
448 {
449 if (mpz_sgn(w) >= 0)
450 {
451 if (mpz_fits_ulong_p(w))
452 mpz_set_ui(z, l / mpz_get_ui(w));
453 else
454 mpz_set_ui(z, 0);
455 }
456 else
457 {
458 mpz_neg(z, w);
459 if (mpz_fits_ulong_p(z))
460 {
461 mpz_set_ui(z, l / mpz_get_ui(z));
462 mpz_neg(z, z);
463 }
464 else
465 mpz_set_ui(z, 0);
466 }
467 }
468 static void eval(mpz_ptr z, mpz_srcptr w, signed long int l)
469 {
470 if (l >= 0)
471 mpz_tdiv_q_ui(z, w, l);
472 else
473 {
474 mpz_tdiv_q_ui(z, w, -l);
475 mpz_neg(z, z);
476 }
477 }
478 static void eval(mpz_ptr z, signed long int l, mpz_srcptr w)
479 {
480 if (mpz_fits_slong_p(w))
481 mpz_set_si(z, l / mpz_get_si(w));
482 else
483 {
484 /* if w is bigger than a long then the quotient must be zero, unless
485 l==LONG_MIN and w==-LONG_MIN in which case the quotient is -1 */
486 mpz_set_si (z, (mpz_cmpabs_ui (w, (l >= 0 ? l : -l)) == 0 ? -1 : 0));
487 }
488 }
489 static void eval(mpz_ptr z, mpz_srcptr w, double d)
490 {
491 mpz_t temp;
492 mpz_init_set_d(temp, d);
493 mpz_tdiv_q(z, w, temp);
494 mpz_clear(temp);
495 }
496 static void eval(mpz_ptr z, double d, mpz_srcptr w)
497 {
498 mpz_t temp;
499 mpz_init_set_d(temp, d);
500 mpz_tdiv_q(z, temp, w);
501 mpz_clear(temp);
502 }
503
504 static void eval(mpq_ptr q, mpq_srcptr r, mpq_srcptr s)
505 { mpq_div(q, r, s); }
506
507 static void eval(mpq_ptr q, mpq_srcptr r, unsigned long int l)
508 {
509 mpq_t temp;
510 mpq_init(temp);
511 mpq_set_ui(temp, l, 1);
512 mpq_div(q, r, temp);
513 mpq_clear(temp);
514 }
515 static void eval(mpq_ptr q, unsigned long int l, mpq_srcptr r)
516 {
517 mpq_t temp;
518 mpq_init(temp);
519 mpq_set_ui(temp, l, 1);
520 mpq_div(q, temp, r);
521 mpq_clear(temp);
522 }
523 static void eval(mpq_ptr q, mpq_srcptr r, signed long int l)
524 {
525 mpq_t temp;
526 mpq_init(temp);
527 mpq_set_si(temp, l, 1);
528 mpq_div(q, r, temp);
529 mpq_clear(temp);
530 }
531 static void eval(mpq_ptr q, signed long int l, mpq_srcptr r)
532 {
533 mpq_t temp;
534 mpq_init(temp);
535 mpq_set_si(temp, l, 1);
536 mpq_div(q, temp, r);
537 mpq_clear(temp);
538 }
539 static void eval(mpq_ptr q, mpq_srcptr r, double d)
540 {
541 mpq_t temp;
542 mpq_init(temp);
543 mpq_set_d(temp, d);
544 mpq_div(q, r, temp);
545 mpq_clear(temp);
546 }
547 static void eval(mpq_ptr q, double d, mpq_srcptr r)
548 {
549 mpq_t temp;
550 mpq_init(temp);
551 mpq_set_d(temp, d);
552 mpq_div(q, temp, r);
553 mpq_clear(temp);
554 }
555
556 static void eval(mpfr_ptr f, mpfr_srcptr g, mpfr_srcptr h)
557 { mpfr_div(f, g, h, MpFrC::get_rnd()); }
558
559 static void eval(mpfr_ptr f, mpfr_srcptr g, unsigned long int l)
560 { mpfr_div_ui(f, g, l, MpFrC::get_rnd()); }
561 static void eval(mpfr_ptr f, unsigned long int l, mpfr_srcptr g)
562 { mpfr_ui_div(f, l, g, MpFrC::get_rnd()); }
563 static void eval(mpfr_ptr f, mpfr_srcptr g, signed long int l)
564 { mpfr_div_si(f, g, l, MpFrC::get_rnd()); }
565 static void eval(mpfr_ptr f, signed long int l, mpfr_srcptr g)
566 { mpfr_si_div(f, l, g, MpFrC::get_rnd()); }
567 static void eval(mpfr_ptr f, mpfr_srcptr g, double d)
568 { mpfr_div_d(f, g, d, MpFrC::get_rnd()); }
569 static void eval(mpfr_ptr f, double d, mpfr_srcptr g)
570 { mpfr_d_div(f, d, g, MpFrC::get_rnd()); }
571};
572
574{
575 static void eval(mpz_ptr z, mpz_srcptr w, mpz_srcptr v)
576 { mpz_tdiv_r(z, w, v); }
577
578 static void eval(mpz_ptr z, mpz_srcptr w, unsigned long int l)
579 { mpz_tdiv_r_ui(z, w, l); }
580 static void eval(mpz_ptr z, unsigned long int l, mpz_srcptr w)
581 {
582 if (mpz_sgn(w) >= 0)
583 {
584 if (mpz_fits_ulong_p(w))
585 mpz_set_ui(z, l % mpz_get_ui(w));
586 else
587 mpz_set_ui(z, l);
588 }
589 else
590 {
591 mpz_neg(z, w);
592 if (mpz_fits_ulong_p(z))
593 mpz_set_ui(z, l % mpz_get_ui(z));
594 else
595 mpz_set_ui(z, l);
596 }
597 }
598 static void eval(mpz_ptr z, mpz_srcptr w, signed long int l)
599 {
600 mpz_tdiv_r_ui (z, w, (l >= 0 ? l : -l));
601 }
602 static void eval(mpz_ptr z, signed long int l, mpz_srcptr w)
603 {
604 if (mpz_fits_slong_p(w))
605 mpz_set_si(z, l % mpz_get_si(w));
606 else
607 {
608 /* if w is bigger than a long then the remainder is l unchanged,
609 unless l==LONG_MIN and w==-LONG_MIN in which case it's 0 */
610 mpz_set_si (z, mpz_cmpabs_ui (w, (l >= 0 ? l : -l)) == 0 ? 0 : l);
611 }
612 }
613 static void eval(mpz_ptr z, mpz_srcptr w, double d)
614 {
615 mpz_t temp;
616 mpz_init_set_d(temp, d);
617 mpz_tdiv_r(z, w, temp);
618 mpz_clear(temp);
619 }
620 static void eval(mpz_ptr z, double d, mpz_srcptr w)
621 {
622 mpz_t temp;
623 mpz_init_set_d(temp, d);
624 mpz_tdiv_r(z, temp, w);
625 mpz_clear(temp);
626 }
627};
628
630{
631 static void eval(mpz_ptr z, mpz_srcptr w, mpz_srcptr v)
632 { mpz_and(z, w, v); }
633};
634
636{
637 static void eval(mpz_ptr z, mpz_srcptr w, mpz_srcptr v)
638 { mpz_ior(z, w, v); }
639};
640
642{
643 static void eval(mpz_ptr z, mpz_srcptr w, mpz_srcptr v)
644 { mpz_xor(z, w, v); }
645};
646
648{
649 static void eval(mpz_ptr z, mpz_srcptr w, unsigned long int l)
650 { mpz_mul_2exp(z, w, l); }
651 static void eval(mpq_ptr q, mpq_srcptr r, unsigned long int l)
652 { mpq_mul_2exp(q, r, l); }
653 static void eval(mpfr_ptr f, mpfr_srcptr g, unsigned long int l)
654 { mpfr_mul_2ui(f, g, l, MpFrC::get_rnd()); }
655};
656
658{
659 static void eval(mpz_ptr z, mpz_srcptr w, unsigned long int l)
660 { mpz_tdiv_q_2exp(z, w, l); }
661 static void eval(mpq_ptr q, mpq_srcptr r, unsigned long int l)
662 { mpq_div_2exp(q, r, l); }
663 static void eval(mpfr_ptr f, mpfr_srcptr g, unsigned long int l)
664 { mpfr_div_2ui(f, g, l, MpFrC::get_rnd()); }
665};
666
668{
669 static bool eval(mpz_srcptr z, mpz_srcptr w) { return mpz_cmp(z, w) == 0; }
670
671 static bool eval(mpz_srcptr z, unsigned long int l)
672 { return mpz_cmp_ui(z, l) == 0; }
673 static bool eval(unsigned long int l, mpz_srcptr z)
674 { return mpz_cmp_ui(z, l) == 0; }
675 static bool eval(mpz_srcptr z, signed long int l)
676 { return mpz_cmp_si(z, l) == 0; }
677 static bool eval(signed long int l, mpz_srcptr z)
678 { return mpz_cmp_si(z, l) == 0; }
679 static bool eval(mpz_srcptr z, double d)
680 { return mpz_cmp_d(z, d) == 0; }
681 static bool eval(double d, mpz_srcptr z)
682 { return mpz_cmp_d(z, d) == 0; }
683
684 static bool eval(mpq_srcptr q, mpq_srcptr r)
685 { return mpq_equal(q, r) != 0; }
686
687 static bool eval(mpq_srcptr q, unsigned long int l)
688 { return mpq_cmp_ui(q, l, 1) == 0; }
689 static bool eval(unsigned long int l, mpq_srcptr q)
690 { return mpq_cmp_ui(q, l, 1) == 0; }
691 static bool eval(mpq_srcptr q, signed long int l)
692 { return mpq_cmp_si(q, l, 1) == 0; }
693 static bool eval(signed long int l, mpq_srcptr q)
694 { return mpq_cmp_si(q, l, 1) == 0; }
695 static bool eval(mpq_srcptr q, double d)
696 {
697 bool b;
698 mpq_t temp;
699 mpq_init(temp);
700 mpq_set_d(temp, d);
701 b = (mpq_equal(q, temp) != 0);
702 mpq_clear(temp);
703 return b;
704 }
705 static bool eval(double d, mpq_srcptr q)
706 {
707 bool b;
708 mpq_t temp;
709 mpq_init(temp);
710 mpq_set_d(temp, d);
711 b = (mpq_equal(temp, q) != 0);
712 mpq_clear(temp);
713 return b;
714 }
715
716 static bool eval(mpfr_srcptr f, mpfr_srcptr g)
717 { return mpfr_cmp(f, g) == 0; }
718
719 static bool eval(mpfr_srcptr f, unsigned long int l)
720 { return mpfr_cmp_ui(f, l) == 0; }
721 static bool eval(unsigned long int l, mpfr_srcptr f)
722 { return mpfr_cmp_ui(f, l) == 0; }
723 static bool eval(mpfr_srcptr f, signed long int l)
724 { return mpfr_cmp_si(f, l) == 0; }
725 static bool eval(signed long int l, mpfr_srcptr f)
726 { return mpfr_cmp_si(f, l) == 0; }
727 static bool eval(mpfr_srcptr f, double d)
728 { return mpfr_cmp_d(f, d) == 0; }
729 static bool eval(double d, mpfr_srcptr f)
730 { return mpfr_cmp_d(f, d) == 0; }
731};
732
734{
735 static bool eval(mpz_srcptr z, mpz_srcptr w)
736 { return mpz_cmp(z, w) != 0; }
737
738 static bool eval(mpz_srcptr z, unsigned long int l)
739 { return mpz_cmp_ui(z, l) != 0; }
740 static bool eval(unsigned long int l, mpz_srcptr z)
741 { return mpz_cmp_ui(z, l) != 0; }
742 static bool eval(mpz_srcptr z, signed long int l)
743 { return mpz_cmp_si(z, l) != 0; }
744 static bool eval(signed long int l, mpz_srcptr z)
745 { return mpz_cmp_si(z, l) != 0; }
746 static bool eval(mpz_srcptr z, double d)
747 { return mpz_cmp_d(z, d) != 0; }
748 static bool eval(double d, mpz_srcptr z)
749 { return mpz_cmp_d(z, d) != 0; }
750
751 static bool eval(mpq_srcptr q, mpq_srcptr r)
752 { return mpq_equal(q, r) == 0; }
753
754 static bool eval(mpq_srcptr q, unsigned long int l)
755 { return mpq_cmp_ui(q, l, 1) != 0; }
756 static bool eval(unsigned long int l, mpq_srcptr q)
757 { return mpq_cmp_ui(q, l, 1) != 0; }
758 static bool eval(mpq_srcptr q, signed long int l)
759 { return mpq_cmp_si(q, l, 1) != 0; }
760 static bool eval(signed long int l, mpq_srcptr q)
761 { return mpq_cmp_si(q, l, 1) != 0; }
762 static bool eval(mpq_srcptr q, double d)
763 {
764 bool b;
765 mpq_t temp;
766 mpq_init(temp);
767 mpq_set_d(temp, d);
768 b = (mpq_equal(q, temp) == 0);
769 mpq_clear(temp);
770 return b;
771 }
772 static bool eval(double d, mpq_srcptr q)
773 {
774 bool b;
775 mpq_t temp;
776 mpq_init(temp);
777 mpq_set_d(temp, d);
778 b = (mpq_equal(temp, q) == 0);
779 mpq_clear(temp);
780 return b;
781 }
782
783 static bool eval(mpfr_srcptr f, mpfr_srcptr g) { return mpfr_cmp(f, g) != 0; }
784
785 static bool eval(mpfr_srcptr f, unsigned long int l)
786 { return mpfr_cmp_ui(f, l) != 0; }
787 static bool eval(unsigned long int l, mpfr_srcptr f)
788 { return mpfr_cmp_ui(f, l) != 0; }
789 static bool eval(mpfr_srcptr f, signed long int l)
790 { return mpfr_cmp_si(f, l) != 0; }
791 static bool eval(signed long int l, mpfr_srcptr f)
792 { return mpfr_cmp_si(f, l) != 0; }
793 static bool eval(mpfr_srcptr f, double d)
794 { return mpfr_cmp_d(f, d) != 0; }
795 static bool eval(double d, mpfr_srcptr f)
796 { return mpfr_cmp_d(f, d) != 0; }
797};
798
800{
801 static bool eval(mpz_srcptr z, mpz_srcptr w) { return mpz_cmp(z, w) < 0; }
802
803 static bool eval(mpz_srcptr z, unsigned long int l)
804 { return mpz_cmp_ui(z, l) < 0; }
805 static bool eval(unsigned long int l, mpz_srcptr z)
806 { return mpz_cmp_ui(z, l) > 0; }
807 static bool eval(mpz_srcptr z, signed long int l)
808 { return mpz_cmp_si(z, l) < 0; }
809 static bool eval(signed long int l, mpz_srcptr z)
810 { return mpz_cmp_si(z, l) > 0; }
811 static bool eval(mpz_srcptr z, double d)
812 { return mpz_cmp_d(z, d) < 0; }
813 static bool eval(double d, mpz_srcptr z)
814 { return mpz_cmp_d(z, d) > 0; }
815
816 static bool eval(mpq_srcptr q, mpq_srcptr r) { return mpq_cmp(q, r) < 0; }
817
818 static bool eval(mpq_srcptr q, unsigned long int l)
819 { return mpq_cmp_ui(q, l, 1) < 0; }
820 static bool eval(unsigned long int l, mpq_srcptr q)
821 { return mpq_cmp_ui(q, l, 1) > 0; }
822 static bool eval(mpq_srcptr q, signed long int l)
823 { return mpq_cmp_si(q, l, 1) < 0; }
824 static bool eval(signed long int l, mpq_srcptr q)
825 { return mpq_cmp_si(q, l, 1) > 0; }
826 static bool eval(mpq_srcptr q, double d)
827 {
828 bool b;
829 mpq_t temp;
830 mpq_init(temp);
831 mpq_set_d(temp, d);
832 b = (mpq_cmp(q, temp) < 0);
833 mpq_clear(temp);
834 return b;
835 }
836 static bool eval(double d, mpq_srcptr q)
837 {
838 bool b;
839 mpq_t temp;
840 mpq_init(temp);
841 mpq_set_d(temp, d);
842 b = (mpq_cmp(temp, q) < 0);
843 mpq_clear(temp);
844 return b;
845 }
846
847 static bool eval(mpfr_srcptr f, mpfr_srcptr g) { return mpfr_cmp(f, g) < 0; }
848
849 static bool eval(mpfr_srcptr f, unsigned long int l)
850 { return mpfr_cmp_ui(f, l) < 0; }
851 static bool eval(unsigned long int l, mpfr_srcptr f)
852 { return mpfr_cmp_ui(f, l) > 0; }
853 static bool eval(mpfr_srcptr f, signed long int l)
854 { return mpfr_cmp_si(f, l) < 0; }
855 static bool eval(signed long int l, mpfr_srcptr f)
856 { return mpfr_cmp_si(f, l) > 0; }
857 static bool eval(mpfr_srcptr f, double d)
858 { return mpfr_cmp_d(f, d) < 0; }
859 static bool eval(double d, mpfr_srcptr f)
860 { return mpfr_cmp_d(f, d) > 0; }
861};
862
864{
865 static bool eval(mpz_srcptr z, mpz_srcptr w) { return mpz_cmp(z, w) <= 0; }
866
867 static bool eval(mpz_srcptr z, unsigned long int l)
868 { return mpz_cmp_ui(z, l) <= 0; }
869 static bool eval(unsigned long int l, mpz_srcptr z)
870 { return mpz_cmp_ui(z, l) >= 0; }
871 static bool eval(mpz_srcptr z, signed long int l)
872 { return mpz_cmp_si(z, l) <= 0; }
873 static bool eval(signed long int l, mpz_srcptr z)
874 { return mpz_cmp_si(z, l) >= 0; }
875 static bool eval(mpz_srcptr z, double d)
876 { return mpz_cmp_d(z, d) <= 0; }
877 static bool eval(double d, mpz_srcptr z)
878 { return mpz_cmp_d(z, d) >= 0; }
879
880 static bool eval(mpq_srcptr q, mpq_srcptr r) { return mpq_cmp(q, r) <= 0; }
881
882 static bool eval(mpq_srcptr q, unsigned long int l)
883 { return mpq_cmp_ui(q, l, 1) <= 0; }
884 static bool eval(unsigned long int l, mpq_srcptr q)
885 { return mpq_cmp_ui(q, l, 1) >= 0; }
886 static bool eval(mpq_srcptr q, signed long int l)
887 { return mpq_cmp_si(q, l, 1) <= 0; }
888 static bool eval(signed long int l, mpq_srcptr q)
889 { return mpq_cmp_si(q, l, 1) >= 0; }
890 static bool eval(mpq_srcptr q, double d)
891 {
892 bool b;
893 mpq_t temp;
894 mpq_init(temp);
895 mpq_set_d(temp, d);
896 b = (mpq_cmp(q, temp) <= 0);
897 mpq_clear(temp);
898 return b;
899 }
900 static bool eval(double d, mpq_srcptr q)
901 {
902 bool b;
903 mpq_t temp;
904 mpq_init(temp);
905 mpq_set_d(temp, d);
906 b = (mpq_cmp(temp, q) <= 0);
907 mpq_clear(temp);
908 return b;
909 }
910
911 static bool eval(mpfr_srcptr f, mpfr_srcptr g) { return mpfr_cmp(f, g) <= 0; }
912
913 static bool eval(mpfr_srcptr f, unsigned long int l)
914 { return mpfr_cmp_ui(f, l) <= 0; }
915 static bool eval(unsigned long int l, mpfr_srcptr f)
916 { return mpfr_cmp_ui(f, l) >= 0; }
917 static bool eval(mpfr_srcptr f, signed long int l)
918 { return mpfr_cmp_si(f, l) <= 0; }
919 static bool eval(signed long int l, mpfr_srcptr f)
920 { return mpfr_cmp_si(f, l) >= 0; }
921 static bool eval(mpfr_srcptr f, double d)
922 { return mpfr_cmp_d(f, d) <= 0; }
923 static bool eval(double d, mpfr_srcptr f)
924 { return mpfr_cmp_d(f, d) >= 0; }
925};
926
928{
929 static bool eval(mpz_srcptr z, mpz_srcptr w) { return mpz_cmp(z, w) > 0; }
930
931 static bool eval(mpz_srcptr z, unsigned long int l)
932 { return mpz_cmp_ui(z, l) > 0; }
933 static bool eval(unsigned long int l, mpz_srcptr z)
934 { return mpz_cmp_ui(z, l) < 0; }
935 static bool eval(mpz_srcptr z, signed long int l)
936 { return mpz_cmp_si(z, l) > 0; }
937 static bool eval(signed long int l, mpz_srcptr z)
938 { return mpz_cmp_si(z, l) < 0; }
939 static bool eval(mpz_srcptr z, double d)
940 { return mpz_cmp_d(z, d) > 0; }
941 static bool eval(double d, mpz_srcptr z)
942 { return mpz_cmp_d(z, d) < 0; }
943
944 static bool eval(mpq_srcptr q, mpq_srcptr r) { return mpq_cmp(q, r) > 0; }
945
946 static bool eval(mpq_srcptr q, unsigned long int l)
947 { return mpq_cmp_ui(q, l, 1) > 0; }
948 static bool eval(unsigned long int l, mpq_srcptr q)
949 { return mpq_cmp_ui(q, l, 1) < 0; }
950 static bool eval(mpq_srcptr q, signed long int l)
951 { return mpq_cmp_si(q, l, 1) > 0; }
952 static bool eval(signed long int l, mpq_srcptr q)
953 { return mpq_cmp_si(q, l, 1) < 0; }
954 static bool eval(mpq_srcptr q, double d)
955 {
956 bool b;
957 mpq_t temp;
958 mpq_init(temp);
959 mpq_set_d(temp, d);
960 b = (mpq_cmp(q, temp) > 0);
961 mpq_clear(temp);
962 return b;
963 }
964 static bool eval(double d, mpq_srcptr q)
965 {
966 bool b;
967 mpq_t temp;
968 mpq_init(temp);
969 mpq_set_d(temp, d);
970 b = (mpq_cmp(temp, q) > 0);
971 mpq_clear(temp);
972 return b;
973 }
974
975 static bool eval(mpfr_srcptr f, mpfr_srcptr g) { return mpfr_cmp(f, g) > 0; }
976
977 static bool eval(mpfr_srcptr f, unsigned long int l)
978 { return mpfr_cmp_ui(f, l) > 0; }
979 static bool eval(unsigned long int l, mpfr_srcptr f)
980 { return mpfr_cmp_ui(f, l) < 0; }
981 static bool eval(mpfr_srcptr f, signed long int l)
982 { return mpfr_cmp_si(f, l) > 0; }
983 static bool eval(signed long int l, mpfr_srcptr f)
984 { return mpfr_cmp_si(f, l) < 0; }
985 static bool eval(mpfr_srcptr f, double d)
986 { return mpfr_cmp_d(f, d) > 0; }
987 static bool eval(double d, mpfr_srcptr f)
988 { return mpfr_cmp_d(f, d) < 0; }
989};
990
991// not in gmpxx.h
993{
994 static int eval(mpfr_srcptr f, mpfr_srcptr g)
995 { return mpfr_cmpabs(f, g); }
996};
997
999{
1000 static bool eval(mpz_srcptr z, mpz_srcptr w) { return mpz_cmp(z, w) >= 0; }
1001
1002 static bool eval(mpz_srcptr z, unsigned long int l)
1003 { return mpz_cmp_ui(z, l) >= 0; }
1004 static bool eval(unsigned long int l, mpz_srcptr z)
1005 { return mpz_cmp_ui(z, l) <= 0; }
1006 static bool eval(mpz_srcptr z, signed long int l)
1007 { return mpz_cmp_si(z, l) >= 0; }
1008 static bool eval(signed long int l, mpz_srcptr z)
1009 { return mpz_cmp_si(z, l) <= 0; }
1010 static bool eval(mpz_srcptr z, double d)
1011 { return mpz_cmp_d(z, d) >= 0; }
1012 static bool eval(double d, mpz_srcptr z)
1013 { return mpz_cmp_d(z, d) <= 0; }
1014
1015 static bool eval(mpq_srcptr q, mpq_srcptr r) { return mpq_cmp(q, r) >= 0; }
1016
1017 static bool eval(mpq_srcptr q, unsigned long int l)
1018 { return mpq_cmp_ui(q, l, 1) >= 0; }
1019 static bool eval(unsigned long int l, mpq_srcptr q)
1020 { return mpq_cmp_ui(q, l, 1) <= 0; }
1021 static bool eval(mpq_srcptr q, signed long int l)
1022 { return mpq_cmp_si(q, l, 1) >= 0; }
1023 static bool eval(signed long int l, mpq_srcptr q)
1024 { return mpq_cmp_si(q, l, 1) <= 0; }
1025 static bool eval(mpq_srcptr q, double d)
1026 {
1027 bool b;
1028 mpq_t temp;
1029 mpq_init(temp);
1030 mpq_set_d(temp, d);
1031 b = (mpq_cmp(q, temp) >= 0);
1032 mpq_clear(temp);
1033 return b;
1034 }
1035 static bool eval(double d, mpq_srcptr q)
1036 {
1037 bool b;
1038 mpq_t temp;
1039 mpq_init(temp);
1040 mpq_set_d(temp, d);
1041 b = (mpq_cmp(temp, q) >= 0);
1042 mpq_clear(temp);
1043 return b;
1044 }
1045
1046 static bool eval(mpfr_srcptr f, mpfr_srcptr g) { return mpfr_cmp(f, g) >= 0; }
1047
1048 static bool eval(mpfr_srcptr f, unsigned long int l)
1049 { return mpfr_cmp_ui(f, l) >= 0; }
1050 static bool eval(unsigned long int l, mpfr_srcptr f)
1051 { return mpfr_cmp_ui(f, l) <= 0; }
1052 static bool eval(mpfr_srcptr f, signed long int l)
1053 { return mpfr_cmp_si(f, l) >= 0; }
1054 static bool eval(signed long int l, mpfr_srcptr f)
1055 { return mpfr_cmp_si(f, l) <= 0; }
1056 static bool eval(mpfr_srcptr f, double d)
1057 { return mpfr_cmp_d(f, d) >= 0; }
1058 static bool eval(double d, mpfr_srcptr f)
1059 { return mpfr_cmp_d(f, d) <= 0; }
1060};
1061
1063{
1064 static void eval(mpz_ptr z) { mpz_add_ui(z, z, 1); }
1065 static void eval(mpq_ptr q)
1066 { mpz_add(mpq_numref(q), mpq_numref(q), mpq_denref(q)); }
1067 static void eval(mpfr_ptr f) { mpfr_add_ui(f, f, 1, MpFrC::get_rnd()); }
1068};
1069
1071{
1072 static void eval(mpz_ptr z) { mpz_sub_ui(z, z, 1); }
1073 static void eval(mpq_ptr q)
1074 { mpz_sub(mpq_numref(q), mpq_numref(q), mpq_denref(q)); }
1075 static void eval(mpfr_ptr f) { mpfr_sub_ui(f, f, 1, MpFrC::get_rnd()); }
1076};
1077
1079{
1080 static void eval(mpz_ptr z, mpz_srcptr w) { mpz_abs(z, w); }
1081 static void eval(mpq_ptr q, mpq_srcptr r) { mpq_abs(q, r); }
1082 static void eval(mpfr_ptr f, mpfr_srcptr g)
1083 { mpfr_abs(f, g, MpFrC::get_rnd()); }
1084};
1085
1086struct __gmp_dim_function // not in gmpxx
1087{
1088 static void eval(mpfr_ptr f, mpfr_srcptr g, mpfr_srcptr h)
1089 { mpfr_dim(f, g, h, MpFrC::get_rnd()); }
1090};
1091
1092struct __gmp_rint_function // not in gmpxx
1093{
1094 static void eval(mpfr_ptr f, mpfr_srcptr g)
1095 { mpfr_rint(f, g, MpFrC::get_rnd()); }
1096};
1097
1099{
1100 static void eval(mpfr_ptr f, mpfr_srcptr g) { mpfr_trunc(f, g); }
1101};
1102
1104{
1105 static void eval(mpfr_ptr f, mpfr_srcptr g) { mpfr_floor(f, g); }
1106};
1107
1109{
1110 static void eval(mpfr_ptr f, mpfr_srcptr g) { mpfr_ceil(f, g); }
1111};
1112
1113struct __gmp_sqr_function // not in gmpxx
1114{
1115 static void eval(mpfr_ptr f, mpfr_srcptr g)
1116 { mpfr_sqr(f, g, MpFrC::get_rnd()); }
1117};
1118
1120{
1121 static void eval(mpz_ptr z, mpz_srcptr w) { mpz_sqrt(z, w); }
1122 static void eval(mpfr_ptr f, mpfr_srcptr g)
1123 { mpfr_sqrt(f, g, MpFrC::get_rnd()); }
1124};
1125
1126struct __gmp_cbrt_function // not in gmpxx
1127{
1128 static void eval(mpfr_ptr f, mpfr_srcptr g)
1129 { mpfr_cbrt(f, g, MpFrC::get_rnd()); }
1130};
1131
1132struct __gmp_root_function // not in gmpxx
1133{
1134 static void eval(mpfr_ptr f, mpfr_srcptr g, unsigned long int l)
1135 {
1136#if MPFR_VERSION_MAJOR >= 4
1137 mpfr_rootn_ui(f, g, l, MpFrC::get_rnd()); // New API (MPFR >= 4.0)
1138#else
1139 mpfr_root(f, g, l, MpFrC::get_rnd()); // Legacy API (MPFR < 4.0)
1140#endif
1141 }
1142};
1143
1144struct __gmp_pow_function // not in gmpxx
1145{
1146 static void eval(mpfr_ptr f, mpfr_srcptr g, mpfr_srcptr h)
1147 { mpfr_pow(f, g, h, MpFrC::get_rnd()); }
1148 static void eval(mpfr_ptr f, mpfr_srcptr g, unsigned long int l)
1149 { mpfr_pow_ui(f, g, l, MpFrC::get_rnd()); }
1150 static void eval(mpfr_ptr f, mpfr_srcptr g, long int l)
1151 { mpfr_pow_si(f, g, l, MpFrC::get_rnd()); }
1152 static void eval(mpfr_ptr f, mpfr_srcptr g, mpz_srcptr z)
1153 { mpfr_pow_z(f, g, z, MpFrC::get_rnd()); }
1154 static void eval(mpfr_ptr f, unsigned long int l, mpfr_srcptr h)
1155 { mpfr_ui_pow(f, l, h, MpFrC::get_rnd()); }
1156 static void eval(mpfr_ptr f, unsigned long int l, unsigned long int h)
1157 { mpfr_ui_pow_ui(f, l, h, MpFrC::get_rnd()); }
1158};
1159
1160struct __gmp_log_function // not in gmpxx
1161{
1162 static void eval(mpfr_ptr f, mpfr_srcptr g)
1163 { mpfr_log(f, g, MpFrC::get_rnd()); }
1164};
1165
1166struct __gmp_log2_function // not in gmpxx
1167{
1168 static void eval(mpfr_ptr f, mpfr_srcptr g)
1169 { mpfr_log2(f, g, MpFrC::get_rnd()); }
1170};
1171
1172struct __gmp_log10_function // not in gmpxx
1173{
1174 static void eval(mpfr_ptr f, mpfr_srcptr g)
1175 { mpfr_log10(f, g, MpFrC::get_rnd()); }
1176};
1177
1178struct __gmp_exp_function // not in gmpxx
1179{
1180 static void eval(mpfr_ptr f, mpfr_srcptr g)
1181 { mpfr_exp(f, g, MpFrC::get_rnd()); }
1182};
1183
1184struct __gmp_exp2_function // not in gmpxx
1185{
1186 static void eval(mpfr_ptr f, mpfr_srcptr g)
1187 { mpfr_exp2(f, g, MpFrC::get_rnd()); }
1188};
1189
1190struct __gmp_exp10_function // not in gmpxx
1191{
1192 static void eval(mpfr_ptr f, mpfr_srcptr g)
1193 { mpfr_exp10(f, g, MpFrC::get_rnd()); }
1194};
1195
1196struct __gmp_cos_function // not in gmpxx
1197{
1198 static void eval(mpfr_ptr f, mpfr_srcptr g)
1199 { mpfr_cos(f, g, MpFrC::get_rnd()); }
1200};
1201
1202struct __gmp_sin_function // not in gmpxx
1203{
1204 static void eval(mpfr_ptr f, mpfr_srcptr g)
1205 { mpfr_sin(f, g, MpFrC::get_rnd()); }
1206};
1207
1208struct __gmp_tan_function // not in gmpxx
1209{
1210 static void eval(mpfr_ptr f, mpfr_srcptr g)
1211 { mpfr_tan(f, g, MpFrC::get_rnd()); }
1212};
1213
1214struct __gmp_sec_function // not in gmpxx
1215{
1216 static void eval(mpfr_ptr f, mpfr_srcptr g)
1217 { mpfr_sec(f, g, MpFrC::get_rnd()); }
1218};
1219
1220struct __gmp_csc_function // not in gmpxx
1221{
1222 static void eval(mpfr_ptr f, mpfr_srcptr g)
1223 { mpfr_csc(f, g, MpFrC::get_rnd()); }
1224};
1225
1226struct __gmp_cot_function // not in gmpxx
1227{
1228 static void eval(mpfr_ptr f, mpfr_srcptr g)
1229 { mpfr_cot(f, g, MpFrC::get_rnd()); }
1230};
1231
1232struct __gmp_acos_function // not in gmpxx
1233{
1234 static void eval(mpfr_ptr f, mpfr_srcptr g)
1235 { mpfr_acos(f, g, MpFrC::get_rnd()); }
1236};
1237
1238struct __gmp_asin_function // not in gmpxx
1239{
1240 static void eval(mpfr_ptr f, mpfr_srcptr g)
1241 { mpfr_asin(f, g, MpFrC::get_rnd()); }
1242};
1243
1244struct __gmp_atan_function // not in gmpxx
1245{
1246 static void eval(mpfr_ptr f, mpfr_srcptr g)
1247 { mpfr_atan(f, g, MpFrC::get_rnd()); }
1248};
1249
1250struct __gmp_atan2_function // not in gmpxx
1251{
1252 static void eval(mpfr_ptr f, mpfr_srcptr g, mpfr_srcptr h)
1253 { mpfr_atan2(f, g, h, MpFrC::get_rnd()); }
1254};
1255
1256struct __gmp_cosh_function // not in gmpxx
1257{
1258 static void eval(mpfr_ptr f, mpfr_srcptr g)
1259 { mpfr_cosh(f, g, MpFrC::get_rnd()); }
1260};
1261
1262struct __gmp_sinh_function // not in gmpxx
1263{
1264 static void eval(mpfr_ptr f, mpfr_srcptr g)
1265 { mpfr_sinh(f, g, MpFrC::get_rnd()); }
1266};
1267
1268struct __gmp_tanh_function // not in gmpxx
1269{
1270 static void eval(mpfr_ptr f, mpfr_srcptr g)
1271 { mpfr_tanh(f, g, MpFrC::get_rnd()); }
1272};
1273
1274struct __gmp_sech_function // not in gmpxx
1275{
1276 static void eval(mpfr_ptr f, mpfr_srcptr g)
1277 { mpfr_sech(f, g, MpFrC::get_rnd()); }
1278};
1279
1280struct __gmp_csch_function // not in gmpxx
1281{
1282 static void eval(mpfr_ptr f, mpfr_srcptr g)
1283 { mpfr_csch(f, g, MpFrC::get_rnd()); }
1284};
1285
1286struct __gmp_coth_function // not in gmpxx
1287{
1288 static void eval(mpfr_ptr f, mpfr_srcptr g)
1289 { mpfr_coth(f, g, MpFrC::get_rnd()); }
1290};
1291
1292struct __gmp_acosh_function // not in gmpxx
1293{
1294 static void eval(mpfr_ptr f, mpfr_srcptr g)
1295 { mpfr_acosh(f, g, MpFrC::get_rnd()); }
1296};
1297
1298struct __gmp_asinh_function // not in gmpxx
1299{
1300 static void eval(mpfr_ptr f, mpfr_srcptr g)
1301 { mpfr_asinh(f, g, MpFrC::get_rnd()); }
1302};
1303
1304struct __gmp_atanh_function // not in gmpxx
1305{
1306 static void eval(mpfr_ptr f, mpfr_srcptr g)
1307 { mpfr_atanh(f, g, MpFrC::get_rnd()); }
1308};
1309
1310struct __gmp_fac_ui_function // not in gmpxx
1311{
1312 static void eval(mpfr_ptr f, unsigned long int l)
1313 { mpfr_fac_ui(f, l, MpFrC::get_rnd()); }
1314};
1315
1316struct __gmp_log1p_function // not in gmpxx
1317{
1318 static void eval(mpfr_ptr f, mpfr_srcptr g)
1319 { mpfr_log1p(f, g, MpFrC::get_rnd()); }
1320};
1321
1322struct __gmp_expm1_function // not in gmpxx
1323{
1324 static void eval(mpfr_ptr f, mpfr_srcptr g)
1325 { mpfr_expm1(f, g, MpFrC::get_rnd()); }
1326};
1327
1328struct __gmp_eint_function // not in gmpxx
1329{
1330 static void eval(mpfr_ptr f, mpfr_srcptr g)
1331 { mpfr_eint(f, g, MpFrC::get_rnd()); }
1332};
1333
1334struct __gmp_gamma_function // not in gmpxx
1335{
1336 static void eval(mpfr_ptr f, mpfr_srcptr g)
1337 { mpfr_gamma(f, g, MpFrC::get_rnd()); }
1338};
1339
1340struct __gmp_lngamma_function // not in gmpxx
1341{
1342 static void eval(mpfr_ptr f, mpfr_srcptr g)
1343 { mpfr_lngamma(f, g, MpFrC::get_rnd()); }
1344};
1345
1346struct __gmp_lgamma_function // not in gmpxx
1347{
1348 static void eval(mpfr_ptr f, mpfr_srcptr g)
1349 { int sgnp; // discarded
1350 mpfr_lgamma(f, &sgnp, g, MpFrC::get_rnd()); }
1351};
1352
1353struct __gmp_zeta_function // not in gmpxx
1354{
1355 static void eval(mpfr_ptr f, mpfr_srcptr g)
1356 { mpfr_zeta(f, g, MpFrC::get_rnd()); }
1357 static void eval(mpfr_ptr f, unsigned long int l)
1358 { mpfr_zeta_ui(f, l, MpFrC::get_rnd()); }
1359};
1360
1361struct __gmp_erf_function // not in gmpxx
1362{
1363 static void eval(mpfr_ptr f, mpfr_srcptr g)
1364 { mpfr_erf(f, g, MpFrC::get_rnd()); }
1365};
1366
1367struct __gmp_erfc_function // not in gmpxx
1368{
1369 static void eval(mpfr_ptr f, mpfr_srcptr g)
1370 { mpfr_erfc(f, g, MpFrC::get_rnd()); }
1371};
1372
1373struct __gmp_j0_function // not in gmpxx
1374{
1375 static void eval(mpfr_ptr f, mpfr_srcptr g)
1376 { mpfr_j0(f, g, MpFrC::get_rnd()); }
1377};
1378
1379struct __gmp_j1_function // not in gmpxx
1380{
1381 static void eval(mpfr_ptr f, mpfr_srcptr g)
1382 { mpfr_j1(f, g, MpFrC::get_rnd()); }
1383};
1384
1385struct __gmp_jn_function // not in gmpxx
1386{
1387// static void eval(mpfr_ptr f, mpfr_srcptr g, long h)
1388// { mpfr_jn(f, h, g, MpFrC::get_rnd()); }
1389 static void eval(mpfr_ptr f, long h, mpfr_srcptr g)
1390 { mpfr_jn(f, h, g, MpFrC::get_rnd()); }
1391};
1392
1393struct __gmp_y0_function // not in gmpxx
1394{
1395 static void eval(mpfr_ptr f, mpfr_srcptr g)
1396 { mpfr_y0(f, g, MpFrC::get_rnd()); }
1397};
1398
1399struct __gmp_y1_function // not in gmpxx
1400{
1401 static void eval(mpfr_ptr f, mpfr_srcptr g)
1402 { mpfr_y1(f, g, MpFrC::get_rnd()); }
1403};
1404
1405struct __gmp_yn_function // not in gmpxx
1406{
1407// static void eval(mpfr_ptr f, mpfr_srcptr g, long h)
1408// { mpfr_yn(f, h, g, MpFrC::get_rnd()); }
1409 static void eval(mpfr_ptr f, long h, mpfr_srcptr g)
1410 { mpfr_yn(f, h, g, MpFrC::get_rnd()); }
1411};
1412
1413struct __gmp_agm_function // not in gmpxx
1414{
1415 static void eval(mpfr_ptr f, mpfr_srcptr g, mpfr_srcptr h)
1416 { mpfr_agm(f, g, h, MpFrC::get_rnd()); }
1417};
1418
1419struct __gmp_const_log2_function // not in gmpxx
1420{
1421 static void eval(mpfr_ptr f)
1422 { mpfr_const_log2(f, MpFrC::get_rnd()); }
1423};
1424
1425struct __gmp_const_pi_function // not in gmpxx
1426{
1427 static void eval(mpfr_ptr f)
1428 { mpfr_const_pi(f, MpFrC::get_rnd()); }
1429};
1430
1431struct __gmp_const_euler_function // not in gmpxx
1432{
1433 static void eval(mpfr_ptr f)
1434 { mpfr_const_euler(f, MpFrC::get_rnd()); }
1435};
1436
1437struct __gmp_const_catalan_function // not in gmpxx
1438{
1439 static void eval(mpfr_ptr f)
1440 { mpfr_const_catalan(f, MpFrC::get_rnd()); }
1441};
1442
1443struct __gmp_max_function // not in gmpxx
1444{
1445 static void eval(mpfr_ptr f, mpfr_srcptr g, mpfr_srcptr h)
1446 { mpfr_max(f, g, h, MpFrC::get_rnd()); }
1447};
1448
1449struct __gmp_min_function // not in gmpxx
1450{
1451 static void eval(mpfr_ptr f, mpfr_srcptr g, mpfr_srcptr h)
1452 { mpfr_min(f, g, h, MpFrC::get_rnd()); }
1453};
1454
1456{
1457 static void eval(mpfr_ptr f, mpfr_srcptr g, mpfr_srcptr h)
1458 {
1459 mpfr_hypot(f, g, h, MpFrC::get_rnd());
1460 }
1461
1462 static void eval(mpfr_ptr f, mpfr_srcptr g, unsigned long int l)
1463 {
1464 mpfr_set_ui(f, l, MpFrC::get_rnd());
1465 mpfr_hypot(f, g, f, MpFrC::get_rnd());
1466 }
1467 static void eval(mpfr_ptr f, unsigned long int l, mpfr_srcptr g)
1468 {
1469 mpfr_set_ui(f, l, MpFrC::get_rnd());
1470 mpfr_hypot(f, g, f, MpFrC::get_rnd());
1471 }
1472 static void eval(mpfr_ptr f, mpfr_srcptr g, signed long int l)
1473 {
1474 mpfr_set_si(f, l, MpFrC::get_rnd());
1475 mpfr_hypot(f, g, f, MpFrC::get_rnd());
1476 }
1477 static void eval(mpfr_ptr f, signed long int l, mpfr_srcptr g)
1478 {
1479 mpfr_set_si(f, l, MpFrC::get_rnd());
1480 mpfr_hypot(f, g, f, MpFrC::get_rnd());
1481 }
1482 static void eval(mpfr_ptr f, mpfr_srcptr g, double d)
1483 {
1484 mpfr_set_d(f, d, MpFrC::get_rnd());
1485 mpfr_hypot(f, g, f, MpFrC::get_rnd());
1486 }
1487 static void eval(mpfr_ptr f, double d, mpfr_srcptr g)
1488 {
1489 mpfr_set_d(f, d, MpFrC::get_rnd());
1490 mpfr_hypot(f, g, f, MpFrC::get_rnd());
1491 }
1492};
1493
1494struct __gmp_frac_function // not in gmpxx
1495{
1496 static void eval(mpfr_ptr f, mpfr_srcptr g)
1497 { mpfr_frac(f, g, MpFrC::get_rnd()); }
1498};
1499
1500struct __gmp_remainder_function // not in gmpxx
1501{
1502 static void eval(mpfr_ptr f, mpfr_srcptr g, mpfr_srcptr h)
1503 { mpfr_remainder(f, g, h, MpFrC::get_rnd()); }
1504};
1505
1507{
1508 static int eval(mpz_srcptr z) { return mpz_sgn(z); }
1509 static int eval(mpq_srcptr q) { return mpq_sgn(q); }
1510 static int eval(mpfr_srcptr f) { return mpfr_sgn(f); }
1511};
1512
1514{
1515 static int eval(mpz_srcptr z, mpz_srcptr w) { return mpz_cmp(z, w); }
1516
1517 static int eval(mpz_srcptr z, unsigned long int l)
1518 { return mpz_cmp_ui(z, l); }
1519 static int eval(unsigned long int l, mpz_srcptr z)
1520 { return -mpz_cmp_ui(z, l); }
1521 static int eval(mpz_srcptr z, signed long int l)
1522 { return mpz_cmp_si(z, l); }
1523 static int eval(signed long int l, mpz_srcptr z)
1524 { return -mpz_cmp_si(z, l); }
1525 static int eval(mpz_srcptr z, double d)
1526 { return mpz_cmp_d(z, d); }
1527 static int eval(double d, mpz_srcptr z)
1528 { return -mpz_cmp_d(z, d); }
1529
1530 static int eval(mpq_srcptr q, mpq_srcptr r) { return mpq_cmp(q, r); }
1531
1532 static int eval(mpq_srcptr q, unsigned long int l)
1533 { return mpq_cmp_ui(q, l, 1); }
1534 static int eval(unsigned long int l, mpq_srcptr q)
1535 { return -mpq_cmp_ui(q, l, 1); }
1536 static int eval(mpq_srcptr q, signed long int l)
1537 { return mpq_cmp_si(q, l, 1); }
1538 static int eval(signed long int l, mpq_srcptr q)
1539 { return -mpq_cmp_si(q, l, 1); }
1540 static int eval(mpq_srcptr q, double d)
1541 {
1542 int i;
1543 mpq_t temp;
1544 mpq_init(temp);
1545 mpq_set_d(temp, d);
1546 i = mpq_cmp(q, temp);
1547 mpq_clear(temp);
1548 return i;
1549 }
1550 static int eval(double d, mpq_srcptr q)
1551 {
1552 int i;
1553 mpq_t temp;
1554 mpq_init(temp);
1555 mpq_set_d(temp, d);
1556 i = mpq_cmp(temp, q);
1557 mpq_clear(temp);
1558 return i;
1559 }
1560
1561 static int eval(mpfr_srcptr f, mpfr_srcptr g) { return mpfr_cmp(f, g); }
1562
1563 static int eval(mpfr_srcptr f, unsigned long int l)
1564 { return mpfr_cmp_ui(f, l); }
1565 static int eval(unsigned long int l, mpfr_srcptr f)
1566 { return -mpfr_cmp_ui(f, l); }
1567 static int eval(mpfr_srcptr f, signed long int l)
1568 { return mpfr_cmp_si(f, l); }
1569 static int eval(signed long int l, mpfr_srcptr f)
1570 { return -mpfr_cmp_si(f, l); }
1571 static int eval(mpfr_srcptr f, double d)
1572 { return mpfr_cmp_d(f, d); }
1573 static int eval(double d, mpfr_srcptr f)
1574 { return -mpfr_cmp_d(f, d); }
1575};
1576
1577struct __gmp_ternary_addmul // z = w + v * u
1578{
1579 static void eval(mpz_ptr z, mpz_srcptr w, mpz_srcptr v, mpz_srcptr u)
1580 { mpz_set(z, w); mpz_addmul(z, v, u); }
1581
1582 static void eval(mpz_ptr z, mpz_srcptr w, mpz_srcptr v, unsigned long int l)
1583 { mpz_set(z, w); mpz_addmul_ui(z, v, l); }
1584 static void eval(mpz_ptr z, mpz_srcptr w, unsigned long int l, mpz_srcptr v)
1585 { mpz_set(z, w); mpz_addmul_ui(z, v, l); }
1586 static void eval(mpz_ptr z, mpz_srcptr w, mpz_srcptr v, signed long int l)
1587 {
1588 mpz_set(z, w);
1589 if (l >= 0)
1590 mpz_addmul_ui(z, v, l);
1591 else
1592 mpz_submul_ui(z, v, -l);
1593 }
1594 static void eval(mpz_ptr z, mpz_srcptr w, signed long int l, mpz_srcptr v)
1595 {
1596 mpz_set(z, w);
1597 if (l >= 0)
1598 mpz_addmul_ui(z, v, l);
1599 else
1600 mpz_submul_ui(z, v, -l);
1601 }
1602 static void eval(mpz_ptr z, mpz_srcptr w, mpz_srcptr v, double d)
1603 {
1604 mpz_t temp;
1605 mpz_init_set_d(temp, d);
1606 mpz_set(z, w);
1607 mpz_addmul(z, v, temp);
1608 mpz_clear(temp);
1609 }
1610 static void eval(mpz_ptr z, mpz_srcptr w, double d, mpz_srcptr v)
1611 {
1612 mpz_t temp;
1613 mpz_init_set_d(temp, d);
1614 mpz_set(z, w);
1615 mpz_addmul(z, temp, v);
1616 mpz_clear(temp);
1617 }
1618};
1619
1620struct __gmp_ternary_submul // z = w - v * u
1621{
1622 static void eval(mpz_ptr z, mpz_srcptr w, mpz_srcptr v, mpz_srcptr u)
1623 { mpz_set(z, w); mpz_submul(z, v, u); }
1624
1625 static void eval(mpz_ptr z, mpz_srcptr w, mpz_srcptr v, unsigned long int l)
1626 { mpz_set(z, w); mpz_submul_ui(z, v, l); }
1627 static void eval(mpz_ptr z, mpz_srcptr w, unsigned long int l, mpz_srcptr v)
1628 { mpz_set(z, w); mpz_submul_ui(z, v, l); }
1629 static void eval(mpz_ptr z, mpz_srcptr w, mpz_srcptr v, signed long int l)
1630 {
1631 mpz_set(z, w);
1632 if (l >= 0)
1633 mpz_submul_ui(z, v, l);
1634 else
1635 mpz_addmul_ui(z, v, -l);
1636 }
1637 static void eval(mpz_ptr z, mpz_srcptr w, signed long int l, mpz_srcptr v)
1638 {
1639 mpz_set(z, w);
1640 if (l >= 0)
1641 mpz_submul_ui(z, v, l);
1642 else
1643 mpz_addmul_ui(z, v, -l);
1644 }
1645 static void eval(mpz_ptr z, mpz_srcptr w, mpz_srcptr v, double d)
1646 {
1647 mpz_t temp;
1648 mpz_init_set_d(temp, d);
1649 mpz_set(z, w);
1650 mpz_submul(z, v, temp);
1651 mpz_clear(temp);
1652 }
1653 static void eval(mpz_ptr z, mpz_srcptr w, double d, mpz_srcptr v)
1654 {
1655 mpz_t temp;
1656 mpz_init_set_d(temp, d);
1657 mpz_set(z, w);
1658 mpz_submul(z, temp, v);
1659 mpz_clear(temp);
1660 }
1661};
1662
1664{
1665 static void eval(mpz_ptr z, gmp_randstate_t s, unsigned long int l)
1666 { mpz_urandomb(z, s, l); }
1667 static void eval(mpz_ptr z, gmp_randstate_t s, mpz_srcptr w)
1668 { mpz_urandomm(z, s, w); }
1669 static void eval(mpfr_ptr f, gmp_randstate_t s, unsigned long int prec)
1670 {
1671 // note code change from gmpxx.h
1672 unsigned long int precf = mpfr_get_prec(f);
1673 if (prec == precf) {
1674 mpfr_urandomb(f, s);
1675 }
1676 else {
1677 mpfr_set_prec(f, prec);
1678 mpfr_urandomb(f, s);
1679 mpfr_prec_round(f, precf, MpFrC::get_rnd());
1680 }
1681 }
1682};
1683
1684
1685/**************** Auxiliary classes ****************/
1686
1687/* this is much the same as gmp_allocated_string in gmp-impl.h
1688 since gmp-impl.h is not publicly available, I redefine it here
1689 I use a different name to avoid possible clashes */
1691{
1692 char *str;
1693 __gmp_alloc_cstring(char *s) { str = s; }
1695 {
1696 void (*freefunc) (void *, size_t);
1697 mp_get_memory_functions (nullptr, nullptr, &freefunc);
1698 (*freefunc) (str, std::strlen(str)+1);
1699 }
1700};
1701
1702
1703// general expression template class
1704template <class T, class U>
1706
1707
1708// templates for resolving expression types
1709template <class T>
1711{
1712 typedef T ref_type;
1713};
1714
1715template <class T, class U>
1717{
1719};
1720
1721
1722template <class T, class U = T>
1724
1725template <>
1727{
1728 typedef mpz_t value_type;
1729 typedef mpz_ptr ptr_type;
1730};
1731
1732template <>
1734{
1735 typedef mpq_t value_type;
1736 typedef mpq_ptr ptr_type;
1737};
1738
1739template <>
1741{
1742 typedef mpfr_t value_type;
1743 typedef mpfr_ptr ptr_type;
1744};
1745
1746template <>
1747struct __gmp_resolve_expr<mpz_t, mpq_t>
1748{
1749 typedef mpq_t value_type;
1750};
1751
1752template <>
1753struct __gmp_resolve_expr<mpq_t, mpz_t>
1754{
1755 typedef mpq_t value_type;
1756};
1757
1758template <>
1759struct __gmp_resolve_expr<mpz_t, mpfr_t>
1760{
1761 typedef mpfr_t value_type;
1762};
1763
1764template <>
1765struct __gmp_resolve_expr<mpfr_t, mpz_t>
1766{
1767 typedef mpfr_t value_type;
1768};
1769
1770template <>
1771struct __gmp_resolve_expr<mpq_t, mpfr_t>
1772{
1773 typedef mpfr_t value_type;
1774};
1775
1776template <>
1777struct __gmp_resolve_expr<mpfr_t, mpq_t>
1778{
1779 typedef mpfr_t value_type;
1780};
1781
1782
1783
1784template <class T, class U, class V>
1789
1790template <class T>
1791struct __gmp_resolve_temp<T, T, T>
1792{
1794};
1795
1796
1797// classes for evaluating unary and binary expressions
1798template <class T, class Op>
1800{
1801 // const T &val; // <-- gmpxx implementation
1802 typename __gmp_resolve_ref<T>::ref_type val; // modification
1803
1804 __gmp_unary_expr(const T &v) : val(v) { }
1805private:
1807};
1808
1809template <class T, class U, class Op>
1811{
1814
1815 __gmp_binary_expr(const T &v1, const U &v2) : val1(v1), val2(v2) { }
1816private:
1818};
1819
1820// not in gmpxx
1821template <class Op>
1823{
1825};
1826
1827
1828// functions for evaluating expressions
1829template <class T, class U>
1830void __gmp_set_expr(mpz_ptr, const __gmp_expr<T, U> &);
1831template <class T, class U>
1832void __gmp_set_expr(mpq_ptr, const __gmp_expr<T, U> &);
1833template <class T, class U>
1834void __gmp_set_expr(mpfr_ptr, const __gmp_expr<T, U> &);
1835
1836
1837/**************** Macros for in-class declarations ****************/
1838/* This is just repetitive code that is easier to maintain if it's written
1839 only once */
1840
1841#define __GMPP_DECLARE_COMPOUND_OPERATOR(fun) \
1842 template <class T, class U> \
1843 __gmp_expr<value_type, value_type> & fun(const __gmp_expr<T, U> &);
1844
1845#define __GMPN_DECLARE_COMPOUND_OPERATOR(fun) \
1846 __gmp_expr & fun(signed char); \
1847 __gmp_expr & fun(unsigned char); \
1848 __gmp_expr & fun(signed int); \
1849 __gmp_expr & fun(unsigned int); \
1850 __gmp_expr & fun(signed short int); \
1851 __gmp_expr & fun(unsigned short int); \
1852 __gmp_expr & fun(signed long int); \
1853 __gmp_expr & fun(unsigned long int); \
1854 __gmp_expr & fun(float); \
1855 __gmp_expr & fun(double); \
1856 __gmp_expr & fun(long double);
1857
1858#define __GMP_DECLARE_COMPOUND_OPERATOR(fun) \
1859__GMPP_DECLARE_COMPOUND_OPERATOR(fun) \
1860__GMPN_DECLARE_COMPOUND_OPERATOR(fun)
1861
1862#define __GMP_DECLARE_COMPOUND_OPERATOR_UI(fun) \
1863 __gmp_expr & fun(unsigned long int);
1864
1865#define __GMP_DECLARE_INCREMENT_OPERATOR(fun) \
1866 inline __gmp_expr & fun(); \
1867 inline __gmp_expr fun(int);
1868
1869
1870/**************** mpz_class -- wrapper for mpz_t ****************/
1871
1872template <>
1873class __gmp_expr<mpz_t, mpz_t>
1874{
1875private:
1876 typedef mpz_t value_type;
1878public:
1879 unsigned long int get_prec() const { return mpfr_get_default_prec(); }
1880
1881 // constructors and destructor
1882 __gmp_expr() { mpz_init(mp); }
1883
1884 __gmp_expr(const __gmp_expr &z) { mpz_init_set(mp, z.mp); }
1885 template <class T, class U>
1887 { mpz_init(mp); __gmp_set_expr(mp, expr); }
1888
1889 __gmp_expr(signed char c) { mpz_init_set_si(mp, c); }
1890 __gmp_expr(unsigned char c) { mpz_init_set_ui(mp, c); }
1891
1892 __gmp_expr(signed int i) { mpz_init_set_si(mp, i); }
1893 __gmp_expr(unsigned int i) { mpz_init_set_ui(mp, i); }
1894
1895 __gmp_expr(signed short int s) { mpz_init_set_si(mp, s); }
1896 __gmp_expr(unsigned short int s) { mpz_init_set_ui(mp, s); }
1897
1898 __gmp_expr(signed long int l) { mpz_init_set_si(mp, l); }
1899 __gmp_expr(unsigned long int l) { mpz_init_set_ui(mp, l); }
1900
1901 __gmp_expr(float f) { mpz_init_set_d(mp, f); }
1902 __gmp_expr(double d) { mpz_init_set_d(mp, d); }
1903 // __gmp_expr(long double ld) { mpz_init_set_d(mp, ld); }
1904
1905 explicit __gmp_expr(const char *s)
1906 {
1907 if (mpz_init_set_str (mp, s, 0) != 0)
1908 {
1909 mpz_clear (mp);
1910 throw std::invalid_argument ("mpz_set_str");
1911 }
1912 }
1913 __gmp_expr(const char *s, int base)
1914 {
1915 if (mpz_init_set_str (mp, s, base) != 0)
1916 {
1917 mpz_clear (mp);
1918 throw std::invalid_argument ("mpz_set_str");
1919 }
1920 }
1921 explicit __gmp_expr(const std::string &s)
1922 {
1923 if (mpz_init_set_str (mp, s.c_str(), 0) != 0)
1924 {
1925 mpz_clear (mp);
1926 throw std::invalid_argument ("mpz_set_str");
1927 }
1928 }
1929 __gmp_expr(const std::string &s, int base)
1930 {
1931 if (mpz_init_set_str(mp, s.c_str(), base) != 0)
1932 {
1933 mpz_clear (mp);
1934 throw std::invalid_argument ("mpz_set_str");
1935 }
1936 }
1937
1938 explicit __gmp_expr(mpz_srcptr z) { mpz_init_set(mp, z); }
1939
1940 ~__gmp_expr() { mpz_clear(mp); }
1941
1942 // assignment operators
1944 { mpz_set(mp, z.mp); return *this; }
1945 template <class T, class U>
1947 { __gmp_set_expr(mp, expr); return *this; }
1948
1949 __gmp_expr & operator=(signed char c) { mpz_set_si(mp, c); return *this; }
1950 __gmp_expr & operator=(unsigned char c) { mpz_set_ui(mp, c); return *this; }
1951
1952 __gmp_expr & operator=(signed int i) { mpz_set_si(mp, i); return *this; }
1953 __gmp_expr & operator=(unsigned int i) { mpz_set_ui(mp, i); return *this; }
1954
1955 __gmp_expr & operator=(signed short int s)
1956 { mpz_set_si(mp, s); return *this; }
1957 __gmp_expr & operator=(unsigned short int s)
1958 { mpz_set_ui(mp, s); return *this; }
1959
1960 __gmp_expr & operator=(signed long int l)
1961 { mpz_set_si(mp, l); return *this; }
1962 __gmp_expr & operator=(unsigned long int l)
1963 { mpz_set_ui(mp, l); return *this; }
1964
1965 __gmp_expr & operator=(float f) { mpz_set_d(mp, f); return *this; }
1966 __gmp_expr & operator=(double d) { mpz_set_d(mp, d); return *this; }
1967 // __gmp_expr & operator=(long double ld)
1968 // { mpz_set_ld(mp, ld); return *this; }
1969
1970 __gmp_expr & operator=(const char *s)
1971 {
1972 if (mpz_set_str (mp, s, 0) != 0)
1973 throw std::invalid_argument ("mpz_set_str");
1974 return *this;
1975 }
1976 __gmp_expr & operator=(const std::string &s)
1977 {
1978 if (mpz_set_str(mp, s.c_str(), 0) != 0)
1979 throw std::invalid_argument ("mpz_set_str");
1980 return *this;
1981 }
1982
1983 // string input/output functions
1984 int set_str(const char *s, int base)
1985 { return mpz_set_str(mp, s, base); }
1986 int set_str(const std::string &s, int base)
1987 { return mpz_set_str(mp, s.c_str(), base); }
1988 std::string get_str(int base = 10) const
1989 {
1990 __gmp_alloc_cstring temp(mpz_get_str(0, base, mp));
1991 return std::string(temp.str);
1992 }
1993
1994 // conversion functions
1995 mpz_srcptr __get_mp() const { return mp; }
1996 mpz_ptr __get_mp() { return mp; }
1997 mpz_srcptr get_mpz_t() const { return mp; }
1998 mpz_ptr get_mpz_t() { return mp; }
1999
2000 signed long int get_si() const { return mpz_get_si(mp); }
2001 unsigned long int get_ui() const { return mpz_get_ui(mp); }
2002 double get_d() const { return mpz_get_d(mp); }
2003
2004 // bool fits_schar_p() const { return mpz_fits_schar_p(mp); }
2005 // bool fits_uchar_p() const { return mpz_fits_uchar_p(mp); }
2006 bool fits_sint_p() const { return mpz_fits_sint_p(mp); }
2007 bool fits_uint_p() const { return mpz_fits_uint_p(mp); }
2008 bool fits_sshort_p() const { return mpz_fits_sshort_p(mp); }
2009 bool fits_ushort_p() const { return mpz_fits_ushort_p(mp); }
2010 bool fits_slong_p() const { return mpz_fits_slong_p(mp); }
2011 bool fits_ulong_p() const { return mpz_fits_ulong_p(mp); }
2012 // bool fits_float_p() const { return mpz_fits_float_p(mp); }
2013 // bool fits_double_p() const { return mpz_fits_double_p(mp); }
2014 // bool fits_ldouble_p() const { return mpz_fits_ldouble_p(mp); }
2015
2016 // member operators
2022
2026
2029
2032};
2033
2034typedef __gmp_expr<mpz_t, mpz_t> mpz_class;
2035
2036
2037/**************** mpq_class -- wrapper for mpq_t ****************/
2038
2039template <>
2040class __gmp_expr<mpq_t, mpq_t>
2041{
2042private:
2043 typedef mpq_t value_type;
2045public:
2046 unsigned long int get_prec() const { return mpfr_get_default_prec(); }
2047 void canonicalize() { mpq_canonicalize(mp); }
2048
2049 // constructors and destructor
2050 __gmp_expr() { mpq_init(mp); }
2051
2052 __gmp_expr(const __gmp_expr &q) { mpq_init(mp); mpq_set(mp, q.mp); }
2053 template <class T, class U>
2055 { mpq_init(mp); __gmp_set_expr(mp, expr); }
2056
2057 __gmp_expr(signed char c) { mpq_init(mp); mpq_set_si(mp, c, 1); }
2058 __gmp_expr(unsigned char c) { mpq_init(mp); mpq_set_ui(mp, c, 1); }
2059
2060 __gmp_expr(signed int i) { mpq_init(mp); mpq_set_si(mp, i, 1); }
2061 __gmp_expr(unsigned int i) { mpq_init(mp); mpq_set_ui(mp, i, 1); }
2062
2063 __gmp_expr(signed short int s) { mpq_init(mp); mpq_set_si(mp, s, 1); }
2064 __gmp_expr(unsigned short int s) { mpq_init(mp); mpq_set_ui(mp, s, 1); }
2065
2066 __gmp_expr(signed long int l) { mpq_init(mp); mpq_set_si(mp, l, 1); }
2067 __gmp_expr(unsigned long int l) { mpq_init(mp); mpq_set_ui(mp, l, 1); }
2068
2069 __gmp_expr(float f) { mpq_init(mp); mpq_set_d(mp, f); }
2070 __gmp_expr(double d) { mpq_init(mp); mpq_set_d(mp, d); }
2071 // __gmp_expr(long double ld) { mpq_init(mp); mpq_set_ld(mp, ld); }
2072
2073 explicit __gmp_expr(const char *s)
2074 {
2075 mpq_init (mp);
2076 if (mpq_set_str (mp, s, 0) != 0)
2077 {
2078 mpq_clear (mp);
2079 throw std::invalid_argument ("mpq_set_str");
2080 }
2081 }
2082 __gmp_expr(const char *s, int base)
2083 {
2084 mpq_init (mp);
2085 if (mpq_set_str(mp, s, base) != 0)
2086 {
2087 mpq_clear (mp);
2088 throw std::invalid_argument ("mpq_set_str");
2089 }
2090 }
2091 explicit __gmp_expr(const std::string &s)
2092 {
2093 mpq_init (mp);
2094 if (mpq_set_str (mp, s.c_str(), 0) != 0)
2095 {
2096 mpq_clear (mp);
2097 throw std::invalid_argument ("mpq_set_str");
2098 }
2099 }
2100 __gmp_expr(const std::string &s, int base)
2101 {
2102 mpq_init(mp);
2103 if (mpq_set_str (mp, s.c_str(), base) != 0)
2104 {
2105 mpq_clear (mp);
2106 throw std::invalid_argument ("mpq_set_str");
2107 }
2108 }
2109 explicit __gmp_expr(mpq_srcptr q) { mpq_init(mp); mpq_set(mp, q); }
2110
2111 __gmp_expr(const mpz_class &num, const mpz_class &den)
2112 {
2113 mpq_init(mp);
2114 mpz_set(mpq_numref(mp), num.get_mpz_t());
2115 mpz_set(mpq_denref(mp), den.get_mpz_t());
2116 }
2117
2118 ~__gmp_expr() { mpq_clear(mp); }
2119
2120 // assignment operators
2122 { mpq_set(mp, q.mp); return *this; }
2123 template <class T, class U>
2125 { __gmp_set_expr(mp, expr); return *this; }
2126
2127 __gmp_expr & operator=(signed char c)
2128 { mpq_set_si(mp, c, 1); return *this; }
2129 __gmp_expr & operator=(unsigned char c)
2130 { mpq_set_ui(mp, c, 1); return *this; }
2131
2132 __gmp_expr & operator=(signed int i) { mpq_set_si(mp, i, 1); return *this; }
2133 __gmp_expr & operator=(unsigned int i)
2134 { mpq_set_ui(mp, i, 1); return *this; }
2135
2136 __gmp_expr & operator=(signed short int s)
2137 { mpq_set_si(mp, s, 1); return *this; }
2138 __gmp_expr & operator=(unsigned short int s)
2139 { mpq_set_ui(mp, s, 1); return *this; }
2140
2141 __gmp_expr & operator=(signed long int l)
2142 { mpq_set_si(mp, l, 1); return *this; }
2143 __gmp_expr & operator=(unsigned long int l)
2144 { mpq_set_ui(mp, l, 1); return *this; }
2145
2146 __gmp_expr & operator=(float f) { mpq_set_d(mp, f); return *this; }
2147 __gmp_expr & operator=(double d) { mpq_set_d(mp, d); return *this; }
2148 // __gmp_expr & operator=(long double ld)
2149 // { mpq_set_ld(mp, ld); return *this; }
2150
2151 __gmp_expr & operator=(const char *s)
2152 {
2153 if (mpq_set_str (mp, s, 0) != 0)
2154 throw std::invalid_argument ("mpq_set_str");
2155 return *this;
2156 }
2157 __gmp_expr & operator=(const std::string &s)
2158 {
2159 if (mpq_set_str(mp, s.c_str(), 0) != 0)
2160 throw std::invalid_argument ("mpq_set_str");
2161 return *this;
2162 }
2163
2164 // string input/output functions
2165 int set_str(const char *s, int base)
2166 { return mpq_set_str(mp, s, base); }
2167 int set_str(const std::string &s, int base)
2168 { return mpq_set_str(mp, s.c_str(), base); }
2169 std::string get_str(int base = 10) const
2170 {
2171 __gmp_alloc_cstring temp(mpq_get_str(0, base, mp));
2172 return std::string(temp.str);
2173 }
2174
2175 // conversion functions
2176
2177 // casting a reference to an mpz_t to mpz_class & is a dirty hack,
2178 // but works because the internal representation of mpz_class is
2179 // exactly an mpz_t
2180 const mpz_class & get_num() const
2181 { return reinterpret_cast<const mpz_class &>(*mpq_numref(mp)); }
2183 { return reinterpret_cast<mpz_class &>(*mpq_numref(mp)); }
2184 const mpz_class & get_den() const
2185 { return reinterpret_cast<const mpz_class &>(*mpq_denref(mp)); }
2187 { return reinterpret_cast<mpz_class &>(*mpq_denref(mp)); }
2188
2189 mpq_srcptr __get_mp() const { return mp; }
2190 mpq_ptr __get_mp() { return mp; }
2191 mpq_srcptr get_mpq_t() const { return mp; }
2192 mpq_ptr get_mpq_t() { return mp; }
2193
2194 mpz_srcptr get_num_mpz_t() const { return mpq_numref(mp); }
2195 mpz_ptr get_num_mpz_t() { return mpq_numref(mp); }
2196 mpz_srcptr get_den_mpz_t() const { return mpq_denref(mp); }
2197 mpz_ptr get_den_mpz_t() { return mpq_denref(mp); }
2198
2199 double get_d() const { return mpq_get_d(mp); }
2200
2201 // compound assignments
2206
2209
2212};
2213
2214typedef __gmp_expr<mpq_t, mpq_t> mpq_class;
2215
2216
2217/**************** mpfr_class -- wrapper for mpfr_t ****************/
2218
2219template <>
2220class __gmp_expr<mpfr_t, mpfr_t> : public MpFrC
2221{
2222private:
2223 typedef mpfr_t value_type;
2225public:
2226 unsigned long int get_prec() const { return mpfr_get_prec(mp); }
2227
2228 void set_prec(unsigned long int prec) { mpfr_set_prec(mp, prec); }
2229 void set_prec_raw(unsigned long int prec) { mpfr_set_prec_raw(mp, prec); }
2230 void prec_round(unsigned long int prec)
2231 { mpfr_prec_round(mp, prec, MpFrC::get_rnd()); }
2232
2233 // constructors and destructor
2234 // note that I have the default constructor be zero rather than NaN
2235 __gmp_expr() { mpfr_init(mp); mpfr_set_d(mp, 0.0, MpFrC::get_rnd()); }
2236
2238 { mpfr_init2(mp, f.get_prec()); mpfr_set(mp, f.mp, MpFrC::get_rnd()); }
2239 __gmp_expr(const __gmp_expr &f, unsigned long int prec)
2240 { mpfr_init2(mp, prec); mpfr_set(mp, f.mp, MpFrC::get_rnd()); }
2241 template <class T, class U>
2243 { mpfr_init2(mp, expr.get_prec()); __gmp_set_expr(mp, expr); }
2244 template <class T, class U>
2245 __gmp_expr(const __gmp_expr<T, U> &expr, unsigned long int prec)
2246 { mpfr_init2(mp, prec); __gmp_set_expr(mp, expr); }
2247
2248 __gmp_expr(signed char c)
2249 { mpfr_init_set_si(mp, c, MpFrC::get_rnd()); }
2250 __gmp_expr(signed char c, unsigned long int prec)
2251 { mpfr_init2(mp, prec); mpfr_set_si(mp, c, MpFrC::get_rnd()); }
2252 __gmp_expr(unsigned char c)
2253 { mpfr_init_set_ui(mp, c, MpFrC::get_rnd()); }
2254 __gmp_expr(unsigned char c, unsigned long int prec)
2255 { mpfr_init2(mp, prec); mpfr_set_ui(mp, c, MpFrC::get_rnd()); }
2256
2257 __gmp_expr(signed int i)
2258 { mpfr_init_set_si(mp, i, MpFrC::get_rnd()); }
2259 __gmp_expr(signed int i, unsigned long int prec)
2260 { mpfr_init2(mp, prec); mpfr_set_si(mp, i, MpFrC::get_rnd()); }
2261 __gmp_expr(unsigned int i)
2262 { mpfr_init_set_ui(mp, i, MpFrC::get_rnd()); }
2263 __gmp_expr(unsigned int i, unsigned long int prec)
2264 { mpfr_init2(mp, prec); mpfr_set_ui(mp, i, MpFrC::get_rnd()); }
2265
2266 __gmp_expr(signed short int s)
2267 { mpfr_init_set_si(mp, s, MpFrC::get_rnd()); }
2268 __gmp_expr(signed short int s, unsigned long int prec)
2269 { mpfr_init2(mp, prec); mpfr_set_si(mp, s, MpFrC::get_rnd()); }
2270 __gmp_expr(unsigned short int s)
2271 { mpfr_init_set_ui(mp, s, MpFrC::get_rnd()); }
2272 __gmp_expr(unsigned short int s, unsigned long int prec)
2273 { mpfr_init2(mp, prec); mpfr_set_ui(mp, s, MpFrC::get_rnd()); }
2274
2275 __gmp_expr(signed long int l)
2276 { mpfr_init_set_si(mp, l, MpFrC::get_rnd()); }
2277 __gmp_expr(signed long int l, unsigned long int prec)
2278 { mpfr_init2(mp, prec); mpfr_set_si(mp, l, MpFrC::get_rnd()); }
2279 __gmp_expr(unsigned long int l)
2280 { mpfr_init_set_ui(mp, l, MpFrC::get_rnd()); }
2281 __gmp_expr(unsigned long int l, unsigned long int prec)
2282 { mpfr_init2(mp, prec); mpfr_set_ui(mp, l, MpFrC::get_rnd()); }
2283
2284 __gmp_expr(float f)
2285 { mpfr_init_set_d(mp, f, MpFrC::get_rnd()); }
2286 __gmp_expr(float f, unsigned long int prec)
2287 { mpfr_init2(mp, prec); mpfr_set_d(mp, f, MpFrC::get_rnd()); }
2288 __gmp_expr(double d)
2289 { mpfr_init_set_d(mp, d, MpFrC::get_rnd()); }
2290 __gmp_expr(double d, unsigned long int prec)
2291 { mpfr_init2(mp, prec); mpfr_set_d(mp, d, MpFrC::get_rnd()); }
2292 // __gmp_expr(long double ld)
2293 // { mpfr_init_set_d(mp, ld, MpFrC::get_rnd()); }
2294 // __gmp_expr(long double ld, unsigned long int prec)
2295 // { mpfr_init2(mp, prec); mpfr_set_d(mp, ld, MpFrC::get_rnd()); }
2296
2297 explicit __gmp_expr(const char *s)
2298 {
2299 if (mpfr_init_set_str (mp, s, MpFrC::get_base(), MpFrC::get_rnd()) != 0)
2300 {
2301 mpfr_clear (mp);
2302 throw std::invalid_argument ("mpfr_set_str");
2303 }
2304 }
2305 __gmp_expr(const char *s, unsigned long int prec, int base = 0)
2306 {
2307 mpfr_init2(mp, prec);
2308 if (mpfr_set_str(mp, s, base, MpFrC::get_rnd()) != 0)
2309 {
2310 mpfr_clear (mp);
2311 throw std::invalid_argument ("mpfr_set_str");
2312 }
2313 }
2314 explicit __gmp_expr(const std::string &s)
2315 {
2316 if (mpfr_init_set_str(mp, s.c_str(),
2318 {
2319 mpfr_clear (mp);
2320 throw std::invalid_argument ("mpfr_set_str");
2321 }
2322 }
2323 __gmp_expr(const std::string &s, unsigned long int prec, int base = 0)
2324 {
2325 mpfr_init2(mp, prec);
2326 if (mpfr_set_str(mp, s.c_str(), base, MpFrC::get_rnd()) != 0)
2327 {
2328 mpfr_clear (mp);
2329 throw std::invalid_argument ("mpfr_set_str");
2330 }
2331 }
2332
2333 explicit __gmp_expr(mpfr_srcptr f)
2334 { mpfr_init2(mp, mpfr_get_prec(f)); mpfr_set(mp, f, MpFrC::get_rnd()); }
2335 __gmp_expr(mpfr_srcptr f, unsigned long int prec)
2336 { mpfr_init2(mp, prec); mpfr_set(mp, f, MpFrC::get_rnd()); }
2337
2338 ~__gmp_expr() { mpfr_clear(mp); }
2339
2340 // assignment operators
2342 { mpfr_set(mp, f.mp, MpFrC::get_rnd()); return *this; }
2343 template <class T, class U>
2345 { __gmp_set_expr(mp, expr); return *this; }
2346
2347 __gmp_expr & operator=(signed char c)
2348 { mpfr_set_si(mp, c, MpFrC::get_rnd()); return *this; }
2349 __gmp_expr & operator=(unsigned char c)
2350 { mpfr_set_ui(mp, c, MpFrC::get_rnd()); return *this; }
2351
2352 __gmp_expr & operator=(signed int i)
2353 { mpfr_set_si(mp, i, MpFrC::get_rnd()); return *this; }
2354 __gmp_expr & operator=(unsigned int i)
2355 { mpfr_set_ui(mp, i, MpFrC::get_rnd()); return *this; }
2356
2357 __gmp_expr & operator=(signed short int s)
2358 { mpfr_set_si(mp, s, MpFrC::get_rnd()); return *this; }
2359 __gmp_expr & operator=(unsigned short int s)
2360 { mpfr_set_ui(mp, s, MpFrC::get_rnd()); return *this; }
2361
2362 __gmp_expr & operator=(signed long int l)
2363 { mpfr_set_si(mp, l, MpFrC::get_rnd()); return *this; }
2364 __gmp_expr & operator=(unsigned long int l)
2365 { mpfr_set_ui(mp, l, MpFrC::get_rnd()); return *this; }
2366
2368 { mpfr_set_d(mp, f, MpFrC::get_rnd()); return *this; }
2370 { mpfr_set_d(mp, d, MpFrC::get_rnd()); return *this; }
2371 // __gmp_expr & operator=(long double ld)
2372 // { mpfr_set_ld(mp, ld); return *this; }
2373
2374 __gmp_expr & operator=(const char *s)
2375 {
2376 if (mpfr_set_str (mp, s, MpFrC::get_base(), MpFrC::get_rnd()) != 0)
2377 throw std::invalid_argument ("mpfr_set_str");
2378 return *this;
2379 }
2380 __gmp_expr & operator=(const std::string &s)
2381 {
2382 if (mpfr_set_str(mp, s.c_str(), MpFrC::get_base(), MpFrC::get_rnd()) != 0)
2383 throw std::invalid_argument ("mpfr_set_str");
2384 return *this;
2385 }
2386
2387 // string input/output functions
2388 int set_str(const char *s, int base)
2389 { return mpfr_set_str(mp, s, base, MpFrC::get_rnd()); }
2390 int set_str(const std::string &s, int base)
2391 { return mpfr_set_str(mp, s.c_str(), base, MpFrC::get_rnd()); }
2392 std::string get_str(mp_exp_t &expo, int base = 10, size_t size = 0) const
2393 {
2394 __gmp_alloc_cstring temp(mpfr_get_str(0, &expo, base, size, mp,
2395 MpFrC::get_rnd()));
2396 return std::string(temp.str);
2397 }
2398
2399 // conversion functions
2400 mpfr_srcptr __get_mp() const { return mp; }
2401 mpfr_ptr __get_mp() { return mp; }
2402 mpfr_srcptr get_mpfr_t() const { return mp; }
2403 mpfr_ptr get_mpfr_t() { return mp; }
2404
2405 signed long int get_si() const
2406 { return mpfr_get_si(mp, MpFrC::get_rnd()); }
2407 unsigned long int get_ui() const
2408 { return mpfr_get_ui(mp, MpFrC::get_rnd()); }
2409 double get_d() const
2410 { return mpfr_get_d(mp, MpFrC::get_rnd()); }
2411
2412 // bool fits_schar_p() const { return mpfr_fits_schar_p(mp, MpFrC::get_rnd()); }
2413 // bool fits_uchar_p() const { return mpfr_fits_uchar_p(mp, MpFrC::get_rnd()); }
2414 bool fits_sint_p() const
2415 { return mpfr_fits_sint_p(mp, MpFrC::get_rnd()); }
2416 bool fits_uint_p() const
2417 { return mpfr_fits_uint_p(mp, MpFrC::get_rnd()); }
2418 bool fits_sshort_p() const
2419 { return mpfr_fits_sshort_p(mp, MpFrC::get_rnd()); }
2420 bool fits_ushort_p() const
2421 { return mpfr_fits_ushort_p(mp, MpFrC::get_rnd()); }
2422 bool fits_slong_p() const
2423 { return mpfr_fits_slong_p(mp, MpFrC::get_rnd()); }
2424 bool fits_ulong_p() const
2425 { return mpfr_fits_ulong_p(mp, MpFrC::get_rnd()); }
2426 // bool fits_float_p() const
2427 // { return mpfr_fits_float_p(mp, MpFrC::get_rnd()); }
2428 // bool fits_double_p() const
2429 // { return mpfr_fits_double_p(mp, MpFrC::get_rnd()); }
2430 // bool fits_ldouble_p() const
2431 // { return mpfr_fits_ldouble_p(mp, MpFrC::get_rnd()); }
2432
2433 // compound assignments
2438
2441
2444};
2445
2446typedef __gmp_expr<mpfr_t, mpfr_t> mpfr_class;
2447
2448
2449
2450/**************** I/O operators ****************/
2451
2452// these are provided separately in libgmpxx and mpfrxx.cpp
2453
2454template <class T>
2455inline std::ostream & operator<<
2456(std::ostream &o, const __gmp_expr<T, T> &expr)
2457{
2458 return o << expr.__get_mp();
2459}
2460
2461template <class T, class U>
2462inline std::ostream & operator<<
2463(std::ostream &o, const __gmp_expr<T, U> &expr)
2464{
2465 __gmp_expr<T, T> temp(expr);
2466 return o << temp.__get_mp();
2467}
2468
2469
2470template <class T>
2471inline std::istream & operator>>(std::istream &i, __gmp_expr<T, T> &expr)
2472{
2473 return i >> expr.__get_mp();
2474}
2475
2476inline std::istream & operator>>(std::istream &i, mpq_class &q)
2477{
2478 i >> q.get_mpq_t();
2479 // q.canonicalize(); // you might want to uncomment this
2480 return i;
2481}
2482
2483
2484/**************** Functions for type conversion ****************/
2485
2486template <>
2487inline void __gmp_set_expr(mpz_ptr z, const mpz_class &w)
2488{
2489 mpz_set(z, w.get_mpz_t());
2490}
2491
2492template <class T>
2493inline void __gmp_set_expr(mpz_ptr z, const __gmp_expr<mpz_t, T> &expr)
2494{
2495 expr.eval(z);
2496}
2497
2498template <>
2499inline void __gmp_set_expr(mpz_ptr z, const mpq_class &q)
2500{
2501 mpz_set_q(z, q.get_mpq_t());
2502}
2503
2504template <class T>
2505inline void __gmp_set_expr(mpz_ptr z, const __gmp_expr<mpq_t, T> &expr)
2506{
2507 mpq_class temp(expr);
2508 mpz_set_q(z, temp.get_mpq_t());
2509}
2510
2511template <class T>
2512inline void __gmp_set_expr(mpz_ptr z, const mpfr_class &f)
2513{
2514 mpz_set_mpfr(z, f.get_mpfr_t());
2515}
2516
2517template <class T>
2518inline void __gmp_set_expr(mpz_ptr z, const __gmp_expr<mpfr_t, T> &expr)
2519{
2520 mpfr_class temp(expr);
2521 mpz_set_mpfr(z, temp.get_mpfr_t());
2522}
2523
2524template <>
2525inline void __gmp_set_expr(mpq_ptr q, const mpz_class &z)
2526{
2527 mpq_set_z(q, z.get_mpz_t());
2528}
2529
2530template <class T>
2531inline void __gmp_set_expr(mpq_ptr q, const __gmp_expr<mpz_t, T> &expr)
2532{
2533 mpz_class temp(expr);
2534 mpq_set_z(q, temp.get_mpz_t());
2535}
2536
2537template <>
2538inline void __gmp_set_expr(mpq_ptr q, const mpq_class &r)
2539{
2540 mpq_set(q, r.get_mpq_t());
2541}
2542
2543template <class T>
2544inline void __gmp_set_expr(mpq_ptr q, const __gmp_expr<mpq_t, T> &expr)
2545{
2546 expr.eval(q);
2547}
2548
2549template <class T>
2550inline void __gmp_set_expr(mpq_ptr q, const mpfr_class &f)
2551{
2552 mpq_set_mpfr(q, f.get_mpfr_t());
2553}
2554
2555template <class T>
2556inline void __gmp_set_expr(mpq_ptr q, const __gmp_expr<mpfr_t, T> &expr)
2557{
2558 mpfr_class temp(expr);
2559 mpq_set_mpfr(q, temp.get_mpfr_t());
2560}
2561
2562template <class T>
2563inline void __gmp_set_expr(mpfr_ptr f, const mpz_class &z)
2564{
2565 mpfr_set_z(f, z.get_mpz_t(), MpFrC::get_rnd());
2566}
2567
2568template <class T>
2569inline void __gmp_set_expr(mpfr_ptr f, const __gmp_expr<mpz_t, T> &expr)
2570{
2571 mpz_class temp(expr);
2572 mpfr_set_z(f, temp.get_mpz_t(), MpFrC::get_rnd());
2573}
2574
2575template <class T>
2576inline void __gmp_set_expr(mpfr_ptr f, const mpq_class &q)
2577{
2578 mpfr_set_q(f, q.get_mpq_t(), MpFrC::get_rnd());
2579}
2580
2581template <class T>
2582inline void __gmp_set_expr(mpfr_ptr f, const __gmp_expr<mpq_t, T> &expr)
2583{
2584 mpq_class temp(expr);
2585 mpfr_set_q(f, temp.get_mpq_t(), MpFrC::get_rnd());
2586}
2587
2588template <>
2589inline void __gmp_set_expr(mpfr_ptr f, const mpfr_class &g)
2590{
2591 mpfr_set(f, g.get_mpfr_t(), MpFrC::get_rnd());
2592}
2593
2594template <class T>
2595inline void __gmp_set_expr(mpfr_ptr f, const __gmp_expr<mpfr_t, T> &expr)
2596{
2597 expr.eval(f, mpfr_get_prec(f));
2598}
2599
2600
2601/**************** Specializations of __gmp_expr ****************/
2602/* The eval() method of __gmp_expr<T, U> evaluates the corresponding
2603 expression and assigns the result to its argument, which is either an
2604 mpz_t, mpq_t, or mpfr_t as specified by the T argument.
2605 Compound expressions are evaluated recursively (temporaries are created
2606 to hold intermediate values), while for simple expressions the eval()
2607 method of the appropriate function object (available as the Op argument
2608 of either __gmp_unary_expr<T, Op> or __gmp_binary_expr<T, U, Op>) is
2609 called. */
2610
2611
2612/**************** Void expressions (not in gmpxx) ****************/
2613template <class T, class Op>
2615{
2616private:
2618public:
2619 __gmp_expr() : expr() { }
2621 unsigned long int = 0) const
2622 { Op::eval(p); }
2623 unsigned long int get_prec() const { return mpfr_get_default_prec(); }
2624};
2625
2626
2627
2628/**************** Unary expressions ****************/
2629/* cases:
2630 - simple: argument is mp*_class, that is, __gmp_expr<T, T>
2631 - compound: argument is __gmp_expr<T, U> (with U not equal to T) */
2632
2633
2634// simple expressions
2635
2636template <class T, class Op>
2638{
2639private:
2641
2643public:
2644 __gmp_expr(const val_type &val) : expr(val) { }
2646 unsigned long int = 0) const
2647 { Op::eval(p, expr.val.__get_mp()); }
2648 const val_type & get_val() const { return expr.val; }
2649 unsigned long int get_prec() const { return expr.val.get_prec(); }
2650};
2651
2652// not in gmpxx (argument is a built-in type)
2653template <class T, class U, class Op>
2655{
2656private:
2657 typedef U val_type;
2658
2660
2661public:
2662 __gmp_expr(const val_type &val) : expr(val) { }
2664 unsigned long int = 0) const
2665 { Op::eval(p, expr.val); }
2666 const val_type & get_val() const { return expr.val; }
2667 unsigned long int get_prec() const { return mpfr_get_default_prec(); }
2668};
2669
2670
2671// compound expressions
2672
2673template <class T, class U, class Op>
2675{
2676private:
2678
2680public:
2681 __gmp_expr(const val_type &val) : expr(val) { }
2683 { __gmp_expr<T, T> temp(expr.val); Op::eval(p, temp.__get_mp()); }
2685 unsigned long int prec) const
2686 { __gmp_expr<T, T> temp(expr.val, prec); Op::eval(p, temp.__get_mp()); }
2687 const val_type & get_val() const { return expr.val; }
2688 unsigned long int get_prec() const { return expr.val.get_prec(); }
2689};
2690
2691
2692/**************** Binary expressions ****************/
2693/* simple:
2694 - arguments are both mp*_class
2695 - one argument is mp*_class, one is a built-in type
2696 compound:
2697 - one is mp*_class, one is __gmp_expr<T, U>
2698 - one is __gmp_expr<T, U>, one is built-in
2699 - both arguments are __gmp_expr<...> */
2700
2701
2702// simple expressions
2703
2704template <class T, class Op>
2706<T, __gmp_binary_expr<__gmp_expr<T, T>, __gmp_expr<T, T>, Op> >
2707{
2708private:
2711
2713public:
2714 __gmp_expr(const val1_type &val1, const val2_type &val2)
2715 : expr(val1, val2) { }
2717 unsigned long int = 0) const
2718 { Op::eval(p, expr.val1.__get_mp(), expr.val2.__get_mp()); }
2719 const val1_type & get_val1() const { return expr.val1; }
2720 const val2_type & get_val2() const { return expr.val2; }
2721 unsigned long int get_prec() const
2722 {
2723 unsigned long int prec1 = expr.val1.get_prec(),
2724 prec2 = expr.val2.get_prec();
2725 return (prec1 > prec2) ? prec1 : prec2;
2726 }
2727};
2728
2729
2730// simple expressions, T is a built-in numerical type
2731
2732template <class T, class U, class Op>
2734{
2735private:
2737 typedef U val2_type;
2738
2740public:
2741 __gmp_expr(const val1_type &val1, const val2_type &val2)
2742 : expr(val1, val2) { }
2744 unsigned long int = 0) const
2745 { Op::eval(p, expr.val1.__get_mp(), expr.val2); }
2746 const val1_type & get_val1() const { return expr.val1; }
2747 const val2_type & get_val2() const { return expr.val2; }
2748 unsigned long int get_prec() const { return expr.val1.get_prec(); }
2749};
2750
2751template <class T, class U, class Op>
2753{
2754private:
2755 typedef U val1_type;
2757
2759public:
2760 __gmp_expr(const val1_type &val1, const val2_type &val2)
2761 : expr(val1, val2) { }
2763 unsigned long int = 0) const
2764 { Op::eval(p, expr.val1, expr.val2.__get_mp()); }
2765 const val1_type & get_val1() const { return expr.val1; }
2766 const val2_type & get_val2() const { return expr.val2; }
2767 unsigned long int get_prec() const { return expr.val2.get_prec(); }
2768};
2769
2770// not in gmpxx (both arguments are built-in type)
2771template <class T, class U, class V, class Op>
2772class __gmp_expr<T, __gmp_binary_expr<U, V, Op> >
2773{
2774private:
2775 typedef U val1_type;
2776 typedef V val2_type;
2777
2779
2780public:
2781 __gmp_expr(const val1_type &val1, const val2_type &val2)
2782 : expr(val1, val2) { }
2784 unsigned long int = 0) const
2785 { Op::eval(p, expr.val1, expr.val2); }
2786 const val1_type & get_val1() const { return expr.val1; }
2787 const val2_type & get_val2() const { return expr.val2; }
2788 unsigned long int get_prec() const { return mpfr_get_default_prec(); }
2789};
2790
2791
2792// compound expressions, one argument is a subexpression
2793
2794template <class T, class U, class V, class Op>
2796<T, __gmp_binary_expr<__gmp_expr<T, T>, __gmp_expr<U, V>, Op> >
2797{
2798private:
2801
2803public:
2804 __gmp_expr(const val1_type &val1, const val2_type &val2)
2805 : expr(val1, val2) { }
2807 {
2808 __gmp_expr<T, T> temp(expr.val2);
2809 Op::eval(p, expr.val1.__get_mp(), temp.__get_mp());
2810 }
2812 unsigned long int prec) const
2813 {
2814 __gmp_expr<T, T> temp(expr.val2, prec);
2815 Op::eval(p, expr.val1.__get_mp(), temp.__get_mp());
2816 }
2817 const val1_type & get_val1() const { return expr.val1; }
2818 const val2_type & get_val2() const { return expr.val2; }
2819 unsigned long int get_prec() const
2820 {
2821 unsigned long int prec1 = expr.val1.get_prec(),
2822 prec2 = expr.val2.get_prec();
2823 return (prec1 > prec2) ? prec1 : prec2;
2824 }
2825};
2826
2827template <class T, class U, class V, class Op>
2829<T, __gmp_binary_expr<__gmp_expr<U, V>, __gmp_expr<T, T>, Op> >
2830{
2831private:
2834
2836public:
2837 __gmp_expr(const val1_type &val1, const val2_type &val2)
2838 : expr(val1, val2) { }
2840 {
2841 __gmp_expr<T, T> temp(expr.val1);
2842 Op::eval(p, temp.__get_mp(), expr.val2.__get_mp());
2843 }
2845 unsigned long int prec) const
2846 {
2847 __gmp_expr<T, T> temp(expr.val1, prec);
2848 Op::eval(p, temp.__get_mp(), expr.val2.__get_mp());
2849 }
2850 const val1_type & get_val1() const { return expr.val1; }
2851 const val2_type & get_val2() const { return expr.val2; }
2852 unsigned long int get_prec() const
2853 {
2854 unsigned long int prec1 = expr.val1.get_prec(),
2855 prec2 = expr.val2.get_prec();
2856 return (prec1 > prec2) ? prec1 : prec2;
2857 }
2858};
2859
2860template <class T, class U, class Op>
2862<T, __gmp_binary_expr<__gmp_expr<T, T>, __gmp_expr<T, U>, Op> >
2863{
2864private:
2867
2869public:
2870 __gmp_expr(const val1_type &val1, const val2_type &val2)
2871 : expr(val1, val2) { }
2873 {
2874 __gmp_expr<T, T> temp(expr.val2);
2875 Op::eval(p, expr.val1.__get_mp(), temp.__get_mp());
2876 }
2878 unsigned long int prec) const
2879 {
2880 __gmp_expr<T, T> temp(expr.val2, prec);
2881 Op::eval(p, expr.val1.__get_mp(), temp.__get_mp());
2882 }
2883 const val1_type & get_val1() const { return expr.val1; }
2884 const val2_type & get_val2() const { return expr.val2; }
2885 unsigned long int get_prec() const
2886 {
2887 unsigned long int prec1 = expr.val1.get_prec(),
2888 prec2 = expr.val2.get_prec();
2889 return (prec1 > prec2) ? prec1 : prec2;
2890 }
2891};
2892
2893template <class T, class U, class Op>
2895<T, __gmp_binary_expr<__gmp_expr<T, U>, __gmp_expr<T, T>, Op> >
2896{
2897private:
2900
2902public:
2903 __gmp_expr(const val1_type &val1, const val2_type &val2)
2904 : expr(val1, val2) { }
2906 {
2907 __gmp_expr<T, T> temp(expr.val1);
2908 Op::eval(p, temp.__get_mp(), expr.val2.__get_mp());
2909 }
2911 unsigned long int prec) const
2912 {
2913 __gmp_expr<T, T> temp(expr.val1, prec);
2914 Op::eval(p, temp.__get_mp(), expr.val2.__get_mp());
2915 }
2916 const val1_type & get_val1() const { return expr.val1; }
2917 const val2_type & get_val2() const { return expr.val2; }
2918 unsigned long int get_prec() const
2919 {
2920 unsigned long int prec1 = expr.val1.get_prec(),
2921 prec2 = expr.val2.get_prec();
2922 return (prec1 > prec2) ? prec1 : prec2;
2923 }
2924};
2925
2926
2927// one argument is a subexpression, one is a built-in
2928
2929template <class T, class U, class V, class Op>
2931{
2932private:
2934 typedef V val2_type;
2935
2937public:
2938 __gmp_expr(const val1_type &val1, const val2_type &val2)
2939 : expr(val1, val2) { }
2941 {
2942 __gmp_expr<T, T> temp(expr.val1);
2943 Op::eval(p, temp.__get_mp(), expr.val2);
2944 }
2946 unsigned long int prec) const
2947 {
2948 __gmp_expr<T, T> temp(expr.val1, prec);
2949 Op::eval(p, temp.__get_mp(), expr.val2);
2950 }
2951 const val1_type & get_val1() const { return expr.val1; }
2952 const val2_type & get_val2() const { return expr.val2; }
2953 unsigned long int get_prec() const { return expr.val1.get_prec(); }
2954};
2955
2956template <class T, class U, class V, class Op>
2958{
2959private:
2960 typedef U val1_type;
2962
2964public:
2965 __gmp_expr(const val1_type &val1, const val2_type &val2)
2966 : expr(val1, val2) { }
2968 {
2969 __gmp_expr<T, T> temp(expr.val2);
2970 Op::eval(p, expr.val1, temp.__get_mp());
2971 }
2973 unsigned long int prec) const
2974 {
2975 __gmp_expr<T, T> temp(expr.val2, prec);
2976 Op::eval(p, expr.val1, temp.__get_mp());
2977 }
2978 const val1_type & get_val1() const { return expr.val1; }
2979 const val2_type & get_val2() const { return expr.val2; }
2980 unsigned long int get_prec() const { return expr.val2.get_prec(); }
2981};
2982
2983
2984// both arguments are subexpressions
2985
2986template <class T, class U, class V, class W, class Op>
2988<T, __gmp_binary_expr<__gmp_expr<T, U>, __gmp_expr<V, W>, Op> >
2989{
2990private:
2993
2995public:
2996 __gmp_expr(const val1_type &val1, const val2_type &val2)
2997 : expr(val1, val2) { }
2999 {
3000 __gmp_expr<T, T> temp1(expr.val1), temp2(expr.val2);
3001 Op::eval(p, temp1.__get_mp(), temp2.__get_mp());
3002 }
3004 unsigned long int prec) const
3005 {
3006 __gmp_expr<T, T> temp1(expr.val1, prec), temp2(expr.val2, prec);
3007 Op::eval(p, temp1.__get_mp(), temp2.__get_mp());
3008 }
3009 const val1_type & get_val1() const { return expr.val1; }
3010 const val2_type & get_val2() const { return expr.val2; }
3011 unsigned long int get_prec() const
3012 {
3013 unsigned long int prec1 = expr.val1.get_prec(),
3014 prec2 = expr.val2.get_prec();
3015 return (prec1 > prec2) ? prec1 : prec2;
3016 }
3017};
3018
3019template <class T, class U, class V, class W, class Op>
3021<T, __gmp_binary_expr<__gmp_expr<U, V>, __gmp_expr<T, W>, Op> >
3022{
3023private:
3026
3028public:
3029 __gmp_expr(const val1_type &val1, const val2_type &val2)
3030 : expr(val1, val2) { }
3032 {
3033 __gmp_expr<T, T> temp1(expr.val1), temp2(expr.val2);
3034 Op::eval(p, temp1.__get_mp(), temp2.__get_mp());
3035 }
3037 unsigned long int prec) const
3038 {
3039 __gmp_expr<T, T> temp1(expr.val1, prec), temp2(expr.val2, prec);
3040 Op::eval(p, temp1.__get_mp(), temp2.__get_mp());
3041 }
3042 const val1_type & get_val1() const { return expr.val1; }
3043 const val2_type & get_val2() const { return expr.val2; }
3044 unsigned long int get_prec() const
3045 {
3046 unsigned long int prec1 = expr.val1.get_prec(),
3047 prec2 = expr.val2.get_prec();
3048 return (prec1 > prec2) ? prec1 : prec2;
3049 }
3050};
3051
3052template <class T, class U, class V, class Op>
3054<T, __gmp_binary_expr<__gmp_expr<T, U>, __gmp_expr<T, V>, Op> >
3055{
3056private:
3059
3061public:
3062 __gmp_expr(const val1_type &val1, const val2_type &val2)
3063 : expr(val1, val2) { }
3065 {
3066 __gmp_expr<T, T> temp1(expr.val1), temp2(expr.val2);
3067 Op::eval(p, temp1.__get_mp(), temp2.__get_mp());
3068 }
3070 unsigned long int prec) const
3071 {
3072 __gmp_expr<T, T> temp1(expr.val1, prec), temp2(expr.val2, prec);
3073 Op::eval(p, temp1.__get_mp(), temp2.__get_mp());
3074 }
3075 const val1_type & get_val1() const { return expr.val1; }
3076 const val2_type & get_val2() const { return expr.val2; }
3077 unsigned long int get_prec() const
3078 {
3079 unsigned long int prec1 = expr.val1.get_prec(),
3080 prec2 = expr.val2.get_prec();
3081 return (prec1 > prec2) ? prec1 : prec2;
3082 }
3083};
3084
3085
3086/**************** Special cases ****************/
3087
3088/* Some operations (i.e., add and subtract) with mixed mpz/mpq arguments
3089 can be done directly without first converting the mpz to mpq.
3090 Appropriate specializations of __gmp_expr are required. */
3091
3092
3093#define __GMPZQ_DEFINE_EXPR(eval_fun) \
3094 \
3095template <> \
3096class __gmp_expr<mpq_t, __gmp_binary_expr<mpz_class, mpq_class, eval_fun> > \
3097{ \
3098private: \
3099 typedef mpz_class val1_type; \
3100 typedef mpq_class val2_type; \
3101 \
3102 __gmp_binary_expr<val1_type, val2_type, eval_fun> expr; \
3103public: \
3104 __gmp_expr(const val1_type &val1, const val2_type &val2) \
3105 : expr(val1, val2) { } \
3106 void eval(mpq_ptr q) const \
3107 { eval_fun::eval(q, expr.val1.get_mpz_t(), expr.val2.get_mpq_t()); } \
3108 const val1_type & get_val1() const { return expr.val1; } \
3109 const val2_type & get_val2() const { return expr.val2; } \
3110 unsigned long int get_prec() const { return mpfr_get_default_prec(); } \
3111}; \
3112 \
3113template <> \
3114class __gmp_expr<mpq_t, __gmp_binary_expr<mpq_class, mpz_class, eval_fun> > \
3115{ \
3116private: \
3117 typedef mpq_class val1_type; \
3118 typedef mpz_class val2_type; \
3119 \
3120 __gmp_binary_expr<val1_type, val2_type, eval_fun> expr; \
3121public: \
3122 __gmp_expr(const val1_type &val1, const val2_type &val2) \
3123 : expr(val1, val2) { } \
3124 void eval(mpq_ptr q) const \
3125 { eval_fun::eval(q, expr.val1.get_mpq_t(), expr.val2.get_mpz_t()); } \
3126 const val1_type & get_val1() const { return expr.val1; } \
3127 const val2_type & get_val2() const { return expr.val2; } \
3128 unsigned long int get_prec() const { return mpfr_get_default_prec(); } \
3129}; \
3130 \
3131template <class T> \
3132class __gmp_expr \
3133<mpq_t, __gmp_binary_expr<mpz_class, __gmp_expr<mpq_t, T>, eval_fun> > \
3134{ \
3135private: \
3136 typedef mpz_class val1_type; \
3137 typedef __gmp_expr<mpq_t, T> val2_type; \
3138 \
3139 __gmp_binary_expr<val1_type, val2_type, eval_fun> expr; \
3140public: \
3141 __gmp_expr(const val1_type &val1, const val2_type &val2) \
3142 : expr(val1, val2) { } \
3143 void eval(mpq_ptr q) const \
3144 { \
3145 mpq_class temp(expr.val2); \
3146 eval_fun::eval(q, expr.val1.get_mpz_t(), temp.get_mpq_t()); \
3147 } \
3148 const val1_type & get_val1() const { return expr.val1; } \
3149 const val2_type & get_val2() const { return expr.val2; } \
3150 unsigned long int get_prec() const { return mpfr_get_default_prec(); } \
3151}; \
3152 \
3153template <class T> \
3154class __gmp_expr \
3155<mpq_t, __gmp_binary_expr<mpq_class, __gmp_expr<mpz_t, T>, eval_fun> > \
3156{ \
3157private: \
3158 typedef mpq_class val1_type; \
3159 typedef __gmp_expr<mpz_t, T> val2_type; \
3160 \
3161 __gmp_binary_expr<val1_type, val2_type, eval_fun> expr; \
3162public: \
3163 __gmp_expr(const val1_type &val1, const val2_type &val2) \
3164 : expr(val1, val2) { } \
3165 void eval(mpq_ptr q) const \
3166 { \
3167 mpz_class temp(expr.val2); \
3168 eval_fun::eval(q, expr.val1.get_mpq_t(), temp.get_mpz_t()); \
3169 } \
3170 const val1_type & get_val1() const { return expr.val1; } \
3171 const val2_type & get_val2() const { return expr.val2; } \
3172 unsigned long int get_prec() const { return mpfr_get_default_prec(); } \
3173}; \
3174 \
3175template <class T> \
3176class __gmp_expr \
3177<mpq_t, __gmp_binary_expr<__gmp_expr<mpz_t, T>, mpq_class, eval_fun> > \
3178{ \
3179private: \
3180 typedef __gmp_expr<mpz_t, T> val1_type; \
3181 typedef mpq_class val2_type; \
3182 \
3183 __gmp_binary_expr<val1_type, val2_type, eval_fun> expr; \
3184public: \
3185 __gmp_expr(const val1_type &val1, const val2_type &val2) \
3186 : expr(val1, val2) { } \
3187 void eval(mpq_ptr q) const \
3188 { \
3189 mpz_class temp(expr.val1); \
3190 eval_fun::eval(q, temp.get_mpz_t(), expr.val2.get_mpq_t()); \
3191 } \
3192 const val1_type & get_val1() const { return expr.val1; } \
3193 const val2_type & get_val2() const { return expr.val2; } \
3194 unsigned long int get_prec() const { return mpfr_get_default_prec(); } \
3195}; \
3196 \
3197template <class T> \
3198class __gmp_expr \
3199<mpq_t, __gmp_binary_expr<__gmp_expr<mpq_t, T>, mpz_class, eval_fun> > \
3200{ \
3201private: \
3202 typedef __gmp_expr<mpq_t, T> val1_type; \
3203 typedef mpz_class val2_type; \
3204 \
3205 __gmp_binary_expr<val1_type, val2_type, eval_fun> expr; \
3206public: \
3207 __gmp_expr(const val1_type &val1, const val2_type &val2) \
3208 : expr(val1, val2) { } \
3209 void eval(mpq_ptr q) const \
3210 { \
3211 mpq_class temp(expr.val1); \
3212 eval_fun::eval(q, temp.get_mpq_t(), expr.val2.get_mpz_t()); \
3213 } \
3214 const val1_type & get_val1() const { return expr.val1; } \
3215 const val2_type & get_val2() const { return expr.val2; } \
3216 unsigned long int get_prec() const { return mpfr_get_default_prec(); } \
3217}; \
3218 \
3219template <class T, class U> \
3220class __gmp_expr<mpq_t, __gmp_binary_expr \
3221<__gmp_expr<mpz_t, T>, __gmp_expr<mpq_t, U>, eval_fun> > \
3222{ \
3223private: \
3224 typedef __gmp_expr<mpz_t, T> val1_type; \
3225 typedef __gmp_expr<mpq_t, U> val2_type; \
3226 \
3227 __gmp_binary_expr<val1_type, val2_type, eval_fun> expr; \
3228public: \
3229 __gmp_expr(const val1_type &val1, const val2_type &val2) \
3230 : expr(val1, val2) { } \
3231 void eval(mpq_ptr q) const \
3232 { \
3233 mpz_class temp1(expr.val1); \
3234 mpq_class temp2(expr.val2); \
3235 eval_fun::eval(q, temp1.get_mpz_t(), temp2.get_mpq_t()); \
3236 } \
3237 const val1_type & get_val1() const { return expr.val1; } \
3238 const val2_type & get_val2() const { return expr.val2; } \
3239 unsigned long int get_prec() const { return mpfr_get_default_prec(); } \
3240}; \
3241 \
3242template <class T, class U> \
3243class __gmp_expr<mpq_t, __gmp_binary_expr \
3244<__gmp_expr<mpq_t, T>, __gmp_expr<mpz_t, U>, eval_fun> > \
3245{ \
3246private: \
3247 typedef __gmp_expr<mpq_t, T> val1_type; \
3248 typedef __gmp_expr<mpz_t, U> val2_type; \
3249 \
3250 __gmp_binary_expr<val1_type, val2_type, eval_fun> expr; \
3251public: \
3252 __gmp_expr(const val1_type &val1, const val2_type &val2) \
3253 : expr(val1, val2) { } \
3254 void eval(mpq_ptr q) const \
3255 { \
3256 mpq_class temp1(expr.val1); \
3257 mpz_class temp2(expr.val2); \
3258 eval_fun::eval(q, temp1.get_mpq_t(), temp2.get_mpz_t()); \
3259 } \
3260 const val1_type & get_val1() const { return expr.val1; } \
3261 const val2_type & get_val2() const { return expr.val2; } \
3262 unsigned long int get_prec() const { return mpfr_get_default_prec(); } \
3263};
3264
3265
3268
3269
3270/* Integer ternary expressions of the kind `a+b*c' or `a*b+c' can be
3271 evaluated directly via mpz_addmul */
3272
3273// a + b * c
3274#define __GMP_DEFINE_TERNARY_EXPR(eval_fun1, eval_fun2, eval_both) \
3275 \
3276template <> \
3277class __gmp_expr<mpz_t, __gmp_binary_expr<mpz_class, __gmp_expr \
3278<mpz_t, __gmp_binary_expr<mpz_class, mpz_class, eval_fun1> >, eval_fun2> > \
3279{ \
3280private: \
3281 typedef mpz_class val1_type; \
3282 typedef __gmp_expr \
3283 <mpz_t, __gmp_binary_expr<mpz_class, mpz_class, eval_fun1> > val2_type; \
3284 \
3285 __gmp_binary_expr<val1_type, val2_type, eval_fun2> expr; \
3286public: \
3287 __gmp_expr(const val1_type &val1, const val2_type &val2) \
3288 : expr(val1, val2) { } \
3289 void eval(mpz_ptr z) const \
3290 { eval_both::eval \
3291 (z, expr.val1.get_mpz_t(), expr.val2.get_val1().get_mpz_t(), \
3292 expr.val2.get_val2().get_mpz_t()); } \
3293 const val1_type & get_val1() const { return expr.val1; } \
3294 const val2_type & get_val2() const { return expr.val2; } \
3295 unsigned long int get_prec() const { return mpfr_get_default_prec(); } \
3296}; \
3297 \
3298template <class T> \
3299class __gmp_expr<mpz_t, __gmp_binary_expr<mpz_class, __gmp_expr \
3300<mpz_t, __gmp_binary_expr<mpz_class, T, eval_fun1> >, eval_fun2> > \
3301{ \
3302private: \
3303 typedef mpz_class val1_type; \
3304 typedef __gmp_expr \
3305 <mpz_t, __gmp_binary_expr<mpz_class, T, eval_fun1> > val2_type; \
3306 \
3307 __gmp_binary_expr<val1_type, val2_type, eval_fun2> expr; \
3308public: \
3309 __gmp_expr(const val1_type &val1, const val2_type &val2) \
3310 : expr(val1, val2) { } \
3311 void eval(mpz_ptr z) const \
3312 { eval_both::eval \
3313 (z, expr.val1.get_mpz_t(), expr.val2.get_val1().get_mpz_t(), \
3314 expr.val2.get_val2()); } \
3315 const val1_type & get_val1() const { return expr.val1; } \
3316 const val2_type & get_val2() const { return expr.val2; } \
3317 unsigned long int get_prec() const { return mpfr_get_default_prec(); } \
3318}; \
3319 \
3320template <class T> \
3321class __gmp_expr<mpz_t, __gmp_binary_expr<mpz_class, __gmp_expr \
3322<mpz_t, __gmp_binary_expr<T, mpz_class, eval_fun1> >, eval_fun2> > \
3323{ \
3324private: \
3325 typedef mpz_class val1_type; \
3326 typedef __gmp_expr \
3327 <mpz_t, __gmp_binary_expr<T, mpz_class, eval_fun1> > val2_type; \
3328 \
3329 __gmp_binary_expr<val1_type, val2_type, eval_fun2> expr; \
3330public: \
3331 __gmp_expr(const val1_type &val1, const val2_type &val2) \
3332 : expr(val1, val2) { } \
3333 void eval(mpz_ptr z) const \
3334 { eval_both::eval \
3335 (z, expr.val1.get_mpz_t(), expr.val2.get_val1(), \
3336 expr.val2.get_val2().get_mpz_t()); } \
3337 const val1_type & get_val1() const { return expr.val1; } \
3338 const val2_type & get_val2() const { return expr.val2; } \
3339 unsigned long int get_prec() const { return mpfr_get_default_prec(); } \
3340}; \
3341 \
3342template <class T> \
3343class __gmp_expr<mpz_t, __gmp_binary_expr<mpz_class, __gmp_expr \
3344<mpz_t, __gmp_binary_expr<mpz_class, __gmp_expr<mpz_t, T>, eval_fun1> >, \
3345 eval_fun2> > \
3346{ \
3347private: \
3348 typedef mpz_class val1_type; \
3349 typedef __gmp_expr<mpz_t, __gmp_binary_expr \
3350 <mpz_class, __gmp_expr<mpz_t, T>, eval_fun1> > val2_type; \
3351 \
3352 __gmp_binary_expr<val1_type, val2_type, eval_fun2> expr; \
3353public: \
3354 __gmp_expr(const val1_type &val1, const val2_type &val2) \
3355 : expr(val1, val2) { } \
3356 void eval(mpz_ptr z) const \
3357 { \
3358 mpz_class temp(expr.val2.get_val2()); \
3359 eval_both::eval \
3360 (z, expr.val1.get_mpz_t(), expr.val2.get_val1().get_mpz_t(), \
3361 temp.get_mpz_t()); \
3362 } \
3363 const val1_type & get_val1() const { return expr.val1; } \
3364 const val2_type & get_val2() const { return expr.val2; } \
3365 unsigned long int get_prec() const { return mpfr_get_default_prec(); } \
3366}; \
3367 \
3368template <class T> \
3369class __gmp_expr<mpz_t, __gmp_binary_expr<mpz_class, __gmp_expr \
3370<mpz_t, __gmp_binary_expr<__gmp_expr<mpz_t, T>, mpz_class, eval_fun1> >, \
3371 eval_fun2> > \
3372{ \
3373private: \
3374 typedef mpz_class val1_type; \
3375 typedef __gmp_expr<mpz_t, __gmp_binary_expr \
3376 <__gmp_expr<mpz_t, T>, mpz_class, eval_fun1> > val2_type; \
3377 \
3378 __gmp_binary_expr<val1_type, val2_type, eval_fun2> expr; \
3379public: \
3380 __gmp_expr(const val1_type &val1, const val2_type &val2) \
3381 : expr(val1, val2) { } \
3382 void eval(mpz_ptr z) const \
3383 { \
3384 mpz_class temp(expr.val2.get_val1()); \
3385 eval_both::eval(z, expr.val1.get_mpz_t(), temp.get_mpz_t(), \
3386 expr.val2.get_val2().get_mpz_t()); \
3387 } \
3388 const val1_type & get_val1() const { return expr.val1; } \
3389 const val2_type & get_val2() const { return expr.val2; } \
3390 unsigned long int get_prec() const { return mpfr_get_default_prec(); } \
3391}; \
3392 \
3393template <class T, class U> \
3394class __gmp_expr<mpz_t, __gmp_binary_expr<mpz_class, __gmp_expr \
3395<mpz_t, __gmp_binary_expr<__gmp_expr<mpz_t, T>, U, eval_fun1> >, \
3396 eval_fun2> > \
3397{ \
3398private: \
3399 typedef mpz_class val1_type; \
3400 typedef __gmp_expr<mpz_t, __gmp_binary_expr \
3401 <__gmp_expr<mpz_t, T>, U, eval_fun1> > val2_type; \
3402 \
3403 __gmp_binary_expr<val1_type, val2_type, eval_fun2> expr; \
3404public: \
3405 __gmp_expr(const val1_type &val1, const val2_type &val2) \
3406 : expr(val1, val2) { } \
3407 void eval(mpz_ptr z) const \
3408 { \
3409 mpz_class temp(expr.val2.get_val1()); \
3410 eval_both::eval \
3411 (z, expr.val1.get_mpz_t(), temp.get_mpz_t(), expr.val2.get_val2()); \
3412 } \
3413 const val1_type & get_val1() const { return expr.val1; } \
3414 const val2_type & get_val2() const { return expr.val2; } \
3415 unsigned long int get_prec() const { return mpfr_get_default_prec(); } \
3416}; \
3417 \
3418template <class T, class U> \
3419class __gmp_expr<mpz_t, __gmp_binary_expr<mpz_class, __gmp_expr \
3420<mpz_t, __gmp_binary_expr<T, __gmp_expr<mpz_t, U>, eval_fun1> >, \
3421 eval_fun2> > \
3422{ \
3423private: \
3424 typedef mpz_class val1_type; \
3425 typedef __gmp_expr<mpz_t, __gmp_binary_expr \
3426 <T, __gmp_expr<mpz_t, U>, eval_fun1> > val2_type; \
3427 \
3428 __gmp_binary_expr<val1_type, val2_type, eval_fun2> expr; \
3429public: \
3430 __gmp_expr(const val1_type &val1, const val2_type &val2) \
3431 : expr(val1, val2) { } \
3432 void eval(mpz_ptr z) const \
3433 { \
3434 mpz_class temp(expr.val2.get_val2()); \
3435 eval_both::eval \
3436 (z, expr.val1.get_mpz_t(), expr.val2.get_val1(), temp.get_mpz_t()); \
3437 } \
3438 const val1_type & get_val1() const { return expr.val1; } \
3439 const val2_type & get_val2() const { return expr.val2; } \
3440 unsigned long int get_prec() const { return mpfr_get_default_prec(); } \
3441}; \
3442 \
3443template <class T, class U> \
3444class __gmp_expr<mpz_t, __gmp_binary_expr<mpz_class, __gmp_expr \
3445<mpz_t, __gmp_binary_expr<__gmp_expr<mpz_t, T>, __gmp_expr<mpz_t, U>, \
3446 eval_fun1> >, eval_fun2> > \
3447{ \
3448private: \
3449 typedef mpz_class val1_type; \
3450 typedef __gmp_expr<mpz_t, __gmp_binary_expr \
3451 <__gmp_expr<mpz_t, T>, __gmp_expr<mpz_t, U>, eval_fun1> > val2_type; \
3452 \
3453 __gmp_binary_expr<val1_type, val2_type, eval_fun2> expr; \
3454public: \
3455 __gmp_expr(const val1_type &val1, const val2_type &val2) \
3456 : expr(val1, val2) { } \
3457 void eval(mpz_ptr z) const \
3458 { \
3459 mpz_class temp1(expr.val2.get_val1()); \
3460 mpz_class temp2(expr.val2.get_val2()); \
3461 eval_both::eval \
3462 (z, expr.val1.get_mpz_t(), temp1.get_mpz_t(), temp2.get_mpz_t()); \
3463 } \
3464 const val1_type & get_val1() const { return expr.val1; } \
3465 const val2_type & get_val2() const { return expr.val2; } \
3466 unsigned long int get_prec() const { return mpfr_get_default_prec(); } \
3467}; \
3468 \
3469template <class T> \
3470class __gmp_expr<mpz_t, __gmp_binary_expr<__gmp_expr<mpz_t, T>, \
3471 __gmp_expr<mpz_t, __gmp_binary_expr<mpz_class, mpz_class, eval_fun1> >, \
3472 eval_fun2> > \
3473{ \
3474private: \
3475 typedef __gmp_expr<mpz_t, T> val1_type; \
3476 typedef __gmp_expr \
3477 <mpz_t, __gmp_binary_expr<mpz_class, mpz_class, eval_fun1> > val2_type; \
3478 \
3479 __gmp_binary_expr<val1_type, val2_type, eval_fun2> expr; \
3480public: \
3481 __gmp_expr(const val1_type &val1, const val2_type &val2) \
3482 : expr(val1, val2) { } \
3483 void eval(mpz_ptr z) const \
3484 { \
3485 mpz_class temp(expr.val1); \
3486 eval_both::eval(z, temp.get_mpz_t(), expr.val2.get_val1().get_mpz_t(), \
3487 expr.val2.get_val2().get_mpz_t()); \
3488 } \
3489 const val1_type & get_val1() const { return expr.val1; } \
3490 const val2_type & get_val2() const { return expr.val2; } \
3491 unsigned long int get_prec() const { return mpfr_get_default_prec(); } \
3492}; \
3493 \
3494template <class T, class U> \
3495class __gmp_expr<mpz_t, __gmp_binary_expr<__gmp_expr<mpz_t, T>, \
3496 __gmp_expr<mpz_t, __gmp_binary_expr<mpz_class, U, eval_fun1> >, \
3497 eval_fun2> > \
3498{ \
3499private: \
3500 typedef __gmp_expr<mpz_t, T> val1_type; \
3501 typedef __gmp_expr \
3502 <mpz_t, __gmp_binary_expr<mpz_class, U, eval_fun1> > val2_type; \
3503 \
3504 __gmp_binary_expr<val1_type, val2_type, eval_fun2> expr; \
3505public: \
3506 __gmp_expr(const val1_type &val1, const val2_type &val2) \
3507 : expr(val1, val2) { } \
3508 void eval(mpz_ptr z) const \
3509 { \
3510 mpz_class temp(expr.val1); \
3511 eval_both::eval(z, temp.get_mpz_t(), expr.val2.get_val1().get_mpz_t(), \
3512 expr.val2.get_val2()); \
3513 } \
3514 const val1_type & get_val1() const { return expr.val1; } \
3515 const val2_type & get_val2() const { return expr.val2; } \
3516 unsigned long int get_prec() const { return mpfr_get_default_prec(); } \
3517}; \
3518 \
3519template <class T, class U> \
3520class __gmp_expr<mpz_t, __gmp_binary_expr<__gmp_expr<mpz_t, T>, \
3521 __gmp_expr<mpz_t, __gmp_binary_expr<U, mpz_class, eval_fun1> >, \
3522 eval_fun2> > \
3523{ \
3524private: \
3525 typedef __gmp_expr<mpz_t, T> val1_type; \
3526 typedef __gmp_expr \
3527 <mpz_t, __gmp_binary_expr<U, mpz_class, eval_fun1> > val2_type; \
3528 \
3529 __gmp_binary_expr<val1_type, val2_type, eval_fun2> expr; \
3530public: \
3531 __gmp_expr(const val1_type &val1, const val2_type &val2) \
3532 : expr(val1, val2) { } \
3533 void eval(mpz_ptr z) const \
3534 { \
3535 mpz_class temp(expr.val1); \
3536 eval_both::eval(z, temp.get_mpz_t(), expr.val2.get_val1(), \
3537 expr.val2.get_val2().get_mpz_t()); \
3538 } \
3539 const val1_type & get_val1() const { return expr.val1; } \
3540 const val2_type & get_val2() const { return expr.val2; } \
3541 unsigned long int get_prec() const { return mpfr_get_default_prec(); } \
3542}; \
3543 \
3544template <class T, class U> \
3545class __gmp_expr<mpz_t, __gmp_binary_expr<__gmp_expr<mpz_t, T>, \
3546 __gmp_expr<mpz_t, __gmp_binary_expr<mpz_class, __gmp_expr<mpz_t, U>, \
3547 eval_fun1> >, eval_fun2> > \
3548{ \
3549private: \
3550 typedef __gmp_expr<mpz_t, T> val1_type; \
3551 typedef __gmp_expr<mpz_t, __gmp_binary_expr \
3552 <mpz_class, __gmp_expr<mpz_t, U>, eval_fun1> > val2_type; \
3553 \
3554 __gmp_binary_expr<val1_type, val2_type, eval_fun2> expr; \
3555public: \
3556 __gmp_expr(const val1_type &val1, const val2_type &val2) \
3557 : expr(val1, val2) { } \
3558 void eval(mpz_ptr z) const \
3559 { \
3560 mpz_class temp1(expr.val1); \
3561 mpz_class temp2(expr.val2.get_val2()); \
3562 eval_both::eval \
3563 (z, temp1.get_mpz_t(), expr.val2.get_val1().get_mpz_t(), \
3564 temp2.get_mpz_t()); \
3565 } \
3566 const val1_type & get_val1() const { return expr.val1; } \
3567 const val2_type & get_val2() const { return expr.val2; } \
3568 unsigned long int get_prec() const { return mpfr_get_default_prec(); } \
3569}; \
3570 \
3571template <class T, class U> \
3572class __gmp_expr<mpz_t, __gmp_binary_expr<__gmp_expr<mpz_t, T>, \
3573 __gmp_expr<mpz_t, __gmp_binary_expr<__gmp_expr<mpz_t, U>, mpz_class, \
3574 eval_fun1> >, eval_fun2> > \
3575{ \
3576private: \
3577 typedef __gmp_expr<mpz_t, T> val1_type; \
3578 typedef __gmp_expr<mpz_t, __gmp_binary_expr \
3579 <__gmp_expr<mpz_t, U>, mpz_class, eval_fun1> > val2_type; \
3580 \
3581 __gmp_binary_expr<val1_type, val2_type, eval_fun2> expr; \
3582public: \
3583 __gmp_expr(const val1_type &val1, const val2_type &val2) \
3584 : expr(val1, val2) { } \
3585 void eval(mpz_ptr z) const \
3586 { \
3587 mpz_class temp1(expr.val1); \
3588 mpz_class temp2(expr.val2.get_val1()); \
3589 eval_both::eval(z, temp1.get_mpz_t(), temp2.get_mpz_t(), \
3590 expr.val2.get_val2().get_mpz_t()); \
3591 } \
3592 const val1_type & get_val1() const { return expr.val1; } \
3593 const val2_type & get_val2() const { return expr.val2; } \
3594 unsigned long int get_prec() const { return mpfr_get_default_prec(); } \
3595}; \
3596 \
3597template <class T, class U, class V> \
3598class __gmp_expr<mpz_t, __gmp_binary_expr<__gmp_expr<mpz_t, T>, \
3599 __gmp_expr<mpz_t, __gmp_binary_expr<__gmp_expr<mpz_t, U>, V, \
3600 eval_fun1> >, eval_fun2> > \
3601{ \
3602private: \
3603 typedef __gmp_expr<mpz_t, T> val1_type; \
3604 typedef __gmp_expr<mpz_t, __gmp_binary_expr \
3605 <__gmp_expr<mpz_t, U>, V, eval_fun1> > val2_type; \
3606 \
3607 __gmp_binary_expr<val1_type, val2_type, eval_fun2> expr; \
3608public: \
3609 __gmp_expr(const val1_type &val1, const val2_type &val2) \
3610 : expr(val1, val2) { } \
3611 void eval(mpz_ptr z) const \
3612 { \
3613 mpz_class temp1(expr.val1); \
3614 mpz_class temp2(expr.val2.get_val1()); \
3615 eval_both::eval \
3616 (z, temp1.get_mpz_t(), temp2.get_mpz_t(), expr.val2.get_val2()); \
3617 } \
3618 const val1_type & get_val1() const { return expr.val1; } \
3619 const val2_type & get_val2() const { return expr.val2; } \
3620 unsigned long int get_prec() const { return mpfr_get_default_prec(); } \
3621}; \
3622 \
3623template <class T, class U, class V> \
3624class __gmp_expr<mpz_t, __gmp_binary_expr<__gmp_expr<mpz_t, T>, \
3625 __gmp_expr<mpz_t, __gmp_binary_expr<U, __gmp_expr<mpz_t, V>, \
3626 eval_fun1> >, eval_fun2> > \
3627{ \
3628private: \
3629 typedef __gmp_expr<mpz_t, T> val1_type; \
3630 typedef __gmp_expr<mpz_t, __gmp_binary_expr \
3631 <U, __gmp_expr<mpz_t, V>, eval_fun1> > val2_type; \
3632 \
3633 __gmp_binary_expr<val1_type, val2_type, eval_fun2> expr; \
3634public: \
3635 __gmp_expr(const val1_type &val1, const val2_type &val2) \
3636 : expr(val1, val2) { } \
3637 void eval(mpz_ptr z) const \
3638 { \
3639 mpz_class temp1(expr.val1); \
3640 mpz_class temp2(expr.val2.get_val2()); \
3641 eval_both::eval \
3642 (z, temp1.get_mpz_t(), expr.val2.get_val1(), temp2.get_mpz_t()); \
3643 } \
3644 const val1_type & get_val1() const { return expr.val1; } \
3645 const val2_type & get_val2() const { return expr.val2; } \
3646 unsigned long int get_prec() const { return mpfr_get_default_prec(); } \
3647}; \
3648 \
3649template <class T, class U, class V> \
3650class __gmp_expr<mpz_t, __gmp_binary_expr<__gmp_expr<mpz_t, T>, \
3651 __gmp_expr<mpz_t, __gmp_binary_expr<__gmp_expr<mpz_t, U>, \
3652 __gmp_expr<mpz_t, V>, eval_fun1> >, eval_fun2> > \
3653{ \
3654private: \
3655 typedef __gmp_expr<mpz_t, T> val1_type; \
3656 typedef __gmp_expr<mpz_t, __gmp_binary_expr \
3657 <__gmp_expr<mpz_t, U>, __gmp_expr<mpz_t, V>, eval_fun1> > val2_type; \
3658 \
3659 __gmp_binary_expr<val1_type, val2_type, eval_fun2> expr; \
3660public: \
3661 __gmp_expr(const val1_type &val1, const val2_type &val2) \
3662 : expr(val1, val2) { } \
3663 void eval(mpz_ptr z) const \
3664 { \
3665 mpz_class temp1(expr.val1); \
3666 mpz_class temp2(expr.val2.get_val1()); \
3667 mpz_class temp3(expr.val2.get_val2()); \
3668 eval_both::eval \
3669 (z, temp1.get_mpz_t(), temp2.get_mpz_t(), temp3.get_mpz_t()); \
3670 } \
3671 const val1_type & get_val1() const { return expr.val1; } \
3672 const val2_type & get_val2() const { return expr.val2; } \
3673 unsigned long int get_prec() const { return mpfr_get_default_prec(); } \
3674};
3675
3676
3681
3682/**************** Macros for defining functions ****************/
3683/* Results of operators and functions are instances of __gmp_expr<T, U>.
3684 T determines the numerical type of the expression: it can be either
3685 mpz_t, mpq_t, or mpfr_t. When the arguments of a binary
3686 expression have different numerical types, __gmp_resolve_expr is used
3687 to determine the "larger" type.
3688 U is either __gmp_unary_expr<V, Op> or __gmp_binary_expr<V, W, Op>,
3689 where V and W are the arguments' types -- they can in turn be
3690 expressions, thus allowing to build compound expressions to any
3691 degree of complexity.
3692 Op is a function object that must have an eval() method accepting
3693 appropriate arguments.
3694 Actual evaluation of a __gmp_expr<T, U> object is done when it gets
3695 assigned to an mp*_class ("lazy" evaluation): this is done by calling
3696 its eval() method. */
3697
3698
3699// non-member void operators and functions (not in gmpxx)
3700
3701#define __GMP_DEFINE_VOID_FUNCTION(T, fun, eval_fun) \
3702 \
3703inline __gmp_expr \
3704<T, __gmp_void_expr<eval_fun> > \
3705fun() \
3706{ \
3707 return __gmp_expr<T, __gmp_void_expr \
3708 <eval_fun> >(); \
3709}
3710
3711
3712// non-member unary operators and functions
3713
3714#define __GMP_DEFINE_UNARY_FUNCTION(fun, eval_fun) \
3715 \
3716template <class T, class U> \
3717inline __gmp_expr<T, __gmp_unary_expr<__gmp_expr<T, U>, eval_fun> > \
3718fun(const __gmp_expr<T, U> &expr) \
3719{ \
3720 return __gmp_expr<T, __gmp_unary_expr<__gmp_expr<T, U>, eval_fun> >(expr); \
3721}
3722
3723
3724
3725#define __GMP_DEFINE_UNARY_TYPE_FUNCTION(type, fun, eval_fun) \
3726 \
3727template <class T, class U> \
3728inline type fun(const __gmp_expr<T, U> &expr) \
3729{ \
3730 typename __gmp_resolve_temp<T, T, U>::temp_type temp(expr); \
3731 return eval_fun::eval(temp.__get_mp()); \
3732}
3733
3734// not in gmpxx
3735#define __GMP_DEFINE_UNARY_FUNCTION_UI(T, fun, eval_fun) \
3736 \
3737inline __gmp_expr \
3738<T, __gmp_unary_expr<unsigned long int, eval_fun> > \
3739fun(unsigned long int l) \
3740{ \
3741 return __gmp_expr<T, __gmp_unary_expr \
3742 <unsigned long int, eval_fun> >(l); \
3743}
3744
3745
3746// non-member binary operators and functions
3747// the second (more specialized) template was not in gmpxx
3748// but seems to be necessary to avoid ambiguity with e.g. the
3749// max template in <algorithm>
3750
3751#define __GMPP_DEFINE_BINARY_FUNCTION(fun, eval_fun) \
3752 \
3753template <class T, class U, class V, class W> \
3754inline __gmp_expr<typename __gmp_resolve_expr<T, V>::value_type, \
3755__gmp_binary_expr<__gmp_expr<T, U>, __gmp_expr<V, W>, eval_fun> > \
3756fun(const __gmp_expr<T, U> &expr1, const __gmp_expr<V, W> &expr2) \
3757{ \
3758 return __gmp_expr<typename __gmp_resolve_expr<T, V>::value_type, \
3759 __gmp_binary_expr<__gmp_expr<T, U>, __gmp_expr<V, W>, eval_fun> > \
3760 (expr1, expr2); \
3761} \
3762 \
3763template <class T, class U> \
3764inline __gmp_expr<typename __gmp_resolve_expr<T, T>::value_type, \
3765__gmp_binary_expr<__gmp_expr<T, U>, __gmp_expr<T, U>, eval_fun> > \
3766fun(const __gmp_expr<T, U> &expr1, const __gmp_expr<T, U> &expr2) \
3767{ \
3768 return __gmp_expr<typename __gmp_resolve_expr<T, T>::value_type, \
3769 __gmp_binary_expr<__gmp_expr<T, U>, __gmp_expr<T, U>, eval_fun> > \
3770 (expr1, expr2); \
3771}
3772
3773#define __GMPNN_DEFINE_BINARY_FUNCTION(fun, eval_fun, type, bigtype) \
3774 \
3775template <class T, class U> \
3776inline __gmp_expr \
3777<T, __gmp_binary_expr<__gmp_expr<T, U>, bigtype, eval_fun> > \
3778fun(const __gmp_expr<T, U> &expr, type t) \
3779{ \
3780 return __gmp_expr \
3781 <T, __gmp_binary_expr<__gmp_expr<T, U>, bigtype, eval_fun> >(expr, t); \
3782} \
3783 \
3784template <class T, class U> \
3785inline __gmp_expr \
3786<T, __gmp_binary_expr<bigtype, __gmp_expr<T, U>, eval_fun> > \
3787fun(type t, const __gmp_expr<T, U> &expr) \
3788{ \
3789 return __gmp_expr \
3790 <T, __gmp_binary_expr<bigtype, __gmp_expr<T, U>, eval_fun> >(t, expr); \
3791}
3792
3793#define __GMPNS_DEFINE_BINARY_FUNCTION(fun, eval_fun, type) \
3794__GMPNN_DEFINE_BINARY_FUNCTION(fun, eval_fun, type, signed long int)
3795
3796#define __GMPNU_DEFINE_BINARY_FUNCTION(fun, eval_fun, type) \
3797__GMPNN_DEFINE_BINARY_FUNCTION(fun, eval_fun, type, unsigned long int)
3798
3799#define __GMPND_DEFINE_BINARY_FUNCTION(fun, eval_fun, type) \
3800__GMPNN_DEFINE_BINARY_FUNCTION(fun, eval_fun, type, double)
3801
3802#define __GMPNLD_DEFINE_BINARY_FUNCTION(fun, eval_fun, type) \
3803__GMPNN_DEFINE_BINARY_FUNCTION(fun, eval_fun, type, long double)
3804
3805#define __GMPN_DEFINE_BINARY_FUNCTION(fun, eval_fun) \
3806__GMPNS_DEFINE_BINARY_FUNCTION(fun, eval_fun, signed char) \
3807__GMPNU_DEFINE_BINARY_FUNCTION(fun, eval_fun, unsigned char) \
3808__GMPNS_DEFINE_BINARY_FUNCTION(fun, eval_fun, signed int) \
3809__GMPNU_DEFINE_BINARY_FUNCTION(fun, eval_fun, unsigned int) \
3810__GMPNS_DEFINE_BINARY_FUNCTION(fun, eval_fun, signed short int) \
3811__GMPNU_DEFINE_BINARY_FUNCTION(fun, eval_fun, unsigned short int) \
3812__GMPNS_DEFINE_BINARY_FUNCTION(fun, eval_fun, signed long int) \
3813__GMPNU_DEFINE_BINARY_FUNCTION(fun, eval_fun, unsigned long int) \
3814__GMPND_DEFINE_BINARY_FUNCTION(fun, eval_fun, float) \
3815__GMPND_DEFINE_BINARY_FUNCTION(fun, eval_fun, double) \
3816__GMPNLD_DEFINE_BINARY_FUNCTION(fun, eval_fun, long double)
3817
3818#define __GMP_DEFINE_BINARY_FUNCTION(fun, eval_fun) \
3819__GMPP_DEFINE_BINARY_FUNCTION(fun, eval_fun) \
3820__GMPN_DEFINE_BINARY_FUNCTION(fun, eval_fun)
3821
3822// the UI version is in gmpxx, but doesn't seem to be necessary unless
3823// the point is to generate a warning if you pass a negative integer
3824#define __GMP_DEFINE_BINARY_FUNCTION_UI(fun, eval_fun) \
3825 \
3826template <class T, class U> \
3827inline __gmp_expr \
3828<T, __gmp_binary_expr<__gmp_expr<T, U>, unsigned long int, eval_fun> > \
3829fun(const __gmp_expr<T, U> &expr, unsigned long int l) \
3830{ \
3831 return __gmp_expr<T, __gmp_binary_expr \
3832 <__gmp_expr<T, U>, unsigned long int, eval_fun> >(expr, l); \
3833}
3834
3835// not in gmpxx. I needed it for pow_ui
3836#define __GMP_DEFINE_BINARY_FUNCTION_UI_UI(T, fun, eval_fun) \
3837 \
3838inline __gmp_expr \
3839<T, __gmp_binary_expr<unsigned long int, unsigned long int, eval_fun> > \
3840fun(unsigned long int r, unsigned long int l) \
3841{ \
3842 return __gmp_expr<T, __gmp_binary_expr \
3843 <unsigned long int, unsigned long int, eval_fun> >(r, l); \
3844}
3845
3846
3847#define __GMPP_DEFINE_BINARY_TYPE_FUNCTION(type, fun, eval_fun) \
3848 \
3849template <class T, class U, class V, class W> \
3850inline type fun(const __gmp_expr<T, U> &expr1, \
3851 const __gmp_expr<V, W> &expr2) \
3852{ \
3853 typedef typename __gmp_resolve_expr<T, V>::value_type eval_type; \
3854 typename __gmp_resolve_temp<eval_type, T, U>::temp_type temp1(expr1); \
3855 typename __gmp_resolve_temp<eval_type, V, W>::temp_type temp2(expr2); \
3856 return eval_fun::eval(temp1.__get_mp(), temp2.__get_mp()); \
3857}
3858
3859#define __GMPNN_DEFINE_BINARY_TYPE_FUNCTION(type, fun, eval_fun, \
3860 type2, bigtype) \
3861 \
3862template <class T, class U> \
3863inline type fun(const __gmp_expr<T, U> &expr, type2 t) \
3864{ \
3865 typename __gmp_resolve_temp<T, T, U>::temp_type temp(expr); \
3866 return eval_fun::eval(temp.__get_mp(), static_cast<bigtype>(t)); \
3867} \
3868 \
3869template <class T, class U> \
3870inline type fun(type2 t, const __gmp_expr<T, U> &expr) \
3871{ \
3872 typename __gmp_resolve_temp<T, T, U>::temp_type temp(expr); \
3873 return eval_fun::eval(static_cast<bigtype>(t), temp.__get_mp()); \
3874}
3875
3876#define __GMPNS_DEFINE_BINARY_TYPE_FUNCTION(type, fun, eval_fun, type2) \
3877__GMPNN_DEFINE_BINARY_TYPE_FUNCTION(type, fun, eval_fun, \
3878 type2, signed long int)
3879
3880#define __GMPNU_DEFINE_BINARY_TYPE_FUNCTION(type, fun, eval_fun, type2) \
3881__GMPNN_DEFINE_BINARY_TYPE_FUNCTION(type, fun, eval_fun, \
3882 type2, unsigned long int)
3883
3884#define __GMPND_DEFINE_BINARY_TYPE_FUNCTION(type, fun, eval_fun, type2) \
3885__GMPNN_DEFINE_BINARY_TYPE_FUNCTION(type, fun, eval_fun, type2, double)
3886
3887#define __GMPNLD_DEFINE_BINARY_TYPE_FUNCTION(type, fun, eval_fun, type2) \
3888__GMPNN_DEFINE_BINARY_TYPE_FUNCTION(type, fun, eval_fun, type2, long double)
3889
3890#define __GMPN_DEFINE_BINARY_TYPE_FUNCTION(type, fun, eval_fun) \
3891__GMPNS_DEFINE_BINARY_TYPE_FUNCTION(type, fun, eval_fun, signed char) \
3892__GMPNU_DEFINE_BINARY_TYPE_FUNCTION(type, fun, eval_fun, unsigned char) \
3893__GMPNS_DEFINE_BINARY_TYPE_FUNCTION(type, fun, eval_fun, signed int) \
3894__GMPNU_DEFINE_BINARY_TYPE_FUNCTION(type, fun, eval_fun, unsigned int) \
3895__GMPNS_DEFINE_BINARY_TYPE_FUNCTION(type, fun, eval_fun, signed short int) \
3896__GMPNU_DEFINE_BINARY_TYPE_FUNCTION(type, fun, eval_fun, unsigned short int) \
3897__GMPNS_DEFINE_BINARY_TYPE_FUNCTION(type, fun, eval_fun, signed long int) \
3898__GMPNU_DEFINE_BINARY_TYPE_FUNCTION(type, fun, eval_fun, unsigned long int) \
3899__GMPND_DEFINE_BINARY_TYPE_FUNCTION(type, fun, eval_fun, float) \
3900__GMPND_DEFINE_BINARY_TYPE_FUNCTION(type, fun, eval_fun, double) \
3901__GMPNLD_DEFINE_BINARY_TYPE_FUNCTION(type, fun, eval_fun, long double)
3902
3903#define __GMP_DEFINE_BINARY_TYPE_FUNCTION(type, fun, eval_fun) \
3904__GMPP_DEFINE_BINARY_TYPE_FUNCTION(type, fun, eval_fun) \
3905__GMPN_DEFINE_BINARY_TYPE_FUNCTION(type, fun, eval_fun)
3906
3907
3908// member operators
3909
3910#define __GMPP_DEFINE_COMPOUND_OPERATOR(type, fun, eval_fun) \
3911 \
3912template <class T, class U> \
3913inline type##_class & type##_class::fun(const __gmp_expr<T, U> &expr) \
3914{ \
3915 __gmp_set_expr(mp, __gmp_expr<type##_t, __gmp_binary_expr \
3916 <type##_class, __gmp_expr<T, U>, eval_fun> >(*this, expr)); \
3917 return *this; \
3918}
3919
3920#define __GMPNN_DEFINE_COMPOUND_OPERATOR(type, fun, eval_fun, \
3921 type2, bigtype) \
3922 \
3923inline type##_class & type##_class::fun(type2 t) \
3924{ \
3925 __gmp_set_expr(mp, __gmp_expr<type##_t, __gmp_binary_expr \
3926 <type##_class, bigtype, eval_fun> >(*this, t)); \
3927 return *this; \
3928}
3929
3930#define __GMPNS_DEFINE_COMPOUND_OPERATOR(type, fun, eval_fun, type2) \
3931__GMPNN_DEFINE_COMPOUND_OPERATOR(type, fun, eval_fun, \
3932 type2, signed long int)
3933
3934#define __GMPNU_DEFINE_COMPOUND_OPERATOR(type, fun, eval_fun, type2) \
3935__GMPNN_DEFINE_COMPOUND_OPERATOR(type, fun, eval_fun, \
3936 type2, unsigned long int)
3937
3938#define __GMPND_DEFINE_COMPOUND_OPERATOR(type, fun, eval_fun, type2) \
3939__GMPNN_DEFINE_COMPOUND_OPERATOR(type, fun, eval_fun, type2, double)
3940
3941#define __GMPNLD_DEFINE_COMPOUND_OPERATOR(type, fun, eval_fun, type2) \
3942__GMPNN_DEFINE_COMPOUND_OPERATOR(type, fun, eval_fun, type2, long double)
3943
3944#define __GMPN_DEFINE_COMPOUND_OPERATOR(type, fun, eval_fun) \
3945__GMPNS_DEFINE_COMPOUND_OPERATOR(type, fun, eval_fun, signed char) \
3946__GMPNU_DEFINE_COMPOUND_OPERATOR(type, fun, eval_fun, unsigned char) \
3947__GMPNS_DEFINE_COMPOUND_OPERATOR(type, fun, eval_fun, signed int) \
3948__GMPNU_DEFINE_COMPOUND_OPERATOR(type, fun, eval_fun, unsigned int) \
3949__GMPNS_DEFINE_COMPOUND_OPERATOR(type, fun, eval_fun, signed short int) \
3950__GMPNU_DEFINE_COMPOUND_OPERATOR(type, fun, eval_fun, unsigned short int) \
3951__GMPNS_DEFINE_COMPOUND_OPERATOR(type, fun, eval_fun, signed long int) \
3952__GMPNU_DEFINE_COMPOUND_OPERATOR(type, fun, eval_fun, unsigned long int) \
3953__GMPND_DEFINE_COMPOUND_OPERATOR(type, fun, eval_fun, float) \
3954__GMPND_DEFINE_COMPOUND_OPERATOR(type, fun, eval_fun, double) \
3955/* __GMPNLD_DEFINE_COMPOUND_OPERATOR(type, fun, eval_fun, long double) */
3956
3957#define __GMP_DEFINE_COMPOUND_OPERATOR(type, fun, eval_fun) \
3958__GMPP_DEFINE_COMPOUND_OPERATOR(type, fun, eval_fun) \
3959__GMPN_DEFINE_COMPOUND_OPERATOR(type, fun, eval_fun)
3960
3961#define __GMPZ_DEFINE_COMPOUND_OPERATOR(fun, eval_fun) \
3962__GMP_DEFINE_COMPOUND_OPERATOR(mpz, fun, eval_fun)
3963
3964#define __GMPZZ_DEFINE_COMPOUND_OPERATOR(fun, eval_fun) \
3965__GMPP_DEFINE_COMPOUND_OPERATOR(mpz, fun, eval_fun)
3966
3967#define __GMPQ_DEFINE_COMPOUND_OPERATOR(fun, eval_fun) \
3968__GMP_DEFINE_COMPOUND_OPERATOR(mpq, fun, eval_fun)
3969
3970#define __MPFR_DEFINE_COMPOUND_OPERATOR(fun, eval_fun) \
3971__GMP_DEFINE_COMPOUND_OPERATOR(mpfr, fun, eval_fun)
3972
3973
3974
3975#define __GMP_DEFINE_COMPOUND_OPERATOR_UI(type, fun, eval_fun) \
3976 \
3977inline type##_class & type##_class::fun(unsigned long int l) \
3978{ \
3979 __gmp_set_expr(mp, __gmp_expr<type##_t, __gmp_binary_expr \
3980 <type##_class, unsigned long int, eval_fun> >(*this, l)); \
3981 return *this; \
3982}
3983
3984#define __GMPZ_DEFINE_COMPOUND_OPERATOR_UI(fun, eval_fun) \
3985__GMP_DEFINE_COMPOUND_OPERATOR_UI(mpz, fun, eval_fun)
3986
3987#define __GMPQ_DEFINE_COMPOUND_OPERATOR_UI(fun, eval_fun) \
3988__GMP_DEFINE_COMPOUND_OPERATOR_UI(mpq, fun, eval_fun)
3989
3990#define __MPFR_DEFINE_COMPOUND_OPERATOR_UI(fun, eval_fun) \
3991__GMP_DEFINE_COMPOUND_OPERATOR_UI(mpfr, fun, eval_fun)
3992
3993
3994
3995#define __GMP_DEFINE_INCREMENT_OPERATOR(type, fun, eval_fun) \
3996 \
3997inline type##_class & type##_class::fun() \
3998{ \
3999 eval_fun::eval(mp); \
4000 return *this; \
4001} \
4002 \
4003inline type##_class type##_class::fun(int) \
4004{ \
4005 type##_class temp(*this); \
4006 eval_fun::eval(mp); \
4007 return temp; \
4008}
4009
4010#define __GMPZ_DEFINE_INCREMENT_OPERATOR(fun, eval_fun) \
4011__GMP_DEFINE_INCREMENT_OPERATOR(mpz, fun, eval_fun)
4012
4013#define __GMPQ_DEFINE_INCREMENT_OPERATOR(fun, eval_fun) \
4014__GMP_DEFINE_INCREMENT_OPERATOR(mpq, fun, eval_fun)
4015
4016#define __MPFR_DEFINE_INCREMENT_OPERATOR(fun, eval_fun) \
4017__GMP_DEFINE_INCREMENT_OPERATOR(mpfr, fun, eval_fun)
4018
4019
4020
4021/**************** Arithmetic operators and functions ****************/
4022
4023// non-member operators and functions
4024
4028
4040
4046__GMP_DEFINE_BINARY_TYPE_FUNCTION(bool, operator>=, \
4048
4050
4113
4116
4119
4120// member operators for mpz_class
4127
4131
4134
4138
4139// member operators for mpq_class
4145
4148
4152
4153// member operators for mpfr_class
4159
4162
4166
4167
4168
4169/**************** Class wrapper for gmp_randstate_t ****************/
4170
4173
4174template <>
4176{
4177private:
4178 __gmp_randstate_struct *state;
4179 unsigned long int bits;
4180public:
4181 __gmp_expr(gmp_randstate_t s, unsigned long int l) : state(s), bits(l) { }
4182 void eval(mpz_ptr z) const { __gmp_rand_function::eval(z, state, bits); }
4183 unsigned long int get_prec() const { return mpfr_get_default_prec(); }
4184};
4185
4186template <>
4188{
4189private:
4190 __gmp_randstate_struct *state;
4192public:
4193 __gmp_expr(gmp_randstate_t s, const mpz_class &z) : state(s), range(z) { }
4194 void eval(mpz_ptr z) const
4195 { __gmp_rand_function::eval(z, state, range.get_mpz_t()); }
4196 unsigned long int get_prec() const { return mpfr_get_default_prec(); }
4197};
4198
4199template <>
4201{
4202private:
4203 __gmp_randstate_struct *state;
4204 unsigned long int bits;
4205public:
4206 __gmp_expr(gmp_randstate_t s, unsigned long int l) : state(s), bits(l) { }
4207 void eval(mpfr_ptr f, unsigned long int prec) const
4208 { __gmp_rand_function::eval(f, state, (bits>0) ? get_prec() : prec); }
4209 unsigned long int get_prec() const
4210 {
4211 if (bits == 0)
4212 return mpfr_get_default_prec();
4213 else
4214 return bits;
4215 }
4216};
4217
4218extern "C" {
4219 typedef void __gmp_randinit_default_t (gmp_randstate_t);
4220 typedef void __gmp_randinit_lc_2exp_t (gmp_randstate_t, mpz_srcptr, unsigned long int, unsigned long int);
4221 typedef int __gmp_randinit_lc_2exp_size_t (gmp_randstate_t, unsigned long int);
4222}
4223
4225{
4226private:
4227 gmp_randstate_t state;
4228
4229 // copy construction and assignment not allowed
4232public:
4233 // constructors and destructor
4234 gmp_randclass(gmp_randalg_t alg, unsigned long int size)
4235 {
4236 switch (alg)
4237 {
4238 case GMP_RAND_ALG_LC: // no other cases for now
4239 default:
4240 gmp_randinit(state, alg, size);
4241 break;
4242 }
4243 }
4244
4245 // gmp_randinit_default
4247
4248 // gmp_randinit_lc_2exp
4250 mpz_class z, unsigned long int l1, unsigned long int l2)
4251 { f(state, z.get_mpz_t(), l1, l2); }
4252
4253 // gmp_randinit_lc_2exp_size
4255 unsigned long int size)
4256 {
4257 if (f (state, size) == 0)
4258 throw std::length_error ("gmp_randinit_lc_2exp_size");
4259 }
4260
4261 ~gmp_randclass() { gmp_randclear(state); }
4262
4263 // initialize
4264 void seed(); // choose a random seed some way (?)
4265 void seed(unsigned long int s) { gmp_randseed_ui(state, s); }
4266 void seed(const mpz_class &z) { gmp_randseed(state, z.get_mpz_t()); }
4267
4268 // get random number
4271
4273 { return get_z_bits(z.get_ui()); }
4274
4277
4279 { return __gmp_expr<mpfr_t, __gmp_urandomb_value>(state, prec); }
4280};
4281
4282
4283/**************** #undef all private macros ****************/
4284
4285#undef __GMPP_DECLARE_COMPOUND_OPERATOR
4286#undef __GMPN_DECLARE_COMPOUND_OPERATOR
4287#undef __GMP_DECLARE_COMPOUND_OPERATOR
4288#undef __GMP_DECLARE_COMPOUND_OPERATOR_UI
4289#undef __GMP_DECLARE_INCREMENT_OPERATOR
4290
4291#undef __GMPZQ_DEFINE_EXPR
4292#undef __GMP_DEFINE_TERNARY_EXPR
4293
4294#undef __GMP_DEFINE_VOID_FUNCTION
4295
4296#undef __GMP_DEFINE_UNARY_FUNCTION
4297#undef __GMP_DEFINE_UNARY_TYPE_FUNCTION
4298#undef __GMP_DEFINE_UNARY_FUNCTION_UI
4299
4300#undef __GMPP_DEFINE_BINARY_FUNCTION
4301#undef __GMPNN_DEFINE_BINARY_FUNCTION
4302#undef __GMPNS_DEFINE_BINARY_FUNCTION
4303#undef __GMPNU_DEFINE_BINARY_FUNCTION
4304#undef __GMPND_DEFINE_BINARY_FUNCTION
4305#undef __GMPNLD_DEFINE_BINARY_FUNCTION
4306#undef __GMPN_DEFINE_BINARY_FUNCTION
4307#undef __GMP_DEFINE_BINARY_FUNCTION
4308
4309#undef __GMP_DEFINE_BINARY_FUNCTION_UI
4310
4311#undef __GMPP_DEFINE_BINARY_TYPE_FUNCTION
4312#undef __GMPNN_DEFINE_BINARY_TYPE_FUNCTION
4313#undef __GMPNS_DEFINE_BINARY_TYPE_FUNCTION
4314#undef __GMPNU_DEFINE_BINARY_TYPE_FUNCTION
4315#undef __GMPND_DEFINE_BINARY_TYPE_FUNCTION
4316#undef __GMPNLD_DEFINE_BINARY_TYPE_FUNCTION
4317#undef __GMPN_DEFINE_BINARY_TYPE_FUNCTION
4318#undef __GMP_DEFINE_BINARY_TYPE_FUNCTION
4319
4320#undef __GMPP_DECLARE_COMPOUND_OPERATOR
4321#undef __GMPN_DECLARE_COMPOUND_OPERATOR
4322#undef __GMP_DECLARE_COMPOUND_OPERATOR
4323
4324#undef __GMP_DECLARE_COMPOUND_OPERATOR_UI
4325#undef __GMP_DECLARE_INCREMENT_OPERATOR
4326
4327#undef __GMPZ_DEFINE_COMPOUND_OPERATOR
4328#undef __GMPZZ_DEFINE_COMPOUND_OPERATOR
4329#undef __GMPZN_DEFINE_COMPOUND_OPERATOR
4330#undef __GMPZNN_DEFINE_COMPOUND_OPERATOR
4331#undef __GMPZNS_DEFINE_COMPOUND_OPERATOR
4332#undef __GMPZNU_DEFINE_COMPOUND_OPERATOR
4333#undef __GMPZND_DEFINE_COMPOUND_OPERATOR
4334#undef __GMPZNLD_DEFINE_COMPOUND_OPERATOR
4335
4336#undef __GMPP_DEFINE_COMPOUND_OPERATOR
4337#undef __GMPNN_DEFINE_COMPOUND_OPERATOR
4338#undef __GMPNS_DEFINE_COMPOUND_OPERATOR
4339#undef __GMPNU_DEFINE_COMPOUND_OPERATOR
4340#undef __GMPND_DEFINE_COMPOUND_OPERATOR
4341#undef __GMPNLD_DEFINE_COMPOUND_OPERATOR
4342#undef __GMPN_DEFINE_COMPOUND_OPERATOR
4343#undef __GMP_DEFINE_COMPOUND_OPERATOR
4344
4345#undef __GMPZ_DEFINE_COMPOUND_OPERATOR
4346#undef __GMPZZ_DEFINE_COMPOUND_OPERATOR
4347#undef __GMPQ_DEFINE_COMPOUND_OPERATOR
4348#undef __MPFR_DEFINE_COMPOUND_OPERATOR
4349
4350#undef __GMP_DEFINE_COMPOUND_OPERATOR_UI
4351#undef __GMPZ_DEFINE_COMPOUND_OPERATOR_UI
4352#undef __GMPQ_DEFINE_COMPOUND_OPERATOR_UI
4353#undef __MPFR_DEFINE_COMPOUND_OPERATOR_UI
4354
4355#undef __GMP_DEFINE_INCREMENT_OPERATOR
4356#undef __GMPZ_DEFINE_INCREMENT_OPERATOR
4357#undef __GMPQ_DEFINE_INCREMENT_OPERATOR
4358#undef __MPFR_DEFINE_INCREMENT_OPERATOR
4359
4360#endif /* __GMP_PLUSPLUS__ */
long double h
Definition btreepic.C:154
long double w
Definition btreepic.C:153
static void set_dprec(mpfr_prec_t p=53)
Definition gmpfrxx.h:110
static mpfr_prec_t get_dprec()
Definition gmpfrxx.h:109
static int base
Definition gmpfrxx.h:102
static void set_base(int b=10)
Definition gmpfrxx.h:105
static void set_rnd(mpfr_rnd_t r=GMP_RNDN)
Definition gmpfrxx.h:107
static int get_base()
Definition gmpfrxx.h:104
static mpfr_rnd_t get_rnd()
Definition gmpfrxx.h:106
static mpfr_rnd_t rnd
Definition gmpfrxx.h:101
__gmp_expr(const val1_type &val1, const val2_type &val2)
Definition gmpfrxx.h:2781
__gmp_binary_expr< val1_type, val2_type, Op > expr
Definition gmpfrxx.h:2778
void eval(typename __gmp_resolve_expr< T >::ptr_type p, unsigned long int=0) const
Definition gmpfrxx.h:2783
__gmp_expr(const val1_type &val1, const val2_type &val2)
Definition gmpfrxx.h:2760
__gmp_binary_expr< val1_type, val2_type, Op > expr
Definition gmpfrxx.h:2758
void eval(typename __gmp_resolve_expr< T >::ptr_type p, unsigned long int=0) const
Definition gmpfrxx.h:2762
void eval(typename __gmp_resolve_expr< T >::ptr_type p) const
Definition gmpfrxx.h:2967
__gmp_expr(const val1_type &val1, const val2_type &val2)
Definition gmpfrxx.h:2965
__gmp_binary_expr< val1_type, val2_type, Op > expr
Definition gmpfrxx.h:2963
void eval(typename __gmp_resolve_expr< T >::ptr_type p, unsigned long int prec) const
Definition gmpfrxx.h:2972
__gmp_expr(const val1_type &val1, const val2_type &val2)
Definition gmpfrxx.h:2741
__gmp_binary_expr< val1_type, val2_type, Op > expr
Definition gmpfrxx.h:2739
void eval(typename __gmp_resolve_expr< T >::ptr_type p, unsigned long int=0) const
Definition gmpfrxx.h:2743
void eval(typename __gmp_resolve_expr< T >::ptr_type p, unsigned long int=0) const
Definition gmpfrxx.h:2716
void eval(typename __gmp_resolve_expr< T >::ptr_type p, unsigned long int prec) const
Definition gmpfrxx.h:2811
void eval(typename __gmp_resolve_expr< T >::ptr_type p) const
Definition gmpfrxx.h:2806
void eval(typename __gmp_resolve_expr< T >::ptr_type p, unsigned long int prec) const
Definition gmpfrxx.h:2877
void eval(typename __gmp_resolve_expr< T >::ptr_type p) const
Definition gmpfrxx.h:2872
void eval(typename __gmp_resolve_expr< T >::ptr_type p, unsigned long int prec) const
Definition gmpfrxx.h:2945
__gmp_binary_expr< val1_type, val2_type, Op > expr
Definition gmpfrxx.h:2936
__gmp_expr(const val1_type &val1, const val2_type &val2)
Definition gmpfrxx.h:2938
void eval(typename __gmp_resolve_expr< T >::ptr_type p) const
Definition gmpfrxx.h:2940
void eval(typename __gmp_resolve_expr< T >::ptr_type p, unsigned long int prec) const
Definition gmpfrxx.h:3003
void eval(typename __gmp_resolve_expr< T >::ptr_type p) const
Definition gmpfrxx.h:2998
void eval(typename __gmp_resolve_expr< T >::ptr_type p) const
Definition gmpfrxx.h:2905
void eval(typename __gmp_resolve_expr< T >::ptr_type p, unsigned long int prec) const
Definition gmpfrxx.h:2910
void eval(typename __gmp_resolve_expr< T >::ptr_type p) const
Definition gmpfrxx.h:3064
void eval(typename __gmp_resolve_expr< T >::ptr_type p, unsigned long int prec) const
Definition gmpfrxx.h:3069
void eval(typename __gmp_resolve_expr< T >::ptr_type p) const
Definition gmpfrxx.h:2839
void eval(typename __gmp_resolve_expr< T >::ptr_type p, unsigned long int prec) const
Definition gmpfrxx.h:2844
void eval(typename __gmp_resolve_expr< T >::ptr_type p, unsigned long int prec) const
Definition gmpfrxx.h:3036
void eval(typename __gmp_resolve_expr< T >::ptr_type p) const
Definition gmpfrxx.h:3031
__gmp_unary_expr< val_type, Op > expr
Definition gmpfrxx.h:2659
unsigned long int get_prec() const
Definition gmpfrxx.h:2667
void eval(typename __gmp_resolve_expr< T >::ptr_type p, unsigned long int=0) const
Definition gmpfrxx.h:2663
void eval(typename __gmp_resolve_expr< T >::ptr_type p, unsigned long int=0) const
Definition gmpfrxx.h:2645
void eval(typename __gmp_resolve_expr< T >::ptr_type p) const
Definition gmpfrxx.h:2682
void eval(typename __gmp_resolve_expr< T >::ptr_type p, unsigned long int prec) const
Definition gmpfrxx.h:2684
unsigned long int get_prec() const
Definition gmpfrxx.h:2623
void eval(typename __gmp_resolve_expr< T >::ptr_type p, unsigned long int=0) const
Definition gmpfrxx.h:2620
unsigned long int get_prec() const
Definition gmpfrxx.h:4209
__gmp_expr(gmp_randstate_t s, unsigned long int l)
Definition gmpfrxx.h:4206
void eval(mpfr_ptr f, unsigned long int prec) const
Definition gmpfrxx.h:4207
int set_str(const std::string &s, int base)
Definition gmpfrxx.h:2390
__gmp_expr(unsigned long int l)
Definition gmpfrxx.h:2279
__gmp_expr(const std::string &s)
Definition gmpfrxx.h:2314
int set_str(const char *s, int base)
Definition gmpfrxx.h:2388
__gmp_expr(const __gmp_expr &f)
Definition gmpfrxx.h:2237
__gmp_expr(signed short int s, unsigned long int prec)
Definition gmpfrxx.h:2268
__gmp_expr & operator=(const __gmp_expr &f)
Definition gmpfrxx.h:2341
void prec_round(unsigned long int prec)
Definition gmpfrxx.h:2230
__gmp_expr(mpfr_srcptr f, unsigned long int prec)
Definition gmpfrxx.h:2335
__gmp_expr(const __gmp_expr< T, U > &expr, unsigned long int prec)
Definition gmpfrxx.h:2245
__gmp_expr(signed long int l)
Definition gmpfrxx.h:2275
__gmp_expr(const __gmp_expr &f, unsigned long int prec)
Definition gmpfrxx.h:2239
__gmp_expr(signed char c)
Definition gmpfrxx.h:2248
__gmp_expr(unsigned char c, unsigned long int prec)
Definition gmpfrxx.h:2254
__gmp_expr< value_type, value_type > & operator=(const __gmp_expr< T, U > &expr)
Definition gmpfrxx.h:2344
__gmp_expr & operator=(const std::string &s)
Definition gmpfrxx.h:2380
__gmp_expr(unsigned short int s)
Definition gmpfrxx.h:2270
signed long int get_si() const
Definition gmpfrxx.h:2405
__gmp_expr(unsigned int i)
Definition gmpfrxx.h:2261
__gmp_expr(signed char c, unsigned long int prec)
Definition gmpfrxx.h:2250
__gmp_expr(signed short int s)
Definition gmpfrxx.h:2266
__gmp_expr(const std::string &s, unsigned long int prec, int base=0)
Definition gmpfrxx.h:2323
__gmp_expr & operator=(unsigned char c)
Definition gmpfrxx.h:2349
__gmp_expr & operator=(unsigned long int l)
Definition gmpfrxx.h:2364
__gmp_expr & operator=(signed int i)
Definition gmpfrxx.h:2352
unsigned long int get_ui() const
Definition gmpfrxx.h:2407
mpfr_srcptr get_mpfr_t() const
Definition gmpfrxx.h:2402
unsigned long int get_prec() const
Definition gmpfrxx.h:2226
__gmp_expr(unsigned long int l, unsigned long int prec)
Definition gmpfrxx.h:2281
void set_prec(unsigned long int prec)
Definition gmpfrxx.h:2228
__gmp_expr(signed int i, unsigned long int prec)
Definition gmpfrxx.h:2259
__gmp_expr & operator=(signed long int l)
Definition gmpfrxx.h:2362
__gmp_expr(unsigned int i, unsigned long int prec)
Definition gmpfrxx.h:2263
std::string get_str(mp_exp_t &expo, int base=10, size_t size=0) const
Definition gmpfrxx.h:2392
__gmp_expr & operator=(unsigned short int s)
Definition gmpfrxx.h:2359
__gmp_expr(unsigned short int s, unsigned long int prec)
Definition gmpfrxx.h:2272
__gmp_expr & operator=(double d)
Definition gmpfrxx.h:2369
__gmp_expr(const char *s, unsigned long int prec, int base=0)
Definition gmpfrxx.h:2305
__gmp_expr(unsigned char c)
Definition gmpfrxx.h:2252
void set_prec_raw(unsigned long int prec)
Definition gmpfrxx.h:2229
mpfr_srcptr __get_mp() const
Definition gmpfrxx.h:2400
__gmp_expr & operator=(unsigned int i)
Definition gmpfrxx.h:2354
__gmp_expr(const __gmp_expr< T, U > &expr)
Definition gmpfrxx.h:2242
__gmp_expr & operator=(signed short int s)
Definition gmpfrxx.h:2357
__gmp_expr & operator=(signed char c)
Definition gmpfrxx.h:2347
__gmp_expr(double d, unsigned long int prec)
Definition gmpfrxx.h:2290
__gmp_expr(signed long int l, unsigned long int prec)
Definition gmpfrxx.h:2277
__gmp_expr & operator=(const char *s)
Definition gmpfrxx.h:2374
__gmp_expr(mpfr_srcptr f)
Definition gmpfrxx.h:2333
__gmp_expr(const char *s)
Definition gmpfrxx.h:2297
__gmp_expr & operator=(float f)
Definition gmpfrxx.h:2367
__gmp_expr(float f, unsigned long int prec)
Definition gmpfrxx.h:2286
__gmp_expr(const char *s, int base)
Definition gmpfrxx.h:2082
__gmp_expr(unsigned short int s)
Definition gmpfrxx.h:2064
__gmp_expr & operator=(float f)
Definition gmpfrxx.h:2146
__gmp_expr< value_type, value_type > & operator=(const __gmp_expr< T, U > &expr)
Definition gmpfrxx.h:2124
const mpz_class & get_num() const
Definition gmpfrxx.h:2180
__gmp_expr & operator=(unsigned long int l)
Definition gmpfrxx.h:2143
__gmp_expr(signed short int s)
Definition gmpfrxx.h:2063
__gmp_expr & operator=(signed char c)
Definition gmpfrxx.h:2127
__gmp_expr & operator=(signed int i)
Definition gmpfrxx.h:2132
__gmp_expr(signed long int l)
Definition gmpfrxx.h:2066
const mpz_class & get_den() const
Definition gmpfrxx.h:2184
__gmp_expr(signed int i)
Definition gmpfrxx.h:2060
__gmp_expr(const std::string &s, int base)
Definition gmpfrxx.h:2100
mpz_srcptr get_num_mpz_t() const
Definition gmpfrxx.h:2194
__gmp_expr & operator=(unsigned char c)
Definition gmpfrxx.h:2129
__gmp_expr & operator=(signed short int s)
Definition gmpfrxx.h:2136
__gmp_expr(unsigned long int l)
Definition gmpfrxx.h:2067
mpq_srcptr get_mpq_t() const
Definition gmpfrxx.h:2191
__gmp_expr(unsigned int i)
Definition gmpfrxx.h:2061
mpz_srcptr get_den_mpz_t() const
Definition gmpfrxx.h:2196
__gmp_expr & operator=(const std::string &s)
Definition gmpfrxx.h:2157
__gmp_expr(const __gmp_expr< T, U > &expr)
Definition gmpfrxx.h:2054
int set_str(const char *s, int base)
Definition gmpfrxx.h:2165
__gmp_expr & operator=(double d)
Definition gmpfrxx.h:2147
__gmp_expr(const __gmp_expr &q)
Definition gmpfrxx.h:2052
unsigned long int get_prec() const
Definition gmpfrxx.h:2046
__gmp_expr & operator=(const char *s)
Definition gmpfrxx.h:2151
__gmp_expr(unsigned char c)
Definition gmpfrxx.h:2058
__gmp_expr(mpq_srcptr q)
Definition gmpfrxx.h:2109
mpq_srcptr __get_mp() const
Definition gmpfrxx.h:2189
__gmp_expr & operator=(unsigned short int s)
Definition gmpfrxx.h:2138
std::string get_str(int base=10) const
Definition gmpfrxx.h:2169
__gmp_expr & operator=(signed long int l)
Definition gmpfrxx.h:2141
__gmp_expr(signed char c)
Definition gmpfrxx.h:2057
__gmp_expr(const std::string &s)
Definition gmpfrxx.h:2091
__gmp_expr & operator=(unsigned int i)
Definition gmpfrxx.h:2133
__gmp_expr & operator=(const __gmp_expr &q)
Definition gmpfrxx.h:2121
__gmp_expr(const mpz_class &num, const mpz_class &den)
Definition gmpfrxx.h:2111
int set_str(const std::string &s, int base)
Definition gmpfrxx.h:2167
__gmp_expr(const char *s)
Definition gmpfrxx.h:2073
unsigned long int get_prec() const
Definition gmpfrxx.h:4183
__gmp_expr(gmp_randstate_t s, unsigned long int l)
Definition gmpfrxx.h:4181
__gmp_expr(gmp_randstate_t s, const mpz_class &z)
Definition gmpfrxx.h:4193
unsigned long int get_prec() const
Definition gmpfrxx.h:4196
__gmp_expr(signed int i)
Definition gmpfrxx.h:1892
int set_str(const std::string &s, int base)
Definition gmpfrxx.h:1986
__gmp_expr & operator=(unsigned short int s)
Definition gmpfrxx.h:1957
signed long int get_si() const
Definition gmpfrxx.h:2000
__gmp_expr(signed char c)
Definition gmpfrxx.h:1889
mpz_srcptr get_mpz_t() const
Definition gmpfrxx.h:1997
__gmp_expr(unsigned char c)
Definition gmpfrxx.h:1890
__gmp_expr & operator=(signed char c)
Definition gmpfrxx.h:1949
__gmp_expr(const char *s)
Definition gmpfrxx.h:1905
__gmp_expr(mpz_srcptr z)
Definition gmpfrxx.h:1938
__gmp_expr & operator=(unsigned int i)
Definition gmpfrxx.h:1953
__gmp_expr(const char *s, int base)
Definition gmpfrxx.h:1913
std::string get_str(int base=10) const
Definition gmpfrxx.h:1988
__gmp_expr & operator=(const __gmp_expr &z)
Definition gmpfrxx.h:1943
__gmp_expr & operator=(float f)
Definition gmpfrxx.h:1965
bool fits_sshort_p() const
Definition gmpfrxx.h:2008
__gmp_expr(const __gmp_expr &z)
Definition gmpfrxx.h:1884
__gmp_expr(const std::string &s)
Definition gmpfrxx.h:1921
__gmp_expr(unsigned long int l)
Definition gmpfrxx.h:1899
__gmp_expr(unsigned short int s)
Definition gmpfrxx.h:1896
bool fits_slong_p() const
Definition gmpfrxx.h:2010
__gmp_expr(unsigned int i)
Definition gmpfrxx.h:1893
__gmp_expr(const __gmp_expr< T, U > &expr)
Definition gmpfrxx.h:1886
__gmp_expr< value_type, value_type > & operator=(const __gmp_expr< T, U > &expr)
Definition gmpfrxx.h:1946
unsigned long int get_ui() const
Definition gmpfrxx.h:2001
__gmp_expr & operator=(unsigned long int l)
Definition gmpfrxx.h:1962
__gmp_expr & operator=(unsigned char c)
Definition gmpfrxx.h:1950
bool fits_ushort_p() const
Definition gmpfrxx.h:2009
__gmp_expr(signed long int l)
Definition gmpfrxx.h:1898
__gmp_expr(signed short int s)
Definition gmpfrxx.h:1895
__gmp_expr & operator=(signed int i)
Definition gmpfrxx.h:1952
__gmp_expr & operator=(const std::string &s)
Definition gmpfrxx.h:1976
__gmp_expr(const std::string &s, int base)
Definition gmpfrxx.h:1929
__gmp_expr & operator=(signed short int s)
Definition gmpfrxx.h:1955
__gmp_expr & operator=(double d)
Definition gmpfrxx.h:1966
int set_str(const char *s, int base)
Definition gmpfrxx.h:1984
bool fits_ulong_p() const
Definition gmpfrxx.h:2011
__gmp_expr & operator=(const char *s)
Definition gmpfrxx.h:1970
unsigned long int get_prec() const
Definition gmpfrxx.h:1879
mpz_srcptr __get_mp() const
Definition gmpfrxx.h:1995
__gmp_expr & operator=(signed long int l)
Definition gmpfrxx.h:1960
__gmp_expr< mpz_t, __gmp_urandomb_value > get_z_bits(const mpz_class &z)
Definition gmpfrxx.h:4272
__gmp_expr< mpz_t, __gmp_urandomm_value > get_z_range(const mpz_class &z)
Definition gmpfrxx.h:4275
void operator=(const gmp_randclass &)
gmp_randstate_t state
Definition gmpfrxx.h:4227
__gmp_expr< mpfr_t, __gmp_urandomb_value > get_f(unsigned long int prec=0)
Definition gmpfrxx.h:4278
gmp_randclass(gmp_randalg_t alg, unsigned long int size)
Definition gmpfrxx.h:4234
gmp_randclass(__gmp_randinit_default_t *f)
Definition gmpfrxx.h:4246
gmp_randclass(const gmp_randclass &)
gmp_randclass(__gmp_randinit_lc_2exp_t *f, mpz_class z, unsigned long int l1, unsigned long int l2)
Definition gmpfrxx.h:4249
void seed(const mpz_class &z)
Definition gmpfrxx.h:4266
__gmp_expr< mpz_t, __gmp_urandomb_value > get_z_bits(unsigned long int l)
Definition gmpfrxx.h:4269
gmp_randclass(__gmp_randinit_lc_2exp_size_t *f, unsigned long int size)
Definition gmpfrxx.h:4254
void seed(unsigned long int s)
Definition gmpfrxx.h:4265
istream & operator>>(istream &s, mpfr_ptr a)
Definition gmpfrxx.C:51
void mpz_set_mpfr(mpz_ptr w, mpfr_srcptr u)
Definition gmpfrxx.C:133
void mpq_set_mpfr(mpq_ptr w, mpfr_srcptr u)
Definition gmpfrxx.C:175
__gmp_expr< T, __gmp_unary_expr< __gmp_expr< T, U >, __gmp_log10_function > > log10(const __gmp_expr< T, U > &expr)
Definition gmpfrxx.h:4065
__gmp_expr< typename __gmp_resolve_expr< T, V >::value_type, __gmp_binary_expr< __gmp_expr< T, U >, __gmp_expr< V, W >, __gmp_hypot_function > > hypot(const __gmp_expr< T, U > &expr1, const __gmp_expr< V, W > &expr2)
Definition gmpfrxx.h:4112
#define __GMPZQ_DEFINE_EXPR(eval_fun)
Definition gmpfrxx.h:3093
__gmp_expr< T, __gmp_unary_expr< __gmp_expr< T, U >, __gmp_cot_function > > cot(const __gmp_expr< T, U > &expr)
Definition gmpfrxx.h:4074
__gmp_expr< typename __gmp_resolve_expr< T, V >::value_type, __gmp_binary_expr< __gmp_expr< T, U >, __gmp_expr< V, W >, __gmp_jn_function > > jn(const __gmp_expr< T, U > &expr1, const __gmp_expr< V, W > &expr2)
Definition gmpfrxx.h:4101
__gmp_expr< T, __gmp_unary_expr< __gmp_expr< T, U >, __gmp_sec_function > > sec(const __gmp_expr< T, U > &expr)
Definition gmpfrxx.h:4072
__gmp_expr< T, __gmp_unary_expr< __gmp_expr< T, U >, __gmp_log2_function > > log2(const __gmp_expr< T, U > &expr)
Definition gmpfrxx.h:4064
__gmp_expr< T, __gmp_unary_expr< __gmp_expr< T, U >, __gmp_y1_function > > y1(const __gmp_expr< T, U > &expr)
Definition gmpfrxx.h:4103
#define __GMP_DEFINE_BINARY_FUNCTION_UI_UI(T, fun, eval_fun)
Definition gmpfrxx.h:3836
__gmp_expr< T, __gmp_unary_expr< __gmp_expr< T, U >, __gmp_csch_function > > csch(const __gmp_expr< T, U > &expr)
Definition gmpfrxx.h:4083
void __gmp_randinit_lc_2exp_t(gmp_randstate_t, mpz_srcptr, unsigned long int, unsigned long int)
Definition gmpfrxx.h:4220
__gmp_expr< T, __gmp_unary_expr< __gmp_expr< T, U >, __gmp_cos_function > > cos(const __gmp_expr< T, U > &expr)
Definition gmpfrxx.h:4069
__gmp_expr< mpfr_t, __gmp_void_expr< __gmp_const_pi_function > > const_pi()
Definition gmpfrxx.h:4107
int cmpabs(const __gmp_expr< T, U > &expr1, const __gmp_expr< V, W > &expr2)
Definition gmpfrxx.h:4049
__gmp_expr< typename __gmp_resolve_expr< T, V >::value_type, __gmp_binary_expr< __gmp_expr< T, U >, __gmp_expr< V, W >, __gmp_yn_function > > yn(const __gmp_expr< T, U > &expr1, const __gmp_expr< V, W > &expr2)
Definition gmpfrxx.h:4104
__gmp_expr< mpfr_t, __gmp_void_expr< __gmp_const_euler_function > > const_euler()
Definition gmpfrxx.h:4108
__gmp_expr< T, __gmp_unary_expr< __gmp_expr< T, U >, __gmp_sqr_function > > sqr(const __gmp_expr< T, U > &expr)
Definition gmpfrxx.h:4057
__gmp_expr< T, __gmp_unary_expr< __gmp_expr< T, U >, __gmp_frac_function > > frac(const __gmp_expr< T, U > &expr)
Definition gmpfrxx.h:4114
__gmp_expr< T, __gmp_unary_expr< __gmp_expr< T, U >, __gmp_acos_function > > acos(const __gmp_expr< T, U > &expr)
Definition gmpfrxx.h:4075
__gmp_expr< T, __gmp_unary_expr< __gmp_expr< T, U >, __gmp_sech_function > > sech(const __gmp_expr< T, U > &expr)
Definition gmpfrxx.h:4082
__gmp_expr< T, __gmp_unary_expr< __gmp_expr< T, U >, __gmp_exp_function > > exp(const __gmp_expr< T, U > &expr)
Definition gmpfrxx.h:4066
__gmp_expr< typename __gmp_resolve_expr< T, V >::value_type, __gmp_binary_expr< __gmp_expr< T, U >, __gmp_expr< V, W >, __gmp_max_function > > max(const __gmp_expr< T, U > &expr1, const __gmp_expr< V, W > &expr2)
Definition gmpfrxx.h:4110
void __gmp_set_expr(mpz_ptr, const __gmp_expr< T, U > &)
__gmp_expr< mpfr_t, __gmp_unary_expr< unsigned long int, __gmp_zeta_function > > zeta_ui(unsigned long int l)
Definition gmpfrxx.h:4096
__gmp_expr< typename __gmp_resolve_expr< T, V >::value_type, __gmp_binary_expr< __gmp_expr< T, U >, __gmp_expr< V, W >, __gmp_dim_function > > dim(const __gmp_expr< T, U > &expr1, const __gmp_expr< V, W > &expr2)
Definition gmpfrxx.h:4052
__gmp_expr< T, __gmp_unary_expr< __gmp_expr< T, U >, __gmp_exp2_function > > exp2(const __gmp_expr< T, U > &expr)
Definition gmpfrxx.h:4067
__gmp_expr< T, __gmp_unary_expr< __gmp_expr< T, U >, __gmp_asin_function > > asin(const __gmp_expr< T, U > &expr)
Definition gmpfrxx.h:4076
#define __GMPZ_DEFINE_COMPOUND_OPERATOR_UI(fun, eval_fun)
Definition gmpfrxx.h:3984
#define __GMPP_DECLARE_COMPOUND_OPERATOR(fun)
Definition gmpfrxx.h:1841
#define __GMP_DEFINE_BINARY_FUNCTION(fun, eval_fun)
Definition gmpfrxx.h:3818
__gmp_expr< mpfr_t, __gmp_unary_expr< unsigned long int, __gmp_fac_ui_function > > fac_ui(unsigned long int l)
Definition gmpfrxx.h:4088
__gmp_expr< T, __gmp_unary_expr< __gmp_expr< T, U >, __gmp_log_function > > log(const __gmp_expr< T, U > &expr)
Definition gmpfrxx.h:4063
__gmp_expr< mpfr_t, __gmp_void_expr< __gmp_const_catalan_function > > const_catalan()
Definition gmpfrxx.h:4109
__gmp_expr< T, __gmp_unary_expr< __gmp_expr< T, U >, __gmp_cosh_function > > cosh(const __gmp_expr< T, U > &expr)
Definition gmpfrxx.h:4079
#define __GMP_DECLARE_COMPOUND_OPERATOR(fun)
Definition gmpfrxx.h:1858
__gmp_expr< T, __gmp_unary_expr< __gmp_expr< T, U >, __gmp_erf_function > > erf(const __gmp_expr< T, U > &expr)
Definition gmpfrxx.h:4097
#define __MPFR_DEFINE_COMPOUND_OPERATOR_UI(fun, eval_fun)
Definition gmpfrxx.h:3990
__gmp_expr< T, __gmp_unary_expr< __gmp_expr< T, U >, __gmp_sin_function > > sin(const __gmp_expr< T, U > &expr)
Definition gmpfrxx.h:4070
__gmp_expr< mpfr_t, __gmp_void_expr< __gmp_const_log2_function > > const_log2()
Definition gmpfrxx.h:4106
__gmp_expr< T, __gmp_unary_expr< __gmp_expr< T, U >, __gmp_erfc_function > > erfc(const __gmp_expr< T, U > &expr)
Definition gmpfrxx.h:4098
#define __GMP_DECLARE_COMPOUND_OPERATOR_UI(fun)
Definition gmpfrxx.h:1862
__gmp_expr< T, __gmp_unary_expr< __gmp_expr< T, U >, __gmp_acosh_function > > acosh(const __gmp_expr< T, U > &expr)
Definition gmpfrxx.h:4085
#define __GMPQ_DEFINE_INCREMENT_OPERATOR(fun, eval_fun)
Definition gmpfrxx.h:4013
__gmp_expr< T, __gmp_unary_expr< __gmp_expr< T, U >, __gmp_floor_function > > floor(const __gmp_expr< T, U > &expr)
Definition gmpfrxx.h:4055
__gmp_expr< typename __gmp_resolve_expr< T, V >::value_type, __gmp_binary_expr< __gmp_expr< T, U >, __gmp_expr< V, W >, __gmp_remainder_function > > remainder(const __gmp_expr< T, U > &expr1, const __gmp_expr< V, W > &expr2)
Definition gmpfrxx.h:4115
__gmp_expr< T, __gmp_unary_expr< __gmp_expr< T, U >, __gmp_sqrt_function > > sqrt(const __gmp_expr< T, U > &expr)
Definition gmpfrxx.h:4058
void mpz_set_mpfr(mpz_ptr w, mpfr_srcptr u)
Definition gmpfrxx.C:133
#define __GMP_DEFINE_TERNARY_EXPR(eval_fun1, eval_fun2, eval_both)
Definition gmpfrxx.h:3274
__gmp_expr< T, __gmp_unary_expr< __gmp_expr< T, U >, __gmp_abs_function > > abs(const __gmp_expr< T, U > &expr)
Definition gmpfrxx.h:4051
__gmp_expr< T, __gmp_unary_expr< __gmp_expr< T, U >, __gmp_tanh_function > > tanh(const __gmp_expr< T, U > &expr)
Definition gmpfrxx.h:4081
__gmp_expr< T, __gmp_unary_expr< __gmp_expr< T, U >, __gmp_csc_function > > csc(const __gmp_expr< T, U > &expr)
Definition gmpfrxx.h:4073
__gmp_expr< typename __gmp_resolve_expr< T, V >::value_type, __gmp_binary_expr< __gmp_expr< T, U >, __gmp_expr< V, W >, __gmp_atan2_function > > atan2(const __gmp_expr< T, U > &expr1, const __gmp_expr< V, W > &expr2)
Definition gmpfrxx.h:4078
__gmp_expr< T, __gmp_unary_expr< __gmp_expr< T, U >, __gmp_atan_function > > atan(const __gmp_expr< T, U > &expr)
Definition gmpfrxx.h:4077
__gmp_expr< T, __gmp_unary_expr< __gmp_expr< T, U >, __gmp_tan_function > > tan(const __gmp_expr< T, U > &expr)
Definition gmpfrxx.h:4071
__gmp_expr< T, __gmp_unary_expr< __gmp_expr< T, U >, __gmp_atanh_function > > atanh(const __gmp_expr< T, U > &expr)
Definition gmpfrxx.h:4087
__gmp_expr< T, __gmp_unary_expr< __gmp_expr< T, U >, __gmp_zeta_function > > zeta(const __gmp_expr< T, U > &expr)
Definition gmpfrxx.h:4095
__gmp_expr< T, __gmp_unary_expr< __gmp_expr< T, U >, __gmp_coth_function > > coth(const __gmp_expr< T, U > &expr)
Definition gmpfrxx.h:4084
__gmp_expr< T, __gmp_unary_expr< __gmp_expr< T, U >, __gmp_log1p_function > > log1p(const __gmp_expr< T, U > &expr)
Definition gmpfrxx.h:4089
__gmp_expr< T, __gmp_unary_expr< __gmp_expr< T, U >, __gmp_gamma_function > > gamma(const __gmp_expr< T, U > &expr)
Definition gmpfrxx.h:4092
#define __GMP_DEFINE_UNARY_FUNCTION_UI(T, fun, eval_fun)
Definition gmpfrxx.h:3735
__gmp_expr< typename __gmp_resolve_expr< T, V >::value_type, __gmp_binary_expr< __gmp_expr< T, U >, __gmp_expr< V, W >, __gmp_min_function > > min(const __gmp_expr< T, U > &expr1, const __gmp_expr< V, W > &expr2)
Definition gmpfrxx.h:4111
void mpq_set_mpfr(mpq_ptr w, mpfr_srcptr u)
Definition gmpfrxx.C:175
__gmp_expr< typename __gmp_resolve_expr< T, V >::value_type, __gmp_binary_expr< __gmp_expr< T, U >, __gmp_expr< V, W >, __gmp_agm_function > > agm(const __gmp_expr< T, U > &expr1, const __gmp_expr< V, W > &expr2)
Definition gmpfrxx.h:4105
#define __GMPZ_DEFINE_INCREMENT_OPERATOR(fun, eval_fun)
Definition gmpfrxx.h:4010
#define __MPFR_DEFINE_COMPOUND_OPERATOR(fun, eval_fun)
Definition gmpfrxx.h:3970
__gmp_expr< T, __gmp_unary_expr< __gmp_expr< T, U >, __gmp_cbrt_function > > cbrt(const __gmp_expr< T, U > &expr)
Definition gmpfrxx.h:4059
#define __GMP_DEFINE_UNARY_TYPE_FUNCTION(type, fun, eval_fun)
Definition gmpfrxx.h:3725
#define __GMPZZ_DEFINE_COMPOUND_OPERATOR(fun, eval_fun)
Definition gmpfrxx.h:3964
#define __GMPQ_DEFINE_COMPOUND_OPERATOR_UI(fun, eval_fun)
Definition gmpfrxx.h:3987
__gmp_expr< T, __gmp_unary_expr< __gmp_expr< T, U >, __gmp_j0_function > > j0(const __gmp_expr< T, U > &expr)
Definition gmpfrxx.h:4099
#define __GMP_DEFINE_BINARY_TYPE_FUNCTION(type, fun, eval_fun)
Definition gmpfrxx.h:3903
__gmp_expr< T, __gmp_unary_expr< __gmp_expr< T, U >, __gmp_ceil_function > > ceil(const __gmp_expr< T, U > &expr)
Definition gmpfrxx.h:4056
#define __GMPQ_DEFINE_COMPOUND_OPERATOR(fun, eval_fun)
Definition gmpfrxx.h:3967
__gmp_expr< T, __gmp_unary_expr< __gmp_expr< T, U >, __gmp_y0_function > > y0(const __gmp_expr< T, U > &expr)
Definition gmpfrxx.h:4102
std::istream & operator>>(std::istream &, mpfr_ptr)
Definition gmpfrxx.C:51
__gmp_expr< typename __gmp_resolve_expr< T, V >::value_type, __gmp_binary_expr< __gmp_expr< T, U >, __gmp_expr< V, W >, __gmp_pow_function > > pow(const __gmp_expr< T, U > &expr1, const __gmp_expr< V, W > &expr2)
Definition gmpfrxx.h:4061
__gmp_expr< T, __gmp_binary_expr< __gmp_expr< T, U >, unsigned long int, __gmp_root_function > > root(const __gmp_expr< T, U > &expr, unsigned long int l)
Definition gmpfrxx.h:4060
__gmp_expr< T, __gmp_unary_expr< __gmp_expr< T, U >, __gmp_trunc_function > > trunc(const __gmp_expr< T, U > &expr)
Definition gmpfrxx.h:4054
#define __GMPZ_DEFINE_COMPOUND_OPERATOR(fun, eval_fun)
Definition gmpfrxx.h:3961
__gmp_expr< mpfr_t, __gmp_binary_expr< unsigned long int, unsigned long int, __gmp_pow_function > > pow_ui(unsigned long int r, unsigned long int l)
Definition gmpfrxx.h:4062
__gmp_expr< T, __gmp_unary_expr< __gmp_expr< T, U >, __gmp_asinh_function > > asinh(const __gmp_expr< T, U > &expr)
Definition gmpfrxx.h:4086
__gmp_expr< T, __gmp_unary_expr< __gmp_expr< T, U >, __gmp_j1_function > > j1(const __gmp_expr< T, U > &expr)
Definition gmpfrxx.h:4100
std::ostream & operator<<(std::ostream &, mpfr_srcptr)
Definition gmpfrxx.C:62
__gmp_expr< T, __gmp_unary_expr< __gmp_expr< T, U >, __gmp_rint_function > > rint(const __gmp_expr< T, U > &expr)
Definition gmpfrxx.h:4053
__gmp_expr< T, __gmp_unary_expr< __gmp_expr< T, U >, __gmp_sinh_function > > sinh(const __gmp_expr< T, U > &expr)
Definition gmpfrxx.h:4080
#define __GMP_DEFINE_VOID_FUNCTION(T, fun, eval_fun)
Definition gmpfrxx.h:3701
int __gmp_randinit_lc_2exp_size_t(gmp_randstate_t, unsigned long int)
Definition gmpfrxx.h:4221
__gmp_expr< T, __gmp_unary_expr< __gmp_expr< T, U >, __gmp_expm1_function > > expm1(const __gmp_expr< T, U > &expr)
Definition gmpfrxx.h:4090
#define __MPFR_DEFINE_INCREMENT_OPERATOR(fun, eval_fun)
Definition gmpfrxx.h:4016
__gmp_expr< T, __gmp_unary_expr< __gmp_expr< T, U >, __gmp_lngamma_function > > lngamma(const __gmp_expr< T, U > &expr)
Definition gmpfrxx.h:4093
__gmp_expr< T, __gmp_unary_expr< __gmp_expr< T, U >, __gmp_eint_function > > eint(const __gmp_expr< T, U > &expr)
Definition gmpfrxx.h:4091
int cmp(const __gmp_expr< T, U > &expr1, const __gmp_expr< V, W > &expr2)
Definition gmpfrxx.h:4118
#define __GMP_DEFINE_UNARY_FUNCTION(fun, eval_fun)
Definition gmpfrxx.h:3714
#define __GMP_DECLARE_INCREMENT_OPERATOR(fun)
Definition gmpfrxx.h:1865
int sgn(const __gmp_expr< T, U > &expr)
Definition gmpfrxx.h:4117
void __gmp_randinit_default_t(gmp_randstate_t)
Definition gmpfrxx.h:4219
#define __GMP_DEFINE_BINARY_FUNCTION_UI(fun, eval_fun)
Definition gmpfrxx.h:3824
__gmp_expr< T, __gmp_unary_expr< __gmp_expr< T, U >, __gmp_lgamma_function > > lgamma(const __gmp_expr< T, U > &expr)
Definition gmpfrxx.h:4094
__gmp_expr< T, __gmp_unary_expr< __gmp_expr< T, U >, __gmp_exp10_function > > exp10(const __gmp_expr< T, U > &expr)
Definition gmpfrxx.h:4068
int mpfr_d_sub(mpfr_ptr z, double a, mpfr_srcptr x, mpfr_rnd_t r)
Definition mpfr_mul_d.c:56
int mpfr_mul_d(mpfr_ptr z, mpfr_srcptr x, double a, mpfr_rnd_t r)
Definition mpfr_mul_d.c:6
int mpfr_div_d(mpfr_ptr z, mpfr_srcptr x, double a, mpfr_rnd_t r)
Definition mpfr_mul_d.c:16
int mpfr_add_d(mpfr_ptr z, mpfr_srcptr x, double a, mpfr_rnd_t r)
Definition mpfr_mul_d.c:36
int mpfr_d_div(mpfr_ptr z, double a, mpfr_srcptr x, mpfr_rnd_t r)
Definition mpfr_mul_d.c:26
int mpfr_sub_d(mpfr_ptr z, mpfr_srcptr x, double a, mpfr_rnd_t r)
Definition mpfr_mul_d.c:46
STL namespace.
static void eval(mpz_ptr z, mpz_srcptr w)
Definition gmpfrxx.h:1080
static void eval(mpfr_ptr f, mpfr_srcptr g)
Definition gmpfrxx.h:1082
static void eval(mpq_ptr q, mpq_srcptr r)
Definition gmpfrxx.h:1081
static void eval(mpfr_ptr f, mpfr_srcptr g)
Definition gmpfrxx.h:1234
static void eval(mpfr_ptr f, mpfr_srcptr g)
Definition gmpfrxx.h:1294
static void eval(mpfr_ptr f, mpfr_srcptr g, mpfr_srcptr h)
Definition gmpfrxx.h:1415
__gmp_alloc_cstring(char *s)
Definition gmpfrxx.h:1693
static void eval(mpfr_ptr f, mpfr_srcptr g)
Definition gmpfrxx.h:1240
static void eval(mpfr_ptr f, mpfr_srcptr g)
Definition gmpfrxx.h:1300
static void eval(mpfr_ptr f, mpfr_srcptr g, mpfr_srcptr h)
Definition gmpfrxx.h:1252
static void eval(mpfr_ptr f, mpfr_srcptr g)
Definition gmpfrxx.h:1246
static void eval(mpfr_ptr f, mpfr_srcptr g)
Definition gmpfrxx.h:1306
static void eval(mpz_ptr z, mpz_srcptr w, mpz_srcptr v)
Definition gmpfrxx.h:631
static void eval(mpz_ptr z, mpz_srcptr w, double d)
Definition gmpfrxx.h:489
static void eval(mpfr_ptr f, double d, mpfr_srcptr g)
Definition gmpfrxx.h:569
static void eval(mpq_ptr q, mpq_srcptr r, unsigned long int l)
Definition gmpfrxx.h:507
static void eval(mpfr_ptr f, mpfr_srcptr g, double d)
Definition gmpfrxx.h:567
static void eval(mpz_ptr z, signed long int l, mpz_srcptr w)
Definition gmpfrxx.h:478
static void eval(mpq_ptr q, signed long int l, mpq_srcptr r)
Definition gmpfrxx.h:531
static void eval(mpfr_ptr f, mpfr_srcptr g, signed long int l)
Definition gmpfrxx.h:563
static void eval(mpz_ptr z, mpz_srcptr w, mpz_srcptr v)
Definition gmpfrxx.h:442
static void eval(mpz_ptr z, unsigned long int l, mpz_srcptr w)
Definition gmpfrxx.h:447
static void eval(mpq_ptr q, mpq_srcptr r, double d)
Definition gmpfrxx.h:539
static void eval(mpz_ptr z, double d, mpz_srcptr w)
Definition gmpfrxx.h:496
static void eval(mpfr_ptr f, unsigned long int l, mpfr_srcptr g)
Definition gmpfrxx.h:561
static void eval(mpfr_ptr f, mpfr_srcptr g, unsigned long int l)
Definition gmpfrxx.h:559
static void eval(mpfr_ptr f, mpfr_srcptr g, mpfr_srcptr h)
Definition gmpfrxx.h:556
static void eval(mpq_ptr q, unsigned long int l, mpq_srcptr r)
Definition gmpfrxx.h:515
static void eval(mpq_ptr q, mpq_srcptr r, signed long int l)
Definition gmpfrxx.h:523
static void eval(mpq_ptr q, double d, mpq_srcptr r)
Definition gmpfrxx.h:547
static void eval(mpz_ptr z, mpz_srcptr w, signed long int l)
Definition gmpfrxx.h:468
static void eval(mpz_ptr z, mpz_srcptr w, unsigned long int l)
Definition gmpfrxx.h:445
static void eval(mpq_ptr q, mpq_srcptr r, mpq_srcptr s)
Definition gmpfrxx.h:504
static void eval(mpfr_ptr f, signed long int l, mpfr_srcptr g)
Definition gmpfrxx.h:565
static bool eval(mpq_srcptr q, unsigned long int l)
Definition gmpfrxx.h:687
static bool eval(mpz_srcptr z, signed long int l)
Definition gmpfrxx.h:675
static bool eval(double d, mpfr_srcptr f)
Definition gmpfrxx.h:729
static bool eval(mpz_srcptr z, double d)
Definition gmpfrxx.h:679
static bool eval(signed long int l, mpq_srcptr q)
Definition gmpfrxx.h:693
static bool eval(double d, mpq_srcptr q)
Definition gmpfrxx.h:705
static bool eval(unsigned long int l, mpq_srcptr q)
Definition gmpfrxx.h:689
static bool eval(mpq_srcptr q, mpq_srcptr r)
Definition gmpfrxx.h:684
static bool eval(signed long int l, mpz_srcptr z)
Definition gmpfrxx.h:677
static bool eval(double d, mpz_srcptr z)
Definition gmpfrxx.h:681
static bool eval(mpfr_srcptr f, double d)
Definition gmpfrxx.h:727
static bool eval(mpq_srcptr q, double d)
Definition gmpfrxx.h:695
static bool eval(unsigned long int l, mpfr_srcptr f)
Definition gmpfrxx.h:721
static bool eval(mpfr_srcptr f, signed long int l)
Definition gmpfrxx.h:723
static bool eval(mpz_srcptr z, unsigned long int l)
Definition gmpfrxx.h:671
static bool eval(mpfr_srcptr f, unsigned long int l)
Definition gmpfrxx.h:719
static bool eval(mpz_srcptr z, mpz_srcptr w)
Definition gmpfrxx.h:669
static bool eval(signed long int l, mpfr_srcptr f)
Definition gmpfrxx.h:725
static bool eval(mpfr_srcptr f, mpfr_srcptr g)
Definition gmpfrxx.h:716
static bool eval(mpq_srcptr q, signed long int l)
Definition gmpfrxx.h:691
static bool eval(unsigned long int l, mpz_srcptr z)
Definition gmpfrxx.h:673
__gmp_resolve_ref< U >::ref_type val2
Definition gmpfrxx.h:1813
__gmp_resolve_ref< T >::ref_type val1
Definition gmpfrxx.h:1812
__gmp_binary_expr(const T &v1, const U &v2)
Definition gmpfrxx.h:1815
static bool eval(signed long int l, mpq_srcptr q)
Definition gmpfrxx.h:1023
static bool eval(mpfr_srcptr f, double d)
Definition gmpfrxx.h:1056
static bool eval(signed long int l, mpz_srcptr z)
Definition gmpfrxx.h:1008
static bool eval(mpz_srcptr z, signed long int l)
Definition gmpfrxx.h:1006
static bool eval(mpq_srcptr q, double d)
Definition gmpfrxx.h:1025
static bool eval(signed long int l, mpfr_srcptr f)
Definition gmpfrxx.h:1054
static bool eval(double d, mpfr_srcptr f)
Definition gmpfrxx.h:1058
static bool eval(unsigned long int l, mpfr_srcptr f)
Definition gmpfrxx.h:1050
static bool eval(mpq_srcptr q, mpq_srcptr r)
Definition gmpfrxx.h:1015
static bool eval(mpfr_srcptr f, unsigned long int l)
Definition gmpfrxx.h:1048
static bool eval(double d, mpq_srcptr q)
Definition gmpfrxx.h:1035
static bool eval(mpz_srcptr z, unsigned long int l)
Definition gmpfrxx.h:1002
static bool eval(mpfr_srcptr f, mpfr_srcptr g)
Definition gmpfrxx.h:1046
static bool eval(mpfr_srcptr f, signed long int l)
Definition gmpfrxx.h:1052
static bool eval(mpq_srcptr q, signed long int l)
Definition gmpfrxx.h:1021
static bool eval(mpz_srcptr z, double d)
Definition gmpfrxx.h:1010
static bool eval(unsigned long int l, mpq_srcptr q)
Definition gmpfrxx.h:1019
static bool eval(mpq_srcptr q, unsigned long int l)
Definition gmpfrxx.h:1017
static bool eval(double d, mpz_srcptr z)
Definition gmpfrxx.h:1012
static bool eval(mpz_srcptr z, mpz_srcptr w)
Definition gmpfrxx.h:1000
static bool eval(unsigned long int l, mpz_srcptr z)
Definition gmpfrxx.h:1004
static bool eval(mpfr_srcptr f, double d)
Definition gmpfrxx.h:985
static bool eval(signed long int l, mpq_srcptr q)
Definition gmpfrxx.h:952
static bool eval(signed long int l, mpz_srcptr z)
Definition gmpfrxx.h:937
static bool eval(mpq_srcptr q, signed long int l)
Definition gmpfrxx.h:950
static bool eval(mpfr_srcptr f, mpfr_srcptr g)
Definition gmpfrxx.h:975
static bool eval(mpq_srcptr q, double d)
Definition gmpfrxx.h:954
static bool eval(mpz_srcptr z, double d)
Definition gmpfrxx.h:939
static bool eval(mpz_srcptr z, mpz_srcptr w)
Definition gmpfrxx.h:929
static bool eval(mpz_srcptr z, unsigned long int l)
Definition gmpfrxx.h:931
static bool eval(unsigned long int l, mpz_srcptr z)
Definition gmpfrxx.h:933
static bool eval(signed long int l, mpfr_srcptr f)
Definition gmpfrxx.h:983
static bool eval(mpq_srcptr q, mpq_srcptr r)
Definition gmpfrxx.h:944
static bool eval(mpfr_srcptr f, unsigned long int l)
Definition gmpfrxx.h:977
static bool eval(double d, mpq_srcptr q)
Definition gmpfrxx.h:964
static bool eval(unsigned long int l, mpq_srcptr q)
Definition gmpfrxx.h:948
static bool eval(mpfr_srcptr f, signed long int l)
Definition gmpfrxx.h:981
static bool eval(mpz_srcptr z, signed long int l)
Definition gmpfrxx.h:935
static bool eval(double d, mpz_srcptr z)
Definition gmpfrxx.h:941
static bool eval(unsigned long int l, mpfr_srcptr f)
Definition gmpfrxx.h:979
static bool eval(mpq_srcptr q, unsigned long int l)
Definition gmpfrxx.h:946
static bool eval(double d, mpfr_srcptr f)
Definition gmpfrxx.h:987
static void eval(mpz_ptr z, mpz_srcptr w, mpz_srcptr v)
Definition gmpfrxx.h:637
static bool eval(unsigned long int l, mpfr_srcptr f)
Definition gmpfrxx.h:915
static bool eval(mpfr_srcptr f, unsigned long int l)
Definition gmpfrxx.h:913
static bool eval(mpz_srcptr z, double d)
Definition gmpfrxx.h:875
static bool eval(double d, mpq_srcptr q)
Definition gmpfrxx.h:900
static bool eval(mpz_srcptr z, signed long int l)
Definition gmpfrxx.h:871
static bool eval(signed long int l, mpq_srcptr q)
Definition gmpfrxx.h:888
static bool eval(signed long int l, mpz_srcptr z)
Definition gmpfrxx.h:873
static bool eval(mpq_srcptr q, mpq_srcptr r)
Definition gmpfrxx.h:880
static bool eval(mpfr_srcptr f, double d)
Definition gmpfrxx.h:921
static bool eval(mpq_srcptr q, double d)
Definition gmpfrxx.h:890
static bool eval(double d, mpz_srcptr z)
Definition gmpfrxx.h:877
static bool eval(mpq_srcptr q, unsigned long int l)
Definition gmpfrxx.h:882
static bool eval(double d, mpfr_srcptr f)
Definition gmpfrxx.h:923
static bool eval(unsigned long int l, mpq_srcptr q)
Definition gmpfrxx.h:884
static bool eval(mpq_srcptr q, signed long int l)
Definition gmpfrxx.h:886
static bool eval(mpz_srcptr z, unsigned long int l)
Definition gmpfrxx.h:867
static bool eval(unsigned long int l, mpz_srcptr z)
Definition gmpfrxx.h:869
static bool eval(mpz_srcptr z, mpz_srcptr w)
Definition gmpfrxx.h:865
static bool eval(mpfr_srcptr f, signed long int l)
Definition gmpfrxx.h:917
static bool eval(signed long int l, mpfr_srcptr f)
Definition gmpfrxx.h:919
static bool eval(mpfr_srcptr f, mpfr_srcptr g)
Definition gmpfrxx.h:911
static bool eval(mpfr_srcptr f, unsigned long int l)
Definition gmpfrxx.h:849
static bool eval(signed long int l, mpz_srcptr z)
Definition gmpfrxx.h:809
static bool eval(double d, mpz_srcptr z)
Definition gmpfrxx.h:813
static bool eval(mpq_srcptr q, double d)
Definition gmpfrxx.h:826
static bool eval(mpfr_srcptr f, mpfr_srcptr g)
Definition gmpfrxx.h:847
static bool eval(double d, mpq_srcptr q)
Definition gmpfrxx.h:836
static bool eval(mpfr_srcptr f, double d)
Definition gmpfrxx.h:857
static bool eval(mpq_srcptr q, unsigned long int l)
Definition gmpfrxx.h:818
static bool eval(mpz_srcptr z, mpz_srcptr w)
Definition gmpfrxx.h:801
static bool eval(mpq_srcptr q, signed long int l)
Definition gmpfrxx.h:822
static bool eval(unsigned long int l, mpfr_srcptr f)
Definition gmpfrxx.h:851
static bool eval(unsigned long int l, mpz_srcptr z)
Definition gmpfrxx.h:805
static bool eval(mpfr_srcptr f, signed long int l)
Definition gmpfrxx.h:853
static bool eval(mpq_srcptr q, mpq_srcptr r)
Definition gmpfrxx.h:816
static bool eval(signed long int l, mpq_srcptr q)
Definition gmpfrxx.h:824
static bool eval(mpz_srcptr z, unsigned long int l)
Definition gmpfrxx.h:803
static bool eval(mpz_srcptr z, signed long int l)
Definition gmpfrxx.h:807
static bool eval(double d, mpfr_srcptr f)
Definition gmpfrxx.h:859
static bool eval(unsigned long int l, mpq_srcptr q)
Definition gmpfrxx.h:820
static bool eval(signed long int l, mpfr_srcptr f)
Definition gmpfrxx.h:855
static bool eval(mpz_srcptr z, double d)
Definition gmpfrxx.h:811
static void eval(mpq_ptr q, mpq_srcptr r, unsigned long int l)
Definition gmpfrxx.h:651
static void eval(mpfr_ptr f, mpfr_srcptr g, unsigned long int l)
Definition gmpfrxx.h:653
static void eval(mpz_ptr z, mpz_srcptr w, unsigned long int l)
Definition gmpfrxx.h:649
static void eval(mpfr_ptr f, mpfr_srcptr g, mpfr_srcptr h)
Definition gmpfrxx.h:326
static void eval(mpq_ptr q, signed long int l, mpq_srcptr r)
Definition gmpfrxx.h:296
static void eval(mpfr_ptr f, mpfr_srcptr g, signed long int l)
Definition gmpfrxx.h:333
static void eval(mpq_ptr q, double d, mpq_srcptr r)
Definition gmpfrxx.h:312
static void eval(mpz_ptr z, mpz_srcptr w, mpz_srcptr v)
Definition gmpfrxx.h:242
static void eval(mpfr_ptr f, signed long int l, mpfr_srcptr g)
Definition gmpfrxx.h:335
static void eval(mpz_ptr z, unsigned long int l, mpz_srcptr w)
Definition gmpfrxx.h:247
static void eval(mpfr_ptr f, mpfr_srcptr g, double d)
Definition gmpfrxx.h:337
static void eval(mpq_ptr q, mpq_srcptr r, mpz_srcptr z)
Definition gmpfrxx.h:321
static void eval(mpq_ptr q, mpz_srcptr z, mpq_srcptr r)
Definition gmpfrxx.h:323
static void eval(mpz_ptr z, mpz_srcptr w, double d)
Definition gmpfrxx.h:266
static void eval(mpq_ptr q, mpq_srcptr r, mpq_srcptr s)
Definition gmpfrxx.h:281
static void eval(mpz_ptr z, double d, mpz_srcptr w)
Definition gmpfrxx.h:273
static void eval(mpq_ptr q, unsigned long int l, mpq_srcptr r)
Definition gmpfrxx.h:286
static void eval(mpfr_ptr f, double d, mpfr_srcptr g)
Definition gmpfrxx.h:339
static void eval(mpq_ptr q, mpq_srcptr r, unsigned long int l)
Definition gmpfrxx.h:284
static void eval(mpfr_ptr f, mpfr_srcptr g, unsigned long int l)
Definition gmpfrxx.h:329
static void eval(mpq_ptr q, mpq_srcptr r, signed long int l)
Definition gmpfrxx.h:288
static void eval(mpz_ptr z, mpz_srcptr w, unsigned long int l)
Definition gmpfrxx.h:245
static void eval(mpfr_ptr f, unsigned long int l, mpfr_srcptr g)
Definition gmpfrxx.h:331
static void eval(mpq_ptr q, mpq_srcptr r, double d)
Definition gmpfrxx.h:304
static void eval(mpz_ptr z, signed long int l, mpz_srcptr w)
Definition gmpfrxx.h:256
static void eval(mpz_ptr z, mpz_srcptr w, signed long int l)
Definition gmpfrxx.h:249
static void eval(mpz_ptr z, mpz_srcptr w, mpz_srcptr v)
Definition gmpfrxx.h:575
static void eval(mpz_ptr z, unsigned long int l, mpz_srcptr w)
Definition gmpfrxx.h:580
static void eval(mpz_ptr z, signed long int l, mpz_srcptr w)
Definition gmpfrxx.h:602
static void eval(mpz_ptr z, mpz_srcptr w, unsigned long int l)
Definition gmpfrxx.h:578
static void eval(mpz_ptr z, mpz_srcptr w, signed long int l)
Definition gmpfrxx.h:598
static void eval(mpz_ptr z, mpz_srcptr w, double d)
Definition gmpfrxx.h:613
static void eval(mpz_ptr z, double d, mpz_srcptr w)
Definition gmpfrxx.h:620
static void eval(mpq_ptr q, mpq_srcptr r, mpq_srcptr s)
Definition gmpfrxx.h:371
static void eval(mpz_ptr z, double d, mpz_srcptr w)
Definition gmpfrxx.h:363
static void eval(mpz_ptr z, mpz_srcptr w, double d)
Definition gmpfrxx.h:356
static void eval(mpq_ptr q, signed long int l, mpq_srcptr r)
Definition gmpfrxx.h:398
static void eval(mpq_ptr q, double d, mpq_srcptr r)
Definition gmpfrxx.h:414
static void eval(mpfr_ptr f, double d, mpfr_srcptr g)
Definition gmpfrxx.h:436
static void eval(mpfr_ptr f, mpfr_srcptr g, unsigned long int l)
Definition gmpfrxx.h:426
static void eval(mpq_ptr q, unsigned long int l, mpq_srcptr r)
Definition gmpfrxx.h:382
static void eval(mpz_ptr z, mpz_srcptr w, mpz_srcptr v)
Definition gmpfrxx.h:345
static void eval(mpfr_ptr f, mpfr_srcptr g, mpfr_srcptr h)
Definition gmpfrxx.h:423
static void eval(mpfr_ptr f, unsigned long int l, mpfr_srcptr g)
Definition gmpfrxx.h:428
static void eval(mpq_ptr q, mpq_srcptr r, signed long int l)
Definition gmpfrxx.h:390
static void eval(mpfr_ptr f, mpfr_srcptr g, double d)
Definition gmpfrxx.h:434
static void eval(mpq_ptr q, mpq_srcptr r, double d)
Definition gmpfrxx.h:406
static void eval(mpz_ptr z, mpz_srcptr w, signed long int l)
Definition gmpfrxx.h:352
static void eval(mpq_ptr q, mpq_srcptr r, unsigned long int l)
Definition gmpfrxx.h:374
static void eval(mpz_ptr z, mpz_srcptr w, unsigned long int l)
Definition gmpfrxx.h:348
static void eval(mpz_ptr z, unsigned long int l, mpz_srcptr w)
Definition gmpfrxx.h:350
static void eval(mpz_ptr z, signed long int l, mpz_srcptr w)
Definition gmpfrxx.h:354
static void eval(mpfr_ptr f, signed long int l, mpfr_srcptr g)
Definition gmpfrxx.h:432
static void eval(mpfr_ptr f, mpfr_srcptr g, signed long int l)
Definition gmpfrxx.h:430
static bool eval(mpz_srcptr z, mpz_srcptr w)
Definition gmpfrxx.h:735
static bool eval(unsigned long int l, mpfr_srcptr f)
Definition gmpfrxx.h:787
static bool eval(mpq_srcptr q, unsigned long int l)
Definition gmpfrxx.h:754
static bool eval(signed long int l, mpq_srcptr q)
Definition gmpfrxx.h:760
static bool eval(double d, mpq_srcptr q)
Definition gmpfrxx.h:772
static bool eval(double d, mpz_srcptr z)
Definition gmpfrxx.h:748
static bool eval(mpfr_srcptr f, unsigned long int l)
Definition gmpfrxx.h:785
static bool eval(mpfr_srcptr f, signed long int l)
Definition gmpfrxx.h:789
static bool eval(mpfr_srcptr f, mpfr_srcptr g)
Definition gmpfrxx.h:783
static bool eval(mpq_srcptr q, mpq_srcptr r)
Definition gmpfrxx.h:751
static bool eval(signed long int l, mpz_srcptr z)
Definition gmpfrxx.h:744
static bool eval(signed long int l, mpfr_srcptr f)
Definition gmpfrxx.h:791
static bool eval(double d, mpfr_srcptr f)
Definition gmpfrxx.h:795
static bool eval(unsigned long int l, mpq_srcptr q)
Definition gmpfrxx.h:756
static bool eval(mpz_srcptr z, signed long int l)
Definition gmpfrxx.h:742
static bool eval(mpq_srcptr q, double d)
Definition gmpfrxx.h:762
static bool eval(mpfr_srcptr f, double d)
Definition gmpfrxx.h:793
static bool eval(mpq_srcptr q, signed long int l)
Definition gmpfrxx.h:758
static bool eval(unsigned long int l, mpz_srcptr z)
Definition gmpfrxx.h:740
static bool eval(mpz_srcptr z, unsigned long int l)
Definition gmpfrxx.h:738
static bool eval(mpz_srcptr z, double d)
Definition gmpfrxx.h:746
static void eval(mpq_ptr q, mpq_srcptr r, double d)
Definition gmpfrxx.h:202
static void eval(mpz_ptr z, mpz_srcptr w, double d)
Definition gmpfrxx.h:164
static void eval(mpq_ptr q, signed long int l, mpq_srcptr r)
Definition gmpfrxx.h:194
static void eval(mpfr_ptr f, signed long int l, mpfr_srcptr g)
Definition gmpfrxx.h:232
static void eval(mpz_ptr z, signed long int l, mpz_srcptr w)
Definition gmpfrxx.h:157
static void eval(mpz_ptr z, mpz_srcptr w, mpz_srcptr v)
Definition gmpfrxx.h:143
static void eval(mpfr_ptr f, unsigned long int l, mpfr_srcptr g)
Definition gmpfrxx.h:228
static void eval(mpq_ptr q, mpq_srcptr r, mpz_srcptr z)
Definition gmpfrxx.h:219
static void eval(mpz_ptr z, mpz_srcptr w, unsigned long int l)
Definition gmpfrxx.h:146
static void eval(mpz_ptr z, unsigned long int l, mpz_srcptr w)
Definition gmpfrxx.h:148
static void eval(mpq_ptr q, mpq_srcptr r, signed long int l)
Definition gmpfrxx.h:186
static void eval(mpfr_ptr f, mpfr_srcptr g, unsigned long int l)
Definition gmpfrxx.h:226
static void eval(mpq_ptr q, mpq_srcptr r, unsigned long int l)
Definition gmpfrxx.h:182
static void eval(mpq_ptr q, unsigned long int l, mpq_srcptr r)
Definition gmpfrxx.h:184
static void eval(mpz_ptr z, double d, mpz_srcptr w)
Definition gmpfrxx.h:171
static void eval(mpfr_ptr f, mpfr_srcptr g, mpfr_srcptr h)
Definition gmpfrxx.h:224
static void eval(mpfr_ptr f, mpfr_srcptr g, signed long int l)
Definition gmpfrxx.h:230
static void eval(mpq_ptr q, double d, mpq_srcptr r)
Definition gmpfrxx.h:210
static void eval(mpfr_ptr f, mpfr_srcptr g, double d)
Definition gmpfrxx.h:234
static void eval(mpfr_ptr f, double d, mpfr_srcptr g)
Definition gmpfrxx.h:236
static void eval(mpq_ptr q, mpq_srcptr r, mpq_srcptr s)
Definition gmpfrxx.h:179
static void eval(mpq_ptr q, mpz_srcptr z, mpq_srcptr r)
Definition gmpfrxx.h:221
static void eval(mpz_ptr z, mpz_srcptr w, signed long int l)
Definition gmpfrxx.h:150
static void eval(mpq_ptr q, mpq_srcptr r, unsigned long int l)
Definition gmpfrxx.h:661
static void eval(mpfr_ptr f, mpfr_srcptr g, unsigned long int l)
Definition gmpfrxx.h:663
static void eval(mpz_ptr z, mpz_srcptr w, unsigned long int l)
Definition gmpfrxx.h:659
static void eval(mpz_ptr z, mpz_srcptr w, mpz_srcptr v)
Definition gmpfrxx.h:643
static void eval(mpfr_ptr f, mpfr_srcptr g)
Definition gmpfrxx.h:1128
static void eval(mpfr_ptr f, mpfr_srcptr g)
Definition gmpfrxx.h:1110
static int eval(mpfr_srcptr f, double d)
Definition gmpfrxx.h:1571
static int eval(mpq_srcptr q, signed long int l)
Definition gmpfrxx.h:1536
static int eval(mpfr_srcptr f, unsigned long int l)
Definition gmpfrxx.h:1563
static int eval(unsigned long int l, mpfr_srcptr f)
Definition gmpfrxx.h:1565
static int eval(mpfr_srcptr f, signed long int l)
Definition gmpfrxx.h:1567
static int eval(mpz_srcptr z, unsigned long int l)
Definition gmpfrxx.h:1517
static int eval(signed long int l, mpfr_srcptr f)
Definition gmpfrxx.h:1569
static int eval(mpz_srcptr z, signed long int l)
Definition gmpfrxx.h:1521
static int eval(signed long int l, mpq_srcptr q)
Definition gmpfrxx.h:1538
static int eval(mpfr_srcptr f, mpfr_srcptr g)
Definition gmpfrxx.h:1561
static int eval(mpq_srcptr q, unsigned long int l)
Definition gmpfrxx.h:1532
static int eval(mpz_srcptr z, double d)
Definition gmpfrxx.h:1525
static int eval(mpq_srcptr q, mpq_srcptr r)
Definition gmpfrxx.h:1530
static int eval(mpz_srcptr z, mpz_srcptr w)
Definition gmpfrxx.h:1515
static int eval(unsigned long int l, mpq_srcptr q)
Definition gmpfrxx.h:1534
static int eval(mpq_srcptr q, double d)
Definition gmpfrxx.h:1540
static int eval(double d, mpq_srcptr q)
Definition gmpfrxx.h:1550
static int eval(double d, mpz_srcptr z)
Definition gmpfrxx.h:1527
static int eval(unsigned long int l, mpz_srcptr z)
Definition gmpfrxx.h:1519
static int eval(double d, mpfr_srcptr f)
Definition gmpfrxx.h:1573
static int eval(signed long int l, mpz_srcptr z)
Definition gmpfrxx.h:1523
static int eval(mpfr_srcptr f, mpfr_srcptr g)
Definition gmpfrxx.h:994
static void eval(mpfr_ptr f)
Definition gmpfrxx.h:1439
static void eval(mpfr_ptr f)
Definition gmpfrxx.h:1433
static void eval(mpfr_ptr f)
Definition gmpfrxx.h:1421
static void eval(mpfr_ptr f)
Definition gmpfrxx.h:1427
static void eval(mpfr_ptr f, mpfr_srcptr g)
Definition gmpfrxx.h:1198
static void eval(mpfr_ptr f, mpfr_srcptr g)
Definition gmpfrxx.h:1258
static void eval(mpfr_ptr f, mpfr_srcptr g)
Definition gmpfrxx.h:1228
static void eval(mpfr_ptr f, mpfr_srcptr g)
Definition gmpfrxx.h:1288
static void eval(mpfr_ptr f, mpfr_srcptr g)
Definition gmpfrxx.h:1222
static void eval(mpfr_ptr f, mpfr_srcptr g)
Definition gmpfrxx.h:1282
static void eval(mpfr_ptr f, mpfr_srcptr g, mpfr_srcptr h)
Definition gmpfrxx.h:1088
static void eval(mpfr_ptr f, mpfr_srcptr g)
Definition gmpfrxx.h:1330
static void eval(mpfr_ptr f, mpfr_srcptr g)
Definition gmpfrxx.h:1363
static void eval(mpfr_ptr f, mpfr_srcptr g)
Definition gmpfrxx.h:1369
static void eval(mpfr_ptr f, mpfr_srcptr g)
Definition gmpfrxx.h:1192
static void eval(mpfr_ptr f, mpfr_srcptr g)
Definition gmpfrxx.h:1186
static void eval(mpfr_ptr f, mpfr_srcptr g)
Definition gmpfrxx.h:1180
static void eval(mpfr_ptr f, mpfr_srcptr g)
Definition gmpfrxx.h:1324
static void eval(mpfr_ptr f, unsigned long int l)
Definition gmpfrxx.h:1312
static void eval(mpfr_ptr f, mpfr_srcptr g)
Definition gmpfrxx.h:1105
static void eval(mpfr_ptr f, mpfr_srcptr g)
Definition gmpfrxx.h:1496
static void eval(mpfr_ptr f, mpfr_srcptr g)
Definition gmpfrxx.h:1336
static void eval(mpfr_ptr f, mpfr_srcptr g, double d)
Definition gmpfrxx.h:1482
static void eval(mpfr_ptr f, double d, mpfr_srcptr g)
Definition gmpfrxx.h:1487
static void eval(mpfr_ptr f, unsigned long int l, mpfr_srcptr g)
Definition gmpfrxx.h:1467
static void eval(mpfr_ptr f, mpfr_srcptr g, mpfr_srcptr h)
Definition gmpfrxx.h:1457
static void eval(mpfr_ptr f, signed long int l, mpfr_srcptr g)
Definition gmpfrxx.h:1477
static void eval(mpfr_ptr f, mpfr_srcptr g, unsigned long int l)
Definition gmpfrxx.h:1462
static void eval(mpfr_ptr f, mpfr_srcptr g, signed long int l)
Definition gmpfrxx.h:1472
static void eval(mpfr_ptr f, mpfr_srcptr g)
Definition gmpfrxx.h:1375
static void eval(mpfr_ptr f, mpfr_srcptr g)
Definition gmpfrxx.h:1381
static void eval(mpfr_ptr f, long h, mpfr_srcptr g)
Definition gmpfrxx.h:1389
static void eval(mpfr_ptr f, mpfr_srcptr g)
Definition gmpfrxx.h:1348
static void eval(mpfr_ptr f, mpfr_srcptr g)
Definition gmpfrxx.h:1342
static void eval(mpfr_ptr f, mpfr_srcptr g)
Definition gmpfrxx.h:1174
static void eval(mpfr_ptr f, mpfr_srcptr g)
Definition gmpfrxx.h:1318
static void eval(mpfr_ptr f, mpfr_srcptr g)
Definition gmpfrxx.h:1168
static void eval(mpfr_ptr f, mpfr_srcptr g)
Definition gmpfrxx.h:1162
static void eval(mpfr_ptr f, mpfr_srcptr g, mpfr_srcptr h)
Definition gmpfrxx.h:1445
static void eval(mpfr_ptr f, mpfr_srcptr g, mpfr_srcptr h)
Definition gmpfrxx.h:1451
static void eval(mpfr_ptr f, mpfr_srcptr g, long int l)
Definition gmpfrxx.h:1150
static void eval(mpfr_ptr f, mpfr_srcptr g, mpz_srcptr z)
Definition gmpfrxx.h:1152
static void eval(mpfr_ptr f, mpfr_srcptr g, mpfr_srcptr h)
Definition gmpfrxx.h:1146
static void eval(mpfr_ptr f, mpfr_srcptr g, unsigned long int l)
Definition gmpfrxx.h:1148
static void eval(mpfr_ptr f, unsigned long int l, unsigned long int h)
Definition gmpfrxx.h:1156
static void eval(mpfr_ptr f, unsigned long int l, mpfr_srcptr h)
Definition gmpfrxx.h:1154
static void eval(mpz_ptr z, gmp_randstate_t s, unsigned long int l)
Definition gmpfrxx.h:1665
static void eval(mpz_ptr z, gmp_randstate_t s, mpz_srcptr w)
Definition gmpfrxx.h:1667
static void eval(mpfr_ptr f, gmp_randstate_t s, unsigned long int prec)
Definition gmpfrxx.h:1669
static void eval(mpfr_ptr f, mpfr_srcptr g, mpfr_srcptr h)
Definition gmpfrxx.h:1502
const __gmp_expr< T, U > & ref_type
Definition gmpfrxx.h:1718
const __gmp_expr< T, T > & temp_type
Definition gmpfrxx.h:1793
__gmp_expr< T, T > temp_type
Definition gmpfrxx.h:1787
static void eval(mpfr_ptr f, mpfr_srcptr g)
Definition gmpfrxx.h:1094
static void eval(mpfr_ptr f, mpfr_srcptr g, unsigned long int l)
Definition gmpfrxx.h:1134
static void eval(mpfr_ptr f, mpfr_srcptr g)
Definition gmpfrxx.h:1216
static void eval(mpfr_ptr f, mpfr_srcptr g)
Definition gmpfrxx.h:1276
static int eval(mpq_srcptr q)
Definition gmpfrxx.h:1509
static int eval(mpz_srcptr z)
Definition gmpfrxx.h:1508
static int eval(mpfr_srcptr f)
Definition gmpfrxx.h:1510
static void eval(mpfr_ptr f, mpfr_srcptr g)
Definition gmpfrxx.h:1204
static void eval(mpfr_ptr f, mpfr_srcptr g)
Definition gmpfrxx.h:1264
static void eval(mpfr_ptr f, mpfr_srcptr g)
Definition gmpfrxx.h:1115
static void eval(mpz_ptr z, mpz_srcptr w)
Definition gmpfrxx.h:1121
static void eval(mpfr_ptr f, mpfr_srcptr g)
Definition gmpfrxx.h:1122
static void eval(mpfr_ptr f, mpfr_srcptr g)
Definition gmpfrxx.h:1210
static void eval(mpfr_ptr f, mpfr_srcptr g)
Definition gmpfrxx.h:1270
static void eval(mpz_ptr z, mpz_srcptr w, mpz_srcptr v, double d)
Definition gmpfrxx.h:1602
static void eval(mpz_ptr z, mpz_srcptr w, signed long int l, mpz_srcptr v)
Definition gmpfrxx.h:1594
static void eval(mpz_ptr z, mpz_srcptr w, mpz_srcptr v, signed long int l)
Definition gmpfrxx.h:1586
static void eval(mpz_ptr z, mpz_srcptr w, mpz_srcptr v, unsigned long int l)
Definition gmpfrxx.h:1582
static void eval(mpz_ptr z, mpz_srcptr w, mpz_srcptr v, mpz_srcptr u)
Definition gmpfrxx.h:1579
static void eval(mpz_ptr z, mpz_srcptr w, double d, mpz_srcptr v)
Definition gmpfrxx.h:1610
static void eval(mpz_ptr z, mpz_srcptr w, unsigned long int l, mpz_srcptr v)
Definition gmpfrxx.h:1584
static void eval(mpz_ptr z, mpz_srcptr w, mpz_srcptr v, double d)
Definition gmpfrxx.h:1645
static void eval(mpz_ptr z, mpz_srcptr w, mpz_srcptr v, mpz_srcptr u)
Definition gmpfrxx.h:1622
static void eval(mpz_ptr z, mpz_srcptr w, double d, mpz_srcptr v)
Definition gmpfrxx.h:1653
static void eval(mpz_ptr z, mpz_srcptr w, unsigned long int l, mpz_srcptr v)
Definition gmpfrxx.h:1627
static void eval(mpz_ptr z, mpz_srcptr w, signed long int l, mpz_srcptr v)
Definition gmpfrxx.h:1637
static void eval(mpz_ptr z, mpz_srcptr w, mpz_srcptr v, unsigned long int l)
Definition gmpfrxx.h:1625
static void eval(mpz_ptr z, mpz_srcptr w, mpz_srcptr v, signed long int l)
Definition gmpfrxx.h:1629
static void eval(mpfr_ptr f, mpfr_srcptr g)
Definition gmpfrxx.h:1100
static void eval(mpz_ptr z, mpz_srcptr w)
Definition gmpfrxx.h:138
static void eval(mpq_ptr q)
Definition gmpfrxx.h:1073
static void eval(mpz_ptr z)
Definition gmpfrxx.h:1072
static void eval(mpfr_ptr f)
Definition gmpfrxx.h:1075
__gmp_unary_expr(const T &v)
Definition gmpfrxx.h:1804
__gmp_resolve_ref< T >::ref_type val
Definition gmpfrxx.h:1802
static void eval(mpz_ptr z)
Definition gmpfrxx.h:1064
static void eval(mpq_ptr q)
Definition gmpfrxx.h:1065
static void eval(mpfr_ptr f)
Definition gmpfrxx.h:1067
static void eval(mpq_ptr q, mpq_srcptr r)
Definition gmpfrxx.h:131
static void eval(mpfr_ptr f, mpfr_srcptr g)
Definition gmpfrxx.h:132
static void eval(mpz_ptr z, mpz_srcptr w)
Definition gmpfrxx.h:130
static void eval(mpz_ptr z, mpz_srcptr w)
Definition gmpfrxx.h:122
static void eval(mpq_ptr q, mpq_srcptr r)
Definition gmpfrxx.h:123
static void eval(mpfr_ptr f, mpfr_srcptr g)
Definition gmpfrxx.h:124
static void eval(mpfr_ptr f, mpfr_srcptr g)
Definition gmpfrxx.h:1395
static void eval(mpfr_ptr f, mpfr_srcptr g)
Definition gmpfrxx.h:1401
static void eval(mpfr_ptr f, long h, mpfr_srcptr g)
Definition gmpfrxx.h:1409
static void eval(mpfr_ptr f, unsigned long int l)
Definition gmpfrxx.h:1357
static void eval(mpfr_ptr f, mpfr_srcptr g)
Definition gmpfrxx.h:1355
DynList< int > l