← Back to branch summary

~ubuntu-branches/ubuntu/intrepid/ecl/intrepid

« back to all changes in this revision

Viewing changes to src/gmp/tests/cxx/t-ops.cc

  • Committer: Bazaar Package Importer
  • Author(s): Peter Van Eynde
  • Date: 2007-04-09 11:51:51 UTC
  • mfrom: (1.1.3 upstream)
  • Revision ID: james.westby@ubuntu.com-20070409115151-ql8cr0kalzx1jmla
Tags: 0.9i-20070324-2
Upload to unstable. 

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/gmp/tests/cxx/t-ops.cc
 
1
/* Test mp*_class operators and functions.
 
2
 
 
3
Copyright 2001, 2002, 2003 Free Software Foundation, Inc.
 
4
 
 
5
This file is part of the GNU MP Library.
 
6
 
 
7
The GNU MP Library is free software; you can redistribute it and/or modify
 
8
it under the terms of the GNU Lesser General Public License as published by
 
9
the Free Software Foundation; either version 2.1 of the License, or (at your
 
10
option) any later version.
 
11
 
 
12
The GNU MP Library is distributed in the hope that it will be useful, but
 
13
WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 
14
or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
 
15
License for more details.
 
16
 
 
17
You should have received a copy of the GNU Lesser General Public License
 
18
along with the GNU MP Library; see the file COPYING.LIB.  If not, write to
 
19
the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
 
20
MA 02110-1301, USA. */
 
21
 
 
22
#include "config.h"
 
23
 
 
24
#include <iostream>
 
25
 
 
26
#include "gmp.h"
 
27
#include "gmpxx.h"
 
28
#include "gmp-impl.h"
 
29
#include "tests.h"
 
30
 
 
31
using namespace std;
 
32
 
 
33
 
 
34
void
 
35
check_mpz (void)
 
36
{
 
37
  // unary operators and functions
 
38
 
 
39
  // operator+
 
40
  {
 
41
    mpz_class a(1);
 
42
    mpz_class b;
 
43
    b = +a; ASSERT_ALWAYS(b == 1);
 
44
  }
 
45
 
 
46
  // operator-
 
47
  {
 
48
    mpz_class a(2);
 
49
    mpz_class b;
 
50
    b = -a; ASSERT_ALWAYS(b == -2);
 
51
  }
 
52
 
 
53
  // operator~
 
54
  {
 
55
    mpz_class a(3);
 
56
    mpz_class b;
 
57
    b = ~a; ASSERT_ALWAYS(b == -4);
 
58
  }
 
59
 
 
60
  // abs
 
61
  {
 
62
    mpz_class a(-123);
 
63
    mpz_class b;
 
64
    b = abs(a); ASSERT_ALWAYS(b == 123);
 
65
  }
 
66
 
 
67
  // sqrt
 
68
  {
 
69
    mpz_class a(25);
 
70
    mpz_class b;
 
71
    b = sqrt(a); ASSERT_ALWAYS(b == 5);
 
72
  }
 
73
  {
 
74
    mpz_class a(125);
 
75
    mpz_class b;
 
76
    b = sqrt(a); ASSERT_ALWAYS(b == 11); // round toward zero
 
77
  }
 
78
 
 
79
  // sgn
 
80
  {
 
81
    mpz_class a(123);
 
82
    int b = sgn(a); ASSERT_ALWAYS(b == 1);
 
83
  }
 
84
  {
 
85
    mpz_class a(0);
 
86
    int b = sgn(a); ASSERT_ALWAYS(b == 0);
 
87
  }
 
88
  {
 
89
    mpz_class a(-123);
 
90
    int b = sgn(a); ASSERT_ALWAYS(b == -1);
 
91
  }
 
92
 
 
93
 
 
94
  // binary operators and functions
 
95
 
 
96
  // operator+
 
97
  {
 
98
    mpz_class a(1), b(2);
 
99
    mpz_class c;
 
100
    c = a + b; ASSERT_ALWAYS(c == 3);
 
101
  }
 
102
  {
 
103
    mpz_class a(3);
 
104
    signed int b = 4;
 
105
    mpz_class c;
 
106
    c = a + b; ASSERT_ALWAYS(c == 7);
 
107
  }
 
108
  {
 
109
    mpz_class a(5);
 
110
    double b = 6.0;
 
111
    mpz_class c;
 
112
    c = b + a; ASSERT_ALWAYS(c == 11);
 
113
  }
 
114
 
 
115
  // operator-
 
116
  {
 
117
    mpz_class a(3), b(6);
 
118
    mpz_class c;
 
119
    c = a - b; ASSERT_ALWAYS(c == -3);
 
120
  }
 
121
 
 
122
  // operator*
 
123
  {
 
124
    mpz_class a(-2), b(4);
 
125
    mpz_class c;
 
126
    c = a * b; ASSERT_ALWAYS(c == -8);
 
127
  }
 
128
  {
 
129
    mpz_class a(2);
 
130
    long b = -4;
 
131
    mpz_class c;
 
132
    c = a * b; ASSERT_ALWAYS(c == -8);
 
133
    c = b * a; ASSERT_ALWAYS(c == -8);
 
134
  }
 
135
  {
 
136
    mpz_class a(-2);
 
137
    unsigned long b = 4;
 
138
    mpz_class c;
 
139
    c = a * b; ASSERT_ALWAYS(c == -8);
 
140
    c = b * a; ASSERT_ALWAYS(c == -8);
 
141
  }
 
142
 
 
143
  // operator/ and operator%
 
144
  {
 
145
    mpz_class a(12), b(4);
 
146
    mpz_class c;
 
147
    c = a / b; ASSERT_ALWAYS(c == 3);
 
148
    c = a % b; ASSERT_ALWAYS(c == 0);
 
149
  }
 
150
  {
 
151
    mpz_class a(7), b(5);
 
152
    mpz_class c;
 
153
    c = a / b; ASSERT_ALWAYS(c == 1);
 
154
    c = a % b; ASSERT_ALWAYS(c == 2);
 
155
  }
 
156
  {
 
157
    mpz_class a(-10);
 
158
    signed int ai = -10;
 
159
    mpz_class b(3);
 
160
    signed int bi = 3;
 
161
    mpz_class c;
 
162
    c = a / b;  ASSERT_ALWAYS(c == -3);
 
163
    c = a % b;  ASSERT_ALWAYS(c == -1);
 
164
    c = a / bi; ASSERT_ALWAYS(c == -3);
 
165
    c = a % bi; ASSERT_ALWAYS(c == -1);
 
166
    c = ai / b; ASSERT_ALWAYS(c == -3);
 
167
    c = ai % b; ASSERT_ALWAYS(c == -1);
 
168
  }
 
169
  {
 
170
    mpz_class a(-10);
 
171
    signed int ai = -10;
 
172
    mpz_class b(-3);
 
173
    signed int bi = -3;
 
174
    mpz_class c;
 
175
    c = a / b;  ASSERT_ALWAYS(c == 3);
 
176
    c = a % b;  ASSERT_ALWAYS(c == -1);
 
177
    c = a / bi; ASSERT_ALWAYS(c == 3);
 
178
    c = a % bi; ASSERT_ALWAYS(c == -1);
 
179
    c = ai / b; ASSERT_ALWAYS(c == 3);
 
180
    c = ai % b; ASSERT_ALWAYS(c == -1);
 
181
  }
 
182
  {
 
183
    mpz_class a (LONG_MIN);
 
184
    signed long ai = LONG_MIN;
 
185
    mpz_class b = - mpz_class (LONG_MIN);
 
186
    mpz_class c;
 
187
    c = a / b;  ASSERT_ALWAYS(c == -1);
 
188
    c = a % b;  ASSERT_ALWAYS(c == 0);
 
189
    c = ai / b; ASSERT_ALWAYS(c == -1);
 
190
    c = ai % b; ASSERT_ALWAYS(c == 0);
 
191
  }
 
192
 
 
193
  // operator&
 
194
  // operator|
 
195
  // operator^
 
196
 
 
197
  // operator<<
 
198
  {
 
199
    mpz_class a(3);
 
200
    unsigned int b = 4;
 
201
    mpz_class c;
 
202
    c = a << b; ASSERT_ALWAYS(c == 48);
 
203
  }
 
204
 
 
205
  // operator>>
 
206
  {
 
207
    mpz_class a(127);
 
208
    unsigned int b = 4;
 
209
    mpz_class c;
 
210
    c = a >> b; ASSERT_ALWAYS(c == 7);
 
211
  }
 
212
 
 
213
  // operator==
 
214
  // operator!=
 
215
  // operator<
 
216
  // operator<=
 
217
  // operator>
 
218
  // operator>=
 
219
 
 
220
  // cmp
 
221
  {
 
222
    mpz_class a(123), b(45);
 
223
    int c;
 
224
    c = cmp(a, b); ASSERT_ALWAYS(c > 0);
 
225
    c = cmp(b, a); ASSERT_ALWAYS(c < 0);
 
226
  }
 
227
  {
 
228
    mpz_class a(123);
 
229
    unsigned long b = 45;
 
230
    int c;
 
231
    c = cmp(a, b); ASSERT_ALWAYS(c > 0);
 
232
    c = cmp(b, a); ASSERT_ALWAYS(c < 0);
 
233
  }
 
234
  {
 
235
    mpz_class a(123);
 
236
    long b = 45;
 
237
    int c;
 
238
    c = cmp(a, b); ASSERT_ALWAYS(c > 0);
 
239
    c = cmp(b, a); ASSERT_ALWAYS(c < 0);
 
240
  }
 
241
  {
 
242
    mpz_class a(123);
 
243
    double b = 45;
 
244
    int c;
 
245
    c = cmp(a, b); ASSERT_ALWAYS(c > 0);
 
246
    c = cmp(b, a); ASSERT_ALWAYS(c < 0);
 
247
  }
 
248
 
 
249
 
 
250
  // ternary operators
 
251
 
 
252
  // mpz_addmul
 
253
  {
 
254
    mpz_class a(1), b(2), c(3);
 
255
    mpz_class d;
 
256
    d = a + b * c; ASSERT_ALWAYS(d == 7);
 
257
  }
 
258
  {
 
259
    mpz_class a(1), b(2);
 
260
    unsigned int c = 3;
 
261
    mpz_class d;
 
262
    d = a + b * c; ASSERT_ALWAYS(d == 7);
 
263
  }
 
264
  {
 
265
    mpz_class a(1), b(3);
 
266
    unsigned int c = 2;
 
267
    mpz_class d;
 
268
    d = a + c * b; ASSERT_ALWAYS(d == 7);
 
269
  }
 
270
  {
 
271
    mpz_class a(1), b(2);
 
272
    signed int c = 3;
 
273
    mpz_class d;
 
274
    d = a + b * c; ASSERT_ALWAYS(d == 7);
 
275
  }
 
276
  {
 
277
    mpz_class a(1), b(3);
 
278
    signed int c = 2;
 
279
    mpz_class d;
 
280
    d = a + c * b; ASSERT_ALWAYS(d == 7);
 
281
  }
 
282
  {
 
283
    mpz_class a(1), b(2);
 
284
    double c = 3.0;
 
285
    mpz_class d;
 
286
    d = a + b * c; ASSERT_ALWAYS(d == 7);
 
287
  }
 
288
  {
 
289
    mpz_class a(1), b(3);
 
290
    double c = 2.0;
 
291
    mpz_class d;
 
292
    d = a + c * b; ASSERT_ALWAYS(d == 7);
 
293
  }
 
294
 
 
295
  {
 
296
    mpz_class a(2), b(3), c(4);
 
297
    mpz_class d;
 
298
    d = a * b + c; ASSERT_ALWAYS(d == 10);
 
299
  }
 
300
  {
 
301
    mpz_class a(2), b(4);
 
302
    unsigned int c = 3;
 
303
    mpz_class d;
 
304
    d = a * c + b; ASSERT_ALWAYS(d == 10);
 
305
  }
 
306
  {
 
307
    mpz_class a(3), b(4);
 
308
    unsigned int c = 2;
 
309
    mpz_class d;
 
310
    d = c * a + b; ASSERT_ALWAYS(d == 10);
 
311
  }
 
312
  {
 
313
    mpz_class a(2), b(4);
 
314
    signed int c = 3;
 
315
    mpz_class d;
 
316
    d = a * c + b; ASSERT_ALWAYS(d == 10);
 
317
  }
 
318
  {
 
319
    mpz_class a(3), b(4);
 
320
    signed int c = 2;
 
321
    mpz_class d;
 
322
    d = c * a + b; ASSERT_ALWAYS(d == 10);
 
323
  }
 
324
  {
 
325
    mpz_class a(2), b(4);
 
326
    double c = 3.0;
 
327
    mpz_class d;
 
328
    d = a * c + b; ASSERT_ALWAYS(d == 10);
 
329
  }
 
330
  {
 
331
    mpz_class a(3), b(4);
 
332
    double c = 2.0;
 
333
    mpz_class d;
 
334
    d = c * a + b; ASSERT_ALWAYS(d == 10);
 
335
  }
 
336
 
 
337
  // mpz_submul
 
338
  {
 
339
    mpz_class a(1), b(2), c(3);
 
340
    mpz_class d;
 
341
    d = a - b * c; ASSERT_ALWAYS(d == -5);
 
342
  }
 
343
  {
 
344
    mpz_class a(1), b(2);
 
345
    unsigned int c = 3;
 
346
    mpz_class d;
 
347
    d = a - b * c; ASSERT_ALWAYS(d == -5);
 
348
  }
 
349
  {
 
350
    mpz_class a(1), b(3);
 
351
    unsigned int c = 2;
 
352
    mpz_class d;
 
353
    d = a - c * b; ASSERT_ALWAYS(d == -5);
 
354
  }
 
355
  {
 
356
    mpz_class a(1), b(2);
 
357
    signed int c = 3;
 
358
    mpz_class d;
 
359
    d = a - b * c; ASSERT_ALWAYS(d == -5);
 
360
  }
 
361
  {
 
362
    mpz_class a(1), b(3);
 
363
    signed int c = 2;
 
364
    mpz_class d;
 
365
    d = a - c * b; ASSERT_ALWAYS(d == -5);
 
366
  }
 
367
  {
 
368
    mpz_class a(1), b(2);
 
369
    double c = 3.0;
 
370
    mpz_class d;
 
371
    d = a - b * c; ASSERT_ALWAYS(d == -5);
 
372
  }
 
373
  {
 
374
    mpz_class a(1), b(3);
 
375
    double c = 2.0;
 
376
    mpz_class d;
 
377
    d = a - c * b; ASSERT_ALWAYS(d == -5);
 
378
  }
 
379
 
 
380
  {
 
381
    mpz_class a(2), b(3), c(4);
 
382
    mpz_class d;
 
383
    d = a * b - c; ASSERT_ALWAYS(d == 2);
 
384
  }
 
385
  {
 
386
    mpz_class a(2), b(4);
 
387
    unsigned int c = 3;
 
388
    mpz_class d;
 
389
    d = a * c - b; ASSERT_ALWAYS(d == 2);
 
390
  }
 
391
  {
 
392
    mpz_class a(3), b(4);
 
393
    unsigned int c = 2;
 
394
    mpz_class d;
 
395
    d = c * a - b; ASSERT_ALWAYS(d == 2);
 
396
  }
 
397
  {
 
398
    mpz_class a(2), b(4);
 
399
    signed int c = 3;
 
400
    mpz_class d;
 
401
    d = a * c - b; ASSERT_ALWAYS(d == 2);
 
402
  }
 
403
  {
 
404
    mpz_class a(3), b(4);
 
405
    signed int c = 2;
 
406
    mpz_class d;
 
407
    d = c * a - b; ASSERT_ALWAYS(d == 2);
 
408
  }
 
409
  {
 
410
    mpz_class a(2), b(4);
 
411
    double c = 3.0;
 
412
    mpz_class d;
 
413
    d = a * c - b; ASSERT_ALWAYS(d == 2);
 
414
  }
 
415
  {
 
416
    mpz_class a(3), b(4);
 
417
    double c = 2.0;
 
418
    mpz_class d;
 
419
    d = c * a - b; ASSERT_ALWAYS(d == 2);
 
420
  }
 
421
}
 
422
 
 
423
void
 
424
check_mpq (void)
 
425
{
 
426
  // unary operators and functions
 
427
 
 
428
  // operator+
 
429
  {
 
430
    mpq_class a(1, 2);
 
431
    mpq_class b;
 
432
    b = +a; ASSERT_ALWAYS(b == 0.5);
 
433
  }
 
434
 
 
435
  // operator-
 
436
  {
 
437
    mpq_class a(3, 4);
 
438
    mpq_class b;
 
439
    b = -a; ASSERT_ALWAYS(b == -0.75);
 
440
  }
 
441
 
 
442
  // abs
 
443
  {
 
444
    mpq_class a(-123);
 
445
    mpq_class b;
 
446
    b = abs(a); ASSERT_ALWAYS(b == 123);
 
447
  }
 
448
 
 
449
  // sgn
 
450
  {
 
451
    mpq_class a(123);
 
452
    int b = sgn(a); ASSERT_ALWAYS(b == 1);
 
453
  }
 
454
  {
 
455
    mpq_class a(0);
 
456
    int b = sgn(a); ASSERT_ALWAYS(b == 0);
 
457
  }
 
458
  {
 
459
    mpq_class a(-123);
 
460
    int b = sgn(a); ASSERT_ALWAYS(b == -1);
 
461
  }
 
462
 
 
463
 
 
464
  // binary operators and functions
 
465
 
 
466
  // operator+
 
467
  {
 
468
    mpq_class a(1, 2), b(3, 4);
 
469
    mpq_class c;
 
470
    c = a + b; ASSERT_ALWAYS(c == 1.25);
 
471
  }
 
472
  {
 
473
    mpq_class a(1, 2);
 
474
    signed int b = 2;
 
475
    mpq_class c;
 
476
    c = a + b; ASSERT_ALWAYS(c == 2.5);
 
477
  }
 
478
  {
 
479
    mpq_class a(1, 2);
 
480
    double b = 1.5;
 
481
    mpq_class c;
 
482
    c = b + a; ASSERT_ALWAYS(c == 2);
 
483
  }
 
484
 
 
485
  // operator-
 
486
  {
 
487
    mpq_class a(1, 2), b(3, 4);
 
488
    mpq_class c;
 
489
    c = a - b; ASSERT_ALWAYS(c == -0.25);
 
490
  }
 
491
 
 
492
  // operator*
 
493
  {
 
494
    mpq_class a(1, 3), b(3, 4);
 
495
    mpq_class c;
 
496
    c = a * b; ASSERT_ALWAYS(c == 0.25);
 
497
  }
 
498
 
 
499
  // operator/
 
500
  {
 
501
    mpq_class a(1, 2), b(2, 3);
 
502
    mpq_class c;
 
503
    c = a / b; ASSERT_ALWAYS(c == 0.75);
 
504
  }
 
505
 
 
506
  // operator<<
 
507
  // operator>>
 
508
  // operator==
 
509
  // operator!=
 
510
  // operator<
 
511
  // operator<=
 
512
  // operator>
 
513
  // operator>=
 
514
 
 
515
  // cmp
 
516
  {
 
517
    mpq_class a(123), b(45);
 
518
    int c;
 
519
    c = cmp(a, b); ASSERT_ALWAYS(c > 0);
 
520
    c = cmp(b, a); ASSERT_ALWAYS(c < 0);
 
521
  }
 
522
  {
 
523
    mpq_class a(123);
 
524
    unsigned long b = 45;
 
525
    int c;
 
526
    c = cmp(a, b); ASSERT_ALWAYS(c > 0);
 
527
    c = cmp(b, a); ASSERT_ALWAYS(c < 0);
 
528
  }
 
529
  {
 
530
    mpq_class a(123);
 
531
    long b = 45;
 
532
    int c;
 
533
    c = cmp(a, b); ASSERT_ALWAYS(c > 0);
 
534
    c = cmp(b, a); ASSERT_ALWAYS(c < 0);
 
535
  }
 
536
  {
 
537
    mpq_class a(123);
 
538
    double b = 45;
 
539
    int c;
 
540
    c = cmp(a, b); ASSERT_ALWAYS(c > 0);
 
541
    c = cmp(b, a); ASSERT_ALWAYS(c < 0);
 
542
  }
 
543
}
 
544
 
 
545
void
 
546
check_mpf (void)
 
547
{
 
548
  // unary operators and functions
 
549
 
 
550
  // operator+
 
551
  {
 
552
    mpf_class a(1);
 
553
    mpf_class b;
 
554
    b = +a; ASSERT_ALWAYS(b == 1);
 
555
  }
 
556
 
 
557
  // operator-
 
558
  {
 
559
    mpf_class a(2);
 
560
    mpf_class b;
 
561
    b = -a; ASSERT_ALWAYS(b == -2);
 
562
  }
 
563
 
 
564
  // abs
 
565
  {
 
566
    mpf_class a(-123);
 
567
    mpf_class b;
 
568
    b = abs(a); ASSERT_ALWAYS(b == 123);
 
569
  }
 
570
 
 
571
  // trunc
 
572
  {
 
573
    mpf_class a(1.5);
 
574
    mpf_class b;
 
575
    b = trunc(a); ASSERT_ALWAYS(b == 1);
 
576
  }
 
577
  {
 
578
    mpf_class a(-1.5);
 
579
    mpf_class b;
 
580
    b = trunc(a); ASSERT_ALWAYS(b == -1);
 
581
  }
 
582
 
 
583
  // floor
 
584
  {
 
585
    mpf_class a(1.9);
 
586
    mpf_class b;
 
587
    b = floor(a); ASSERT_ALWAYS(b == 1);
 
588
  }
 
589
  {
 
590
    mpf_class a(-1.1);
 
591
    mpf_class b;
 
592
    b = floor(a); ASSERT_ALWAYS(b == -2);
 
593
  }
 
594
 
 
595
  // ceil
 
596
  {
 
597
    mpf_class a(1.1);
 
598
    mpf_class b;
 
599
    b = ceil(a); ASSERT_ALWAYS(b == 2);
 
600
  }
 
601
  {
 
602
    mpf_class a(-1.9);
 
603
    mpf_class b;
 
604
    b = ceil(a); ASSERT_ALWAYS(b == -1);
 
605
  }
 
606
 
 
607
  // sqrt
 
608
  {
 
609
    mpf_class a(25);
 
610
    mpf_class b;
 
611
    b = sqrt(a); ASSERT_ALWAYS(b == 5);
 
612
  }
 
613
  {
 
614
    mpf_class a(2.25);
 
615
    mpf_class b;
 
616
    b = sqrt(a); ASSERT_ALWAYS(b == 1.5);
 
617
  }
 
618
 
 
619
  // sgn
 
620
  {
 
621
    mpf_class a(123);
 
622
    int b = sgn(a); ASSERT_ALWAYS(b == 1);
 
623
  }
 
624
  {
 
625
    mpf_class a(0);
 
626
    int b = sgn(a); ASSERT_ALWAYS(b == 0);
 
627
  }
 
628
  {
 
629
    mpf_class a(-123);
 
630
    int b = sgn(a); ASSERT_ALWAYS(b == -1);
 
631
  }
 
632
 
 
633
 
 
634
  // binary operators and functions
 
635
 
 
636
  // operator+
 
637
  {
 
638
    mpf_class a(1), b(2);
 
639
    mpf_class c;
 
640
    c = a + b; ASSERT_ALWAYS(c == 3);
 
641
  }
 
642
 
 
643
  // operator-
 
644
  {
 
645
    mpf_class a(3), b(4);
 
646
    mpf_class c;
 
647
    c = a - b; ASSERT_ALWAYS(c == -1);
 
648
  }
 
649
 
 
650
  // operator*
 
651
  {
 
652
    mpf_class a(2), b(5);
 
653
    mpf_class c;
 
654
    c = a * b; ASSERT_ALWAYS(c == 10);
 
655
  }
 
656
 
 
657
  // operator/
 
658
  {
 
659
    mpf_class a(7), b(4);
 
660
    mpf_class c;
 
661
    c = a / b; ASSERT_ALWAYS(c == 1.75);
 
662
  }
 
663
 
 
664
  // operator<<
 
665
  // operator>>
 
666
  // operator==
 
667
  // operator!=
 
668
  // operator<
 
669
  // operator<=
 
670
  // operator>
 
671
  // operator>=
 
672
 
 
673
  // hypot
 
674
  {
 
675
    mpf_class a(3), b(4);
 
676
    mpf_class c;
 
677
    c = hypot(a, b); ASSERT_ALWAYS(c == 5);
 
678
  }
 
679
 
 
680
  // cmp
 
681
  {
 
682
    mpf_class a(123), b(45);
 
683
    int c;
 
684
    c = cmp(a, b); ASSERT_ALWAYS(c > 0);
 
685
    c = cmp(b, a); ASSERT_ALWAYS(c < 0);
 
686
  }
 
687
  {
 
688
    mpf_class a(123);
 
689
    unsigned long b = 45;
 
690
    int c;
 
691
    c = cmp(a, b); ASSERT_ALWAYS(c > 0);
 
692
    c = cmp(b, a); ASSERT_ALWAYS(c < 0);
 
693
  }
 
694
  {
 
695
    mpf_class a(123);
 
696
    long b = 45;
 
697
    int c;
 
698
    c = cmp(a, b); ASSERT_ALWAYS(c > 0);
 
699
    c = cmp(b, a); ASSERT_ALWAYS(c < 0);
 
700
  }
 
701
  {
 
702
    mpf_class a(123);
 
703
    double b = 45;
 
704
    int c;
 
705
    c = cmp(a, b); ASSERT_ALWAYS(c > 0);
 
706
    c = cmp(b, a); ASSERT_ALWAYS(c < 0);
 
707
  }
 
708
}
 
709
 
 
710
 
 
711
 
 
712
int
 
713
main (void)
 
714
{
 
715
  tests_start();
 
716
 
 
717
  check_mpz();
 
718
  check_mpq();
 
719
  check_mpf();
 
720
 
 
721
  tests_end();
 
722
  return 0;
 
723
}