← Back to branch summary

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

« back to all changes in this revision

Viewing changes to src/gmp/demos/perl/test.pl

  • Committer: Bazaar Package Importer
  • Author(s): Peter Van Eynde
  • Date: 2006-05-17 02:46:26 UTC
  • Revision ID: james.westby@ubuntu.com-20060517024626-lljr08ftv9g9vefl
Tags: upstream-0.9h-20060510
Import upstream version 0.9h-20060510

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/gmp/demos/perl/test.pl
 
1
#!/usr/bin/perl -w
 
2
 
 
3
# GMP perl module tests
 
4
 
 
5
# Copyright 2001, 2002, 2003 Free Software Foundation, Inc.
 
6
#
 
7
# This file is part of the GNU MP Library.
 
8
#
 
9
# The GNU MP Library is free software; you can redistribute it and/or modify
 
10
# it under the terms of the GNU Lesser General Public License as published
 
11
# by the Free Software Foundation; either version 2.1 of the License, or (at
 
12
# your option) any later version.
 
13
#
 
14
# The GNU MP Library is distributed in the hope that it will be useful, but
 
15
# WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 
16
# or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
 
17
# License for more details.
 
18
#
 
19
# You should have received a copy of the GNU Lesser General Public License
 
20
# along with the GNU MP Library; see the file COPYING.LIB.  If not, write to
 
21
# the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
 
22
# MA 02111-1307, USA.
 
23
 
 
24
 
 
25
# These tests aim to exercise the many possible combinations of operands
 
26
# etc, and to run all functions at least once, which if nothing else will
 
27
# check everything intended is in the :all list.
 
28
#
 
29
# Use the following in .emacs to match test failure messages.
 
30
#
 
31
# ;; perl "Test" module error messages
 
32
# (eval-after-load "compile"
 
33
#   '(add-to-list
 
34
#     'compilation-error-regexp-alist
 
35
#     '("^.*Failed test [0-9]+ in \\([^ ]+\\) at line \\([0-9]+\\)" 1 2)))
 
36
 
 
37
 
 
38
use strict;
 
39
use Test;
 
40
 
 
41
BEGIN {
 
42
  plan tests => 123,
 
43
  onfail => sub { print "there were failures\n" },
 
44
}
 
45
 
 
46
use GMP qw(:all);
 
47
use GMP::Mpz qw(:all);
 
48
use GMP::Mpq qw(:all);
 
49
use GMP::Mpf qw(:all);
 
50
use GMP::Rand qw(:all);
 
51
 
 
52
use GMP::Mpz qw(:constants);
 
53
use GMP::Mpz qw(:noconstants);
 
54
use GMP::Mpq qw(:constants);
 
55
use GMP::Mpq qw(:noconstants);
 
56
use GMP::Mpf qw(:constants);
 
57
use GMP::Mpf qw(:noconstants);
 
58
 
 
59
package Mytie;
 
60
use Exporter;
 
61
use vars  qw($val $fetched $stored);
 
62
$val = 0;
 
63
$fetched = 0;
 
64
$stored = 0;
 
65
sub TIESCALAR {
 
66
  my ($class, $newval) = @_;
 
67
  my $var = 'mytie dummy refed var';
 
68
  $val = $newval;
 
69
  $fetched = 0;
 
70
  $stored = 0;
 
71
  return bless \$var, $class;
 
72
}
 
73
sub FETCH {
 
74
  my ($self) = @_;
 
75
  $fetched++;
 
76
  return $val;
 
77
}
 
78
sub STORE {
 
79
  my ($self, $newval) = @_;
 
80
  $val = $newval;
 
81
  $stored++;
 
82
}
 
83
package main;
 
84
 
 
85
# check Mytie does what it should
 
86
{ tie my $t, 'Mytie', 123;
 
87
  ok ($Mytie::val == 123);
 
88
  $Mytie::val = 456;
 
89
  ok ($t == 456);
 
90
  $t = 789;
 
91
  ok ($Mytie::val == 789);
 
92
}
 
93
 
 
94
 
 
95
# Usage: str(x)
 
96
# Return x forced to a string, not a PVIV.
 
97
#
 
98
sub str {
 
99
  my $s = "$_[0]" . "";
 
100
  return $s;
 
101
}
 
102
 
 
103
my $ivnv_2p128 = 65536.0 * 65536.0 * 65536.0 * 65536.0
 
104
               * 65536.0 * 65536.0 * 65536.0 * 65536.0;
 
105
kill (0, $ivnv_2p128);
 
106
my $str_2p128 = '340282366920938463463374607431768211456';
 
107
 
 
108
my $uv_max = ~ 0;
 
109
my $uv_max_str = ~ 0;
 
110
$uv_max_str = "$uv_max_str";
 
111
$uv_max_str = "" . "$uv_max_str";
 
112
 
 
113
 
 
114
#------------------------------------------------------------------------------
 
115
# GMP::version
 
116
 
 
117
use GMP qw(version);
 
118
print '$GMP::VERSION ',$GMP::VERSION,' GMP::version() ',version(),"\n";
 
119
 
 
120
 
 
121
#------------------------------------------------------------------------------
 
122
# GMP::Mpz::new
 
123
 
 
124
ok (mpz(0) == 0);
 
125
ok (mpz('0') == 0);
 
126
ok (mpz(substr('101',1,1)) == 0);
 
127
ok (mpz(0.0) == 0);
 
128
ok (mpz(mpz(0)) == 0);
 
129
ok (mpz(mpq(0)) == 0);
 
130
ok (mpz(mpf(0)) == 0);
 
131
 
 
132
{ tie my $t, 'Mytie', 0;
 
133
  ok (mpz($t) == 0);
 
134
  ok ($Mytie::fetched > 0);
 
135
}
 
136
{ tie my $t, 'Mytie', '0';
 
137
  ok (mpz($t) == 0);
 
138
  ok ($Mytie::fetched > 0);
 
139
}
 
140
{ tie my $t, 'Mytie', substr('101',1,1); ok (mpz($t) == 0); }
 
141
{ tie my $t, 'Mytie', 0.0; ok (mpz($t) == 0); }
 
142
{ tie my $t, 'Mytie', mpz(0); ok (mpz($t) == 0); }
 
143
{ tie my $t, 'Mytie', mpq(0); ok (mpz($t) == 0); }
 
144
{ tie my $t, 'Mytie', mpf(0); ok (mpz($t) == 0); }
 
145
 
 
146
ok (mpz(-123) == -123);
 
147
ok (mpz('-123') == -123);
 
148
ok (mpz(substr('1-1231',1,4)) == -123);
 
149
ok (mpz(-123.0) == -123);
 
150
ok (mpz(mpz(-123)) == -123);
 
151
ok (mpz(mpq(-123)) == -123);
 
152
ok (mpz(mpf(-123)) == -123);
 
153
 
 
154
{ tie my $t, 'Mytie', -123; ok (mpz($t) == -123); }
 
155
{ tie my $t, 'Mytie', '-123'; ok (mpz($t) == -123); }
 
156
{ tie my $t, 'Mytie', substr('1-1231',1,4); ok (mpz($t) == -123); }
 
157
{ tie my $t, 'Mytie', -123.0; ok (mpz($t) == -123); }
 
158
{ tie my $t, 'Mytie', mpz(-123); ok (mpz($t) == -123); }
 
159
{ tie my $t, 'Mytie', mpq(-123); ok (mpz($t) == -123); }
 
160
{ tie my $t, 'Mytie', mpf(-123); ok (mpz($t) == -123); }
 
161
 
 
162
ok (mpz($ivnv_2p128) == $str_2p128);
 
163
{ tie my $t, 'Mytie', $ivnv_2p128; ok (mpz($t) == $str_2p128); }
 
164
 
 
165
ok (mpz($uv_max) > 0);
 
166
ok (mpz($uv_max) == mpz($uv_max_str));
 
167
{ tie my $t, 'Mytie', $uv_max; ok (mpz($t) > 0); }
 
168
{ tie my $t, 'Mytie', $uv_max; ok (mpz($t) == mpz($uv_max_str)); }
 
169
 
 
170
{ my $s = '999999999999999999999999999999';
 
171
  kill (0, $s);
 
172
  ok (mpz($s) == '999999999999999999999999999999');
 
173
  tie my $t, 'Mytie', $s;
 
174
  ok (mpz($t) == '999999999999999999999999999999');
 
175
}
 
176
 
 
177
#------------------------------------------------------------------------------
 
178
# GMP::Mpz::overload_abs
 
179
 
 
180
ok (abs(mpz(0)) == 0);
 
181
ok (abs(mpz(123)) == 123);
 
182
ok (abs(mpz(-123)) == 123);
 
183
 
 
184
{ my $x = mpz(-123); $x = abs($x); ok ($x == 123); }
 
185
{ my $x = mpz(0);    $x = abs($x); ok ($x == 0);   }
 
186
{ my $x = mpz(123);  $x = abs($x); ok ($x == 123); }
 
187
 
 
188
{ tie my $t, 'Mytie', mpz(0); ok (abs($t) == 0); }
 
189
{ tie my $t, 'Mytie', mpz(123); ok (abs($t) == 123); }
 
190
{ tie my $t, 'Mytie', mpz(-123); ok (abs($t) == 123); }
 
191
 
 
192
#------------------------------------------------------------------------------
 
193
# GMP::Mpz::overload_add
 
194
 
 
195
ok (mpz(0) + 1 == 1);
 
196
ok (mpz(-1) + 1 == 0);
 
197
ok (1 + mpz(0) == 1);
 
198
ok (1 + mpz(-1) == 0);
 
199
 
 
200
#------------------------------------------------------------------------------
 
201
# GMP::Mpz::overload_addeq
 
202
 
 
203
{ my $a = mpz(7); $a += 1; ok ($a == 8); }
 
204
{ my $a = mpz(7); my $b = $a; $a += 1; ok ($a == 8); ok ($b == 7); }
 
205
 
 
206
#------------------------------------------------------------------------------
 
207
# GMP::Mpz::overload_and
 
208
 
 
209
ok ((mpz(3) & 1) == 1);
 
210
ok ((mpz(3) & 4) == 0);
 
211
 
 
212
{ my $a = mpz(3); $a &= 1; ok ($a == 1); }
 
213
{ my $a = mpz(3); $a &= 4; ok ($a == 0); }
 
214
 
 
215
#------------------------------------------------------------------------------
 
216
# GMP::Mpz::overload_bool
 
217
 
 
218
if (mpz(0))   { ok (0); } else { ok (1); }
 
219
if (mpz(123)) { ok (1); } else { ok (0); }
 
220
 
 
221
#------------------------------------------------------------------------------
 
222
# GMP::Mpz::overload_com
 
223
 
 
224
ok (~ mpz(0) == -1);
 
225
ok (~ mpz(1) == -2);
 
226
ok (~ mpz(-2) == 1);
 
227
ok (~ mpz(0xFF) == -0x100);
 
228
ok (~ mpz(-0x100) == 0xFF);
 
229
 
 
230
#------------------------------------------------------------------------------
 
231
# GMP::Mpz::overload_dec
 
232
 
 
233
{ my $a = mpz(0); ok ($a-- == 0); ok ($a == -1); }
 
234
{ my $a = mpz(0); ok (--$a == -1); }
 
235
 
 
236
{ my $a = mpz(0); my $b = $a; $a--; ok ($a == -1); ok ($b == 0); }
 
237
 
 
238
#------------------------------------------------------------------------------
 
239
# GMP::Mpz::overload_div
 
240
 
 
241
ok (mpz(6) / 2 == 3);
 
242
ok (mpz(-6) / 2 == -3);
 
243
ok (mpz(6) / -2 == -3);
 
244
ok (mpz(-6) / -2 == 3);
 
245
 
 
246
#------------------------------------------------------------------------------
 
247
# GMP::Mpz::overload_diveq
 
248
 
 
249
{ my $a = mpz(21); $a /= 3; ok ($a == 7); }
 
250
{ my $a = mpz(21); my $b = $a; $a /= 3; ok ($a == 7); ok ($b == 21); }
 
251
 
 
252
#------------------------------------------------------------------------------
 
253
# GMP::Mpz::overload_eq
 
254
 
 
255
{ my $a = mpz(0);
 
256
  my $b = $a;
 
257
  $a = mpz(1);
 
258
  ok ($a == 1);
 
259
  ok ($b == 0); }
 
260
 
 
261
#------------------------------------------------------------------------------
 
262
# GMP::Mpz::overload_inc
 
263
 
 
264
{ my $a = mpz(0); ok ($a++ == 0); ok ($a == 1); }
 
265
{ my $a = mpz(0); ok (++$a == 1); }
 
266
 
 
267
{ my $a = mpz(0); my $b = $a; $a++; ok ($a == 1); ok ($b == 0); }
 
268
 
 
269
#------------------------------------------------------------------------------
 
270
# GMP::Mpz::overload_ior
 
271
 
 
272
ok ((mpz(3) | 1) == 3);
 
273
ok ((mpz(3) | 4) == 7);
 
274
 
 
275
{ my $a = mpz(3); $a |= 1; ok ($a == 3); }
 
276
{ my $a = mpz(3); $a |= 4; ok ($a == 7); }
 
277
 
 
278
ok ((mpz("0xAA") | mpz("0x55")) == mpz("0xFF"));
 
279
 
 
280
#------------------------------------------------------------------------------
 
281
# GMP::Mpz::overload_lshift
 
282
 
 
283
{ my $a = mpz(7) << 1; ok ($a == 14); }
 
284
 
 
285
#------------------------------------------------------------------------------
 
286
# GMP::Mpz::overload_lshifteq
 
287
 
 
288
{ my $a = mpz(7); $a <<= 1; ok ($a == 14); }
 
289
{ my $a = mpz(7); my $b = $a; $a <<= 1; ok ($a == 14); ok ($b == 7); }
 
290
 
 
291
#------------------------------------------------------------------------------
 
292
# GMP::Mpz::overload_mul
 
293
 
 
294
ok (mpz(2) * 3 == 6);
 
295
 
 
296
#------------------------------------------------------------------------------
 
297
# GMP::Mpz::overload_muleq
 
298
 
 
299
{ my $a = mpz(7); $a *= 3;  ok ($a == 21); }
 
300
{ my $a = mpz(7); my $b = $a; $a *= 3;  ok ($a == 21); ok ($b == 7); }
 
301
 
 
302
#------------------------------------------------------------------------------
 
303
# GMP::Mpz::overload_neg
 
304
 
 
305
ok (- mpz(0) == 0);
 
306
ok (- mpz(123) == -123);
 
307
ok (- mpz(-123) == 123);
 
308
 
 
309
#------------------------------------------------------------------------------
 
310
# GMP::Mpz::overload_not
 
311
 
 
312
if (not mpz(0))   { ok (1); } else { ok (0); }
 
313
if (not mpz(123)) { ok (0); } else { ok (1); }
 
314
 
 
315
ok ((! mpz(0)) == 1);
 
316
ok ((! mpz(123)) == 0);
 
317
 
 
318
#------------------------------------------------------------------------------
 
319
# GMP::Mpz::overload_pow
 
320
 
 
321
ok (mpz(0) ** 1 == 0);
 
322
ok (mpz(1) ** 1 == 1);
 
323
ok (mpz(2) ** 0 == 1);
 
324
ok (mpz(2) ** 1 == 2);
 
325
ok (mpz(2) ** 2 == 4);
 
326
ok (mpz(2) ** 3 == 8);
 
327
ok (mpz(2) ** 4 == 16);
 
328
 
 
329
ok (mpz(0) ** mpz(1) == 0);
 
330
ok (mpz(1) ** mpz(1) == 1);
 
331
ok (mpz(2) ** mpz(0) == 1);
 
332
ok (mpz(2) ** mpz(1) == 2);
 
333
ok (mpz(2) ** mpz(2) == 4);
 
334
ok (mpz(2) ** mpz(3) == 8);
 
335
ok (mpz(2) ** mpz(4) == 16);
 
336
 
 
337
#------------------------------------------------------------------------------
 
338
# GMP::Mpz::overload_poweq
 
339
 
 
340
{ my $a = mpz(3); $a **= 4; ok ($a == 81); }
 
341
{ my $a = mpz(3); my $b = $a; $a **= 4; ok ($a == 81); ok ($b == 3); }
 
342
 
 
343
#------------------------------------------------------------------------------
 
344
# GMP::Mpz::overload_rem
 
345
 
 
346
ok (mpz(-8) % 3 == -2);
 
347
ok (mpz(-7) % 3 == -1);
 
348
ok (mpz(-6) % 3 == 0);
 
349
ok (mpz(6) % 3 == 0);
 
350
ok (mpz(7) % 3 == 1);
 
351
ok (mpz(8) % 3 == 2);
 
352
 
 
353
{ my $a = mpz(24); $a %= 7; ok ($a == 3); }
 
354
 
 
355
#------------------------------------------------------------------------------
 
356
# GMP::Mpz::overload_rshift
 
357
 
 
358
{ my $a = mpz(32) >> 1; ok ($a == 16); }
 
359
 
 
360
#------------------------------------------------------------------------------
 
361
# GMP::Mpz::overload_rshifteq
 
362
 
 
363
{ my $a = mpz(32); $a >>= 1; ok ($a == 16); }
 
364
{ my $a = mpz(32); my $b = $a; $a >>= 1; ok ($a == 16); ok ($b == 32); }
 
365
 
 
366
#------------------------------------------------------------------------------
 
367
# GMP::Mpz::overload_spaceship
 
368
 
 
369
ok (mpz(0) < 1);
 
370
ok (mpz(0) > -1);
 
371
 
 
372
ok (mpz(0) != 1);
 
373
ok (mpz(0) != -1);
 
374
ok (mpz(1) != 0);
 
375
ok (mpz(1) != -1);
 
376
ok (mpz(-1) != 0);
 
377
ok (mpz(-1) != 1);
 
378
 
 
379
ok (mpz(0) < 1.0);
 
380
ok (mpz(0) < '1');
 
381
ok (mpz(0) < substr('-1',1,1));
 
382
ok (mpz(0) < mpz(1));
 
383
ok (mpz(0) < mpq(1));
 
384
ok (mpz(0) < mpf(1));
 
385
ok (mpz(0) < $uv_max);
 
386
 
 
387
#------------------------------------------------------------------------------
 
388
# GMP::Mpz::overload_sqrt
 
389
 
 
390
ok (sqrt(mpz(0)) == 0);
 
391
ok (sqrt(mpz(1)) == 1);
 
392
ok (sqrt(mpz(4)) == 2);
 
393
ok (sqrt(mpz(81)) == 9);
 
394
 
 
395
#------------------------------------------------------------------------------
 
396
# GMP::Mpz::overload_string
 
397
 
 
398
{ my $x = mpz(0);    ok("$x" eq "0"); }
 
399
{ my $x = mpz(123);  ok("$x" eq "123"); }
 
400
{ my $x = mpz(-123); ok("$x" eq "-123"); }
 
401
 
 
402
#------------------------------------------------------------------------------
 
403
# GMP::Mpz::overload_sub
 
404
 
 
405
ok (mpz(0) - 1 == -1);
 
406
ok (mpz(1) - 1 == 0);
 
407
ok (1 - mpz(0) == 1);
 
408
ok (1 - mpz(1) == 0);
 
409
 
 
410
#------------------------------------------------------------------------------
 
411
# GMP::Mpz::overload_subeq
 
412
 
 
413
{ my $a = mpz(7); $a -= 1; ok ($a == 6); }
 
414
{ my $a = mpz(7); my $b = $a; $a -= 1; ok ($a == 6); ok ($b == 7); }
 
415
 
 
416
#------------------------------------------------------------------------------
 
417
# GMP::Mpz::overload_xor
 
418
 
 
419
ok ((mpz(3) ^ 1) == 2);
 
420
ok ((mpz(3) ^ 4) == 7);
 
421
 
 
422
{ my $a = mpz(3); $a ^= 1; ok ($a == 2); }
 
423
{ my $a = mpz(3); $a ^= 4; ok ($a == 7); }
 
424
 
 
425
 
 
426
#------------------------------------------------------------------------------
 
427
# GMP::Mpz::bin
 
428
 
 
429
ok (bin(2,0) == 1);
 
430
ok (bin(2,1) == 2);
 
431
ok (bin(2,2) == 1);
 
432
 
 
433
ok (bin(3,0) == 1);
 
434
ok (bin(3,1) == 3);
 
435
ok (bin(3,2) == 3);
 
436
ok (bin(3,3) == 1);
 
437
 
 
438
 
 
439
#------------------------------------------------------------------------------
 
440
# GMP::Mpz::cdiv
 
441
 
 
442
{ my ($q, $r);
 
443
  ($q, $r) = cdiv (16, 3);
 
444
  ok ($q == 6);
 
445
  ok ($r == -2);
 
446
  ($q, $r) = cdiv (16, -3);
 
447
  ok ($q == -5);
 
448
  ok ($r == 1);
 
449
  ($q, $r) = cdiv (-16, 3);
 
450
  ok ($q == -5);
 
451
  ok ($r == -1);
 
452
  ($q, $r) = cdiv (-16, -3);
 
453
  ok ($q == 6);
 
454
  ok ($r == 2);
 
455
}
 
456
 
 
457
 
 
458
#------------------------------------------------------------------------------
 
459
# GMP::Mpz::cdiv_2exp
 
460
 
 
461
{ my ($q, $r);
 
462
  ($q, $r) = cdiv_2exp (23, 2);
 
463
  ok ($q == 6);
 
464
  ok ($r == -1);
 
465
  ($q, $r) = cdiv_2exp (-23, 2);
 
466
  ok ($q == -5);
 
467
  ok ($r == -3);
 
468
}
 
469
 
 
470
 
 
471
#------------------------------------------------------------------------------
 
472
# GMP::Mpz::clrbit
 
473
 
 
474
{ my $a = mpz(3); clrbit ($a, 1); ok ($a == 1);
 
475
  ok (UNIVERSAL::isa($a,"GMP::Mpz")); }
 
476
{ my $a = mpz(3); clrbit ($a, 2); ok ($a == 3);
 
477
  ok (UNIVERSAL::isa($a,"GMP::Mpz")); }
 
478
 
 
479
{ my $a = 3; clrbit ($a, 1); ok ($a == 1);
 
480
  ok (UNIVERSAL::isa($a,"GMP::Mpz")); }
 
481
{ my $a = 3; clrbit ($a, 2); ok ($a == 3);
 
482
  ok (UNIVERSAL::isa($a,"GMP::Mpz")); }
 
483
 
 
484
# mutate only given variable
 
485
{ my $a = mpz(3);
 
486
  my $b = $a;
 
487
  clrbit ($a, 0);
 
488
  ok ($a == 2);
 
489
  ok ($b == 3);
 
490
}
 
491
{ my $a = 3;
 
492
  my $b = $a;
 
493
  clrbit ($a, 0);
 
494
  ok ($a == 2);
 
495
  ok ($b == 3);
 
496
}
 
497
 
 
498
{ tie my $a, 'Mytie', mpz(3);
 
499
  clrbit ($a, 1);
 
500
  ok ($Mytie::fetched > 0);    # used fetch
 
501
  ok ($Mytie::stored > 0);     # used store
 
502
  ok ($a == 1);                # expected result
 
503
  ok (UNIVERSAL::isa($a,"GMP::Mpz"));
 
504
  ok (tied($a));               # still tied
 
505
}
 
506
{ tie my $a, 'Mytie', 3;
 
507
  clrbit ($a, 1);
 
508
  ok ($Mytie::fetched > 0);    # used fetch
 
509
  ok ($Mytie::stored > 0);     # used store
 
510
  ok ($a == 1);                # expected result
 
511
  ok (UNIVERSAL::isa($a,"GMP::Mpz"));
 
512
  ok (tied($a));               # still tied
 
513
}
 
514
 
 
515
{ my $b = mpz(3);
 
516
  tie my $a, 'Mytie', $b;
 
517
  clrbit ($a, 0);
 
518
  ok ($a == 2);
 
519
  ok ($b == 3);
 
520
  ok (tied($a));
 
521
}
 
522
{ my $b = 3;
 
523
  tie my $a, 'Mytie', $b;
 
524
  clrbit ($a, 0);
 
525
  ok ($a == 2);
 
526
  ok ($b == 3);
 
527
  ok (tied($a));
 
528
}
 
529
 
 
530
 
 
531
#------------------------------------------------------------------------------
 
532
# GMP::Mpz::congruent_p
 
533
 
 
534
ok (  congruent_p (21, 0, 7));
 
535
ok (! congruent_p (21, 1, 7));
 
536
ok (  congruent_p (21, 5, 8));
 
537
ok (! congruent_p (21, 6, 8));
 
538
 
 
539
 
 
540
#------------------------------------------------------------------------------
 
541
# GMP::Mpz::congruent_2exp_p
 
542
 
 
543
ok (  congruent_2exp_p (20, 0, 2));
 
544
ok (! congruent_2exp_p (21, 0, 2));
 
545
ok (! congruent_2exp_p (20, 1, 2));
 
546
 
 
547
#------------------------------------------------------------------------------
 
548
# GMP::Mpz::divexact
 
549
 
 
550
ok (divexact(27,3) == 9);
 
551
ok (divexact(27,-3) == -9);
 
552
ok (divexact(-27,3) == -9);
 
553
ok (divexact(-27,-3) == 9);
 
554
 
 
555
#------------------------------------------------------------------------------
 
556
# GMP::Mpz::divisible_p
 
557
 
 
558
ok (  divisible_p (21, 7));
 
559
ok (! divisible_p (21, 8));
 
560
 
 
561
#------------------------------------------------------------------------------
 
562
# GMP::Mpz::divisible_2exp_p
 
563
 
 
564
ok (  divisible_2exp_p (20, 2));
 
565
ok (! divisible_2exp_p (21, 2));
 
566
 
 
567
#------------------------------------------------------------------------------
 
568
# GMP::Mpz::even_p
 
569
 
 
570
ok (! even_p(mpz(-3)));
 
571
ok (  even_p(mpz(-2)));
 
572
ok (! even_p(mpz(-1)));
 
573
ok (  even_p(mpz(0)));
 
574
ok (! even_p(mpz(1)));
 
575
ok (  even_p(mpz(2)));
 
576
ok (! even_p(mpz(3)));
 
577
 
 
578
#------------------------------------------------------------------------------
 
579
# GMP::Mpz::export
 
580
 
 
581
{ my $s = mpz_export (1, 2, 1, 0, "0x61626364");
 
582
  ok ($s eq 'abcd'); }
 
583
{ my $s = mpz_export (-1, 2, 1, 0, "0x61626364");
 
584
  ok ($s eq 'cdab'); }
 
585
{ my $s = mpz_export (1, 2, -1, 0, "0x61626364");
 
586
  ok ($s eq 'badc'); }
 
587
{ my $s = mpz_export (-1, 2, -1, 0, "0x61626364");
 
588
  ok ($s eq 'dcba'); }
 
589
 
 
590
#------------------------------------------------------------------------------
 
591
# GMP::Mpz::fac
 
592
 
 
593
ok (fac(0) == 1);
 
594
ok (fac(1) == 1);
 
595
ok (fac(2) == 2);
 
596
ok (fac(3) == 6);
 
597
ok (fac(4) == 24);
 
598
ok (fac(5) == 120);
 
599
 
 
600
#------------------------------------------------------------------------------
 
601
# GMP::Mpz::fdiv
 
602
 
 
603
{ my ($q, $r);
 
604
  ($q, $r) = fdiv (16, 3);
 
605
  ok ($q == 5);
 
606
  ok ($r == 1);
 
607
  ($q, $r) = fdiv (16, -3);
 
608
  ok ($q == -6);
 
609
  ok ($r == -2);
 
610
  ($q, $r) = fdiv (-16, 3);
 
611
  ok ($q == -6);
 
612
  ok ($r == 2);
 
613
  ($q, $r) = fdiv (-16, -3);
 
614
  ok ($q == 5);
 
615
  ok ($r == -1);
 
616
}
 
617
 
 
618
#------------------------------------------------------------------------------
 
619
# GMP::Mpz::fdiv_2exp
 
620
 
 
621
{ my ($q, $r);
 
622
  ($q, $r) = fdiv_2exp (23, 2);
 
623
  ok ($q == 5);
 
624
  ok ($r == 3);
 
625
  ($q, $r) = fdiv_2exp (-23, 2);
 
626
  ok ($q == -6);
 
627
  ok ($r == 1);
 
628
}
 
629
 
 
630
#------------------------------------------------------------------------------
 
631
# GMP::Mpz::fib
 
632
 
 
633
ok (fib(0) == 0);
 
634
ok (fib(1) == 1);
 
635
ok (fib(2) == 1);
 
636
ok (fib(3) == 2);
 
637
ok (fib(4) == 3);
 
638
ok (fib(5) == 5);
 
639
ok (fib(6) == 8);
 
640
 
 
641
#------------------------------------------------------------------------------
 
642
# GMP::Mpz::fib2
 
643
 
 
644
{ my ($a, $b) = fib2(0); ok($a==0); ok($b==1); }
 
645
{ my ($a, $b) = fib2(1); ok($a==1); ok($b==0); }
 
646
{ my ($a, $b) = fib2(2); ok($a==1); ok($b==1); }
 
647
{ my ($a, $b) = fib2(3); ok($a==2); ok($b==1); }
 
648
{ my ($a, $b) = fib2(4); ok($a==3); ok($b==2); }
 
649
{ my ($a, $b) = fib2(5); ok($a==5); ok($b==3); }
 
650
{ my ($a, $b) = fib2(6); ok($a==8); ok($b==5); }
 
651
 
 
652
#------------------------------------------------------------------------------
 
653
# GMP::Mpz::gcd
 
654
 
 
655
ok (gcd (21) == 21);
 
656
ok (gcd (21,15) == 3);
 
657
ok (gcd (21,15,30,57) == 3);
 
658
ok (gcd (21,-15) == 3);
 
659
ok (gcd (-21,15) == 3);
 
660
ok (gcd (-21,-15) == 3);
 
661
 
 
662
#------------------------------------------------------------------------------
 
663
# GMP::Mpz::gcdext
 
664
 
 
665
{
 
666
  my ($g, $x, $y) = gcdext (3,5);
 
667
  ok ($g == 1);
 
668
  ok ($x == 2);
 
669
  ok ($y == -1);
 
670
}
 
671
 
 
672
#------------------------------------------------------------------------------
 
673
# GMP::Mpz::hamdist
 
674
 
 
675
ok (hamdist(5,7) == 1);
 
676
 
 
677
#------------------------------------------------------------------------------
 
678
# GMP::Mpz::import
 
679
 
 
680
{ my $z = mpz_import (1, 2, 1, 0, 'abcd');
 
681
  ok ($z == 0x61626364); }
 
682
{ my $z = mpz_import (-1, 2, 1, 0, 'abcd');
 
683
  ok ($z == 0x63646162); }
 
684
{ my $z = mpz_import (1, 2, -1, 0, 'abcd');
 
685
  ok ($z == 0x62616463); }
 
686
{ my $z = mpz_import (-1, 2, -1, 0, 'abcd');
 
687
  ok ($z == 0x64636261); }
 
688
 
 
689
#------------------------------------------------------------------------------
 
690
# GMP::Mpz::invert
 
691
 
 
692
ok (invert(1,123) == 1);
 
693
ok (invert(6,7) == 6);
 
694
ok (! defined invert(2,8));
 
695
 
 
696
#------------------------------------------------------------------------------
 
697
# GMP::Mpz::jacobi, GMP::Mpz::kronecker
 
698
 
 
699
foreach my $i ([  1, 19,  1 ],
 
700
               [  4, 19,  1 ],
 
701
               [  5, 19,  1 ],
 
702
               [  6, 19,  1 ],
 
703
               [  7, 19,  1 ],
 
704
               [  9, 19,  1 ],
 
705
               [ 11, 19,  1 ],
 
706
               [ 16, 19,  1 ],
 
707
               [ 17, 19,  1 ],
 
708
               [  2, 19, -1 ],
 
709
               [  3, 19, -1 ],
 
710
               [  8, 19, -1 ],
 
711
               [ 10, 19, -1 ],
 
712
               [ 12, 19, -1 ],
 
713
               [ 13, 19, -1 ],
 
714
               [ 14, 19, -1 ],
 
715
               [ 15, 19, -1 ],
 
716
               [ 18, 19, -1 ]) {
 
717
  foreach my $fun (\&jacobi, \&kronecker) {
 
718
    ok (&$fun ($$i[0], $$i[1]) == $$i[2]);
 
719
 
 
720
    ok (&$fun ($$i[0],      str($$i[1])) == $$i[2]);
 
721
    ok (&$fun (str($$i[0]),     $$i[1])  == $$i[2]);
 
722
    ok (&$fun (str($$i[0]), str($$i[1])) == $$i[2]);
 
723
 
 
724
    ok (&$fun ($$i[0],      mpz($$i[1])) == $$i[2]);
 
725
    ok (&$fun (mpz($$i[0]), $$i[1]) == $$i[2]);
 
726
    ok (&$fun (mpz($$i[0]), mpz($$i[1])) == $$i[2]);
 
727
  }
 
728
}              
 
729
 
 
730
#------------------------------------------------------------------------------
 
731
# GMP::Mpz::lcm
 
732
 
 
733
ok (lcm (2) == 2);
 
734
ok (lcm (0) == 0);
 
735
ok (lcm (0,0) == 0);
 
736
ok (lcm (0,0,0) == 0);
 
737
ok (lcm (0,0,0,0) == 0);
 
738
ok (lcm (2,0) == 0);
 
739
ok (lcm (-2,0) == 0);
 
740
ok (lcm (2,3) == 6);
 
741
ok (lcm (2,3,4) == 12);
 
742
ok (lcm (2,-3) == 6);
 
743
ok (lcm (-2,3) == 6);
 
744
ok (lcm (-2,-3) == 6);
 
745
ok (lcm (mpz(2)**512,1) == mpz(2)**512);
 
746
ok (lcm (mpz(2)**512,-1) == mpz(2)**512);
 
747
ok (lcm (-mpz(2)**512,1) == mpz(2)**512);
 
748
ok (lcm (-mpz(2)**512,-1) == mpz(2)**512);
 
749
ok (lcm (mpz(2)**512,mpz(2)**512) == mpz(2)**512);
 
750
ok (lcm (mpz(2)**512,-mpz(2)**512) == mpz(2)**512);
 
751
ok (lcm (-mpz(2)**512,mpz(2)**512) == mpz(2)**512);
 
752
ok (lcm (-mpz(2)**512,-mpz(2)**512) == mpz(2)**512);
 
753
 
 
754
#------------------------------------------------------------------------------
 
755
# GMP::Mpz::lucnum
 
756
 
 
757
ok (lucnum(0) == 2);
 
758
ok (lucnum(1) == 1);
 
759
ok (lucnum(2) == 3);
 
760
ok (lucnum(3) == 4);
 
761
ok (lucnum(4) == 7);
 
762
ok (lucnum(5) == 11);
 
763
ok (lucnum(6) == 18);
 
764
 
 
765
#------------------------------------------------------------------------------
 
766
# GMP::Mpz::lucnum2
 
767
 
 
768
{ my ($a, $b) = lucnum2(0); ok($a==2);  ok($b==-1); }
 
769
{ my ($a, $b) = lucnum2(1); ok($a==1);  ok($b==2); }
 
770
{ my ($a, $b) = lucnum2(2); ok($a==3);  ok($b==1); }
 
771
{ my ($a, $b) = lucnum2(3); ok($a==4);  ok($b==3); }
 
772
{ my ($a, $b) = lucnum2(4); ok($a==7);  ok($b==4); }
 
773
{ my ($a, $b) = lucnum2(5); ok($a==11); ok($b==7); }
 
774
{ my ($a, $b) = lucnum2(6); ok($a==18); ok($b==11); }
 
775
 
 
776
#------------------------------------------------------------------------------
 
777
# GMP::Mpz::nextprime
 
778
 
 
779
ok (nextprime(2) == 3);
 
780
ok (nextprime(3) == 5);
 
781
ok (nextprime(5) == 7);
 
782
ok (nextprime(7) == 11);
 
783
ok (nextprime(11) == 13);
 
784
 
 
785
#------------------------------------------------------------------------------
 
786
# GMP::Mpz::perfect_power_p
 
787
 
 
788
# ok (  perfect_power_p(mpz(-27)));
 
789
# ok (! perfect_power_p(mpz(-9)));
 
790
# ok (! perfect_power_p(mpz(-1)));
 
791
ok (  perfect_power_p(mpz(0)));
 
792
ok (  perfect_power_p(mpz(1)));
 
793
ok (! perfect_power_p(mpz(2)));
 
794
ok (! perfect_power_p(mpz(3)));
 
795
ok (  perfect_power_p(mpz(4)));
 
796
ok (  perfect_power_p(mpz(9)));
 
797
ok (  perfect_power_p(mpz(27)));
 
798
ok (  perfect_power_p(mpz(81)));
 
799
 
 
800
#------------------------------------------------------------------------------
 
801
# GMP::Mpz::perfect_square_p
 
802
 
 
803
ok (! perfect_square_p(mpz(-9)));
 
804
ok (! perfect_square_p(mpz(-1)));
 
805
ok (  perfect_square_p(mpz(0)));
 
806
ok (  perfect_square_p(mpz(1)));
 
807
ok (! perfect_square_p(mpz(2)));
 
808
ok (! perfect_square_p(mpz(3)));
 
809
ok (  perfect_square_p(mpz(4)));
 
810
ok (  perfect_square_p(mpz(9)));
 
811
ok (! perfect_square_p(mpz(27)));
 
812
ok (  perfect_square_p(mpz(81)));
 
813
 
 
814
#------------------------------------------------------------------------------
 
815
# GMP::Mpz::popcount
 
816
 
 
817
ok (popcount(7) == 3);
 
818
 
 
819
#------------------------------------------------------------------------------
 
820
# GMP::Mpz::powm
 
821
 
 
822
ok (powm (3,2,8) == 1);
 
823
 
 
824
#------------------------------------------------------------------------------
 
825
# GMP::Mpz::probab_prime_p
 
826
 
 
827
ok (  probab_prime_p(89,1));
 
828
ok (! probab_prime_p(81,1));
 
829
 
 
830
#------------------------------------------------------------------------------
 
831
# GMP::Mpz::realloc
 
832
 
 
833
{ my $z = mpz(123);
 
834
  realloc ($z, 512); }
 
835
 
 
836
#------------------------------------------------------------------------------
 
837
# GMP::Mpz::remove
 
838
 
 
839
{
 
840
  my ($rem, $mult);
 
841
  ($rem, $mult) = remove(12,3);
 
842
  ok ($rem == 4);
 
843
  ok ($mult == 1);
 
844
  ($rem, $mult) = remove(12,2);
 
845
  ok ($rem == 3);
 
846
  ok ($mult == 2);
 
847
}
 
848
 
 
849
#------------------------------------------------------------------------------
 
850
# GMP::Mpz::root
 
851
 
 
852
ok (root(0,2) == 0);
 
853
ok (root(8,3) == 2);
 
854
ok (root(-8,3) == -2);
 
855
ok (root(81,4) == 3);
 
856
ok (root(243,5) == 3);
 
857
 
 
858
#------------------------------------------------------------------------------
 
859
# GMP::Mpz::roote
 
860
 
 
861
{ my ($r,$e);
 
862
  ($r, $e) = roote(0,2);
 
863
  ok ($r == 0);
 
864
  ok ($e);
 
865
  ($r, $e) = roote(81,4);
 
866
  ok ($r == 3);
 
867
  ok ($e);
 
868
  ($r, $e) = roote(85,4);
 
869
  ok ($r == 3);
 
870
  ok (! $e);
 
871
}
 
872
 
 
873
#------------------------------------------------------------------------------
 
874
# GMP::Mpz::scan0
 
875
 
 
876
ok (scan0 (0, 0) == 0);
 
877
ok (scan0 (1, 0) == 1);
 
878
ok (scan0 (3, 0) == 2);
 
879
ok (scan0 (-1, 0) == ~0);
 
880
ok (scan0 (-2, 1) == ~0);
 
881
 
 
882
#------------------------------------------------------------------------------
 
883
# GMP::Mpz::scan1
 
884
 
 
885
ok (scan1 (1, 0) == 0);
 
886
ok (scan1 (2, 0) == 1);
 
887
ok (scan1 (4, 0) == 2);
 
888
ok (scan1 (0, 0) == ~0);
 
889
ok (scan1 (3, 2) == ~0);
 
890
 
 
891
#------------------------------------------------------------------------------
 
892
# GMP::Mpz::setbit
 
893
 
 
894
{ my $a = mpz(3); setbit ($a, 1); ok ($a == 3); }
 
895
{ my $a = mpz(3); setbit ($a, 2); ok ($a == 7); }
 
896
 
 
897
{ my $a = 3; setbit ($a, 1); ok ($a == 3); }
 
898
{ my $a = 3; setbit ($a, 2); ok ($a == 7); }
 
899
 
 
900
# mutate only given variable
 
901
{ my $a = mpz(0);
 
902
  my $b = $a;
 
903
  setbit ($a, 0);
 
904
  ok ($a == 1);
 
905
  ok ($b == 0);
 
906
}
 
907
{ my $a = 0;
 
908
  my $b = $a;
 
909
  setbit ($a, 0);
 
910
  ok ($a == 1);
 
911
  ok ($b == 0);
 
912
}
 
913
 
 
914
{ tie my $a, 'Mytie', mpz(3);
 
915
  setbit ($a, 2);
 
916
  ok ($Mytie::fetched > 0);    # used fetch
 
917
  ok ($Mytie::stored > 0);     # used store
 
918
  ok ($a == 7);                # expected result
 
919
  ok (UNIVERSAL::isa($a,"GMP::Mpz"));
 
920
  ok (tied($a));               # still tied
 
921
}
 
922
{ tie my $a, 'Mytie', 3;
 
923
  setbit ($a, 2);
 
924
  ok ($Mytie::fetched > 0);    # used fetch
 
925
  ok ($Mytie::stored > 0);     # used store
 
926
  ok ($a == 7);                # expected result
 
927
  ok (UNIVERSAL::isa($a,"GMP::Mpz"));
 
928
  ok (tied($a));               # still tied
 
929
}
 
930
 
 
931
{ my $b = mpz(2);
 
932
  tie my $a, 'Mytie', $b;
 
933
  setbit ($a, 0);
 
934
  ok ($a == 3);
 
935
  ok ($b == 2);
 
936
  ok (tied($a));
 
937
}
 
938
{ my $b = 2;
 
939
  tie my $a, 'Mytie', $b;
 
940
  setbit ($a, 0);
 
941
  ok ($a == 3);
 
942
  ok ($b == 2);
 
943
  ok (tied($a));
 
944
}
 
945
 
 
946
#------------------------------------------------------------------------------
 
947
# GMP::Mpz::sizeinbase
 
948
 
 
949
ok (sizeinbase(1,10) == 1);
 
950
ok (sizeinbase(100,10) == 3);
 
951
ok (sizeinbase(9999,10) == 5);
 
952
 
 
953
#------------------------------------------------------------------------------
 
954
# GMP::Mpz::sqrtrem
 
955
 
 
956
{
 
957
  my ($root, $rem) = sqrtrem(mpz(0));
 
958
  ok ($root == 0);
 
959
  ok ($rem == 0);
 
960
}
 
961
{
 
962
  my ($root, $rem) = sqrtrem(mpz(1));
 
963
  ok ($root == 1);
 
964
  ok ($rem == 0);
 
965
}
 
966
{
 
967
  my ($root, $rem) = sqrtrem(mpz(2));
 
968
  ok ($root == 1);
 
969
  ok ($rem == 1);
 
970
}
 
971
{
 
972
  my ($root, $rem) = sqrtrem(mpz(9));
 
973
  ok ($root == 3);
 
974
  ok ($rem == 0);
 
975
}
 
976
{
 
977
  my ($root, $rem) = sqrtrem(mpz(35));
 
978
  ok ($root == 5);
 
979
  ok ($rem == 10);
 
980
}
 
981
{
 
982
  my ($root, $rem) = sqrtrem(mpz(0));
 
983
  ok ($root == 0);
 
984
  ok ($rem == 0);
 
985
}
 
986
 
 
987
#------------------------------------------------------------------------------
 
988
# GMP::Mpz::tdiv
 
989
 
 
990
{ my ($q, $r);
 
991
  ($q, $r) = tdiv (16, 3);
 
992
  ok ($q == 5);
 
993
  ok ($r == 1);
 
994
  ($q, $r) = tdiv (16, -3);
 
995
  ok ($q == -5);
 
996
  ok ($r == 1);
 
997
  ($q, $r) = tdiv (-16, 3);
 
998
  ok ($q == -5);
 
999
  ok ($r == -1);
 
1000
  ($q, $r) = tdiv (-16, -3);
 
1001
  ok ($q == 5);
 
1002
  ok ($r == -1);
 
1003
}
 
1004
 
 
1005
#------------------------------------------------------------------------------
 
1006
# GMP::Mpz::tdiv_2exp
 
1007
 
 
1008
{ my ($q, $r);
 
1009
  ($q, $r) = tdiv_2exp (23, 2);
 
1010
  ok ($q == 5);
 
1011
  ok ($r == 3);
 
1012
  ($q, $r) = tdiv_2exp (-23, 2);
 
1013
  ok ($q == -5);
 
1014
  ok ($r == -3);
 
1015
}
 
1016
 
 
1017
#------------------------------------------------------------------------------
 
1018
# GMP::Mpz::tstbit
 
1019
 
 
1020
ok (tstbit (6, 0) == 0);
 
1021
ok (tstbit (6, 1) == 1);
 
1022
ok (tstbit (6, 2) == 1);
 
1023
ok (tstbit (6, 3) == 0);
 
1024
 
 
1025
 
 
1026
 
 
1027
 
 
1028
#------------------------------------------------------------------------------
 
1029
# GMP::Mpq
 
1030
 
 
1031
#------------------------------------------------------------------------------
 
1032
# GMP::Mpq::new
 
1033
 
 
1034
ok (mpq(0) == 0);
 
1035
ok (mpq('0') == 0);
 
1036
ok (mpq(substr('101',1,1)) == 0);
 
1037
ok (mpq(0.0) == 0);
 
1038
ok (mpq(mpz(0)) == 0);
 
1039
ok (mpq(mpq(0)) == 0);
 
1040
ok (mpq(mpf(0)) == 0);
 
1041
 
 
1042
{ tie my $t, 'Mytie', 0; ok (mpq($t) == 0); }
 
1043
{ tie my $t, 'Mytie', '0'; ok (mpq($t) == 0); }
 
1044
{ tie my $t, 'Mytie', substr('101',1,1); ok (mpq($t) == 0); }
 
1045
{ tie my $t, 'Mytie', 0.0; ok (mpq($t) == 0); }
 
1046
{ tie my $t, 'Mytie', mpz(0); ok (mpq($t) == 0); }
 
1047
{ tie my $t, 'Mytie', mpq(0); ok (mpq($t) == 0); }
 
1048
{ tie my $t, 'Mytie', mpf(0); ok (mpq($t) == 0); }
 
1049
 
 
1050
ok (mpq(-123) == -123);
 
1051
ok (mpq('-123') == -123);
 
1052
ok (mpq(substr('1-1231',1,4)) == -123);
 
1053
ok (mpq(-123.0) == -123);
 
1054
ok (mpq(mpz(-123)) == -123);
 
1055
ok (mpq(mpq(-123)) == -123);
 
1056
ok (mpq(mpf(-123)) == -123);
 
1057
 
 
1058
{ tie my $t, 'Mytie', -123; ok (mpq($t) == -123); }
 
1059
{ tie my $t, 'Mytie', '-123'; ok (mpq($t) == -123); }
 
1060
{ tie my $t, 'Mytie', substr('1-1231',1,4); ok (mpq($t) == -123); }
 
1061
{ tie my $t, 'Mytie', -123.0; ok (mpq($t) == -123); }
 
1062
{ tie my $t, 'Mytie', mpz(-123); ok (mpq($t) == -123); }
 
1063
{ tie my $t, 'Mytie', mpq(-123); ok (mpq($t) == -123); }
 
1064
{ tie my $t, 'Mytie', mpf(-123); ok (mpq($t) == -123); }
 
1065
 
 
1066
ok (mpq($ivnv_2p128) == $str_2p128);
 
1067
{ tie my $t, 'Mytie', $ivnv_2p128; ok (mpq($t) == $str_2p128); }
 
1068
 
 
1069
ok (mpq('3/2') == mpq(3,2));
 
1070
ok (mpq('3/1') == mpq(3,1));
 
1071
ok (mpq('-3/2') == mpq(-3,2));
 
1072
ok (mpq('-3/1') == mpq(-3,1));
 
1073
ok (mpq('0x3') == mpq(3,1));
 
1074
ok (mpq('0b111') == mpq(7,1));
 
1075
ok (mpq('0b0') == mpq(0,1));
 
1076
 
 
1077
ok (mpq($uv_max) > 0);
 
1078
ok (mpq($uv_max) == mpq($uv_max_str));
 
1079
{ tie my $t, 'Mytie', $uv_max; ok (mpq($t) > 0); }
 
1080
{ tie my $t, 'Mytie', $uv_max; ok (mpq($t) == mpq($uv_max_str)); }
 
1081
 
 
1082
{ my $x = 123.5;
 
1083
  kill (0, $x);
 
1084
  ok (mpq($x) == 123.5);
 
1085
  tie my $t, 'Mytie', $x;
 
1086
  ok (mpq($t) == 123.5);
 
1087
}
 
1088
 
 
1089
#------------------------------------------------------------------------------
 
1090
# GMP::Mpq::overload_abs
 
1091
 
 
1092
ok (abs(mpq(0)) == 0);
 
1093
ok (abs(mpq(123)) == 123);
 
1094
ok (abs(mpq(-123)) == 123);
 
1095
 
 
1096
{ my $x = mpq(-123); $x = abs($x); ok ($x == 123); }
 
1097
{ my $x = mpq(0);    $x = abs($x); ok ($x == 0);   }
 
1098
{ my $x = mpq(123);  $x = abs($x); ok ($x == 123); }
 
1099
 
 
1100
{ tie my $t, 'Mytie', mpq(0); ok (abs($t) == 0); }
 
1101
{ tie my $t, 'Mytie', mpq(123); ok (abs($t) == 123); }
 
1102
{ tie my $t, 'Mytie', mpq(-123); ok (abs($t) == 123); }
 
1103
 
 
1104
#------------------------------------------------------------------------------
 
1105
# GMP::Mpq::overload_add
 
1106
 
 
1107
ok (mpq(0) + 1 == 1);
 
1108
ok (mpq(-1) + 1 == 0);
 
1109
ok (1 + mpq(0) == 1);
 
1110
ok (1 + mpq(-1) == 0);
 
1111
 
 
1112
ok (mpq(1,2)+mpq(1,3) == mpq(5,6));
 
1113
ok (mpq(1,2)+mpq(-1,3) == mpq(1,6));
 
1114
ok (mpq(-1,2)+mpq(1,3) == mpq(-1,6));
 
1115
ok (mpq(-1,2)+mpq(-1,3) == mpq(-5,6));
 
1116
 
 
1117
#------------------------------------------------------------------------------
 
1118
# GMP::Mpq::overload_addeq
 
1119
 
 
1120
{ my $a = mpq(7); $a += 1; ok ($a == 8); }
 
1121
{ my $a = mpq(7); my $b = $a; $a += 1; ok ($a == 8); ok ($b == 7); }
 
1122
 
 
1123
#------------------------------------------------------------------------------
 
1124
# GMP::Mpq::overload_bool
 
1125
 
 
1126
if (mpq(0))   { ok (0); } else { ok (1); }
 
1127
if (mpq(123)) { ok (1); } else { ok (0); }
 
1128
 
 
1129
#------------------------------------------------------------------------------
 
1130
# GMP::Mpq::overload_dec
 
1131
 
 
1132
{ my $a = mpq(0); ok ($a-- == 0); ok ($a == -1); }
 
1133
{ my $a = mpq(0); ok (--$a == -1); }
 
1134
 
 
1135
{ my $a = mpq(0); my $b = $a; $a--; ok ($a == -1); ok ($b == 0); }
 
1136
 
 
1137
#------------------------------------------------------------------------------
 
1138
# GMP::Mpq::overload_div
 
1139
 
 
1140
ok (mpq(6) / 2 == 3);
 
1141
ok (mpq(-6) / 2 == -3);
 
1142
ok (mpq(6) / -2 == -3);
 
1143
ok (mpq(-6) / -2 == 3);
 
1144
 
 
1145
#------------------------------------------------------------------------------
 
1146
# GMP::Mpq::overload_diveq
 
1147
 
 
1148
{ my $a = mpq(21); $a /= 3; ok ($a == 7); }
 
1149
{ my $a = mpq(21); my $b = $a; $a /= 3; ok ($a == 7); ok ($b == 21); }
 
1150
 
 
1151
#------------------------------------------------------------------------------
 
1152
# GMP::Mpq::overload_eq
 
1153
 
 
1154
{ my $a = mpq(0);
 
1155
  my $b = $a;
 
1156
  $a = mpq(1);
 
1157
  ok ($a == 1);
 
1158
  ok ($b == 0); }
 
1159
 
 
1160
#------------------------------------------------------------------------------
 
1161
# GMP::Mpq::overload_inc
 
1162
 
 
1163
{ my $a = mpq(0); ok ($a++ == 0); ok ($a == 1); }
 
1164
{ my $a = mpq(0); ok (++$a == 1); }
 
1165
 
 
1166
{ my $a = mpq(0); my $b = $a; $a++; ok ($a == 1); ok ($b == 0); }
 
1167
 
 
1168
#------------------------------------------------------------------------------
 
1169
# GMP::Mpq::overload_lshift
 
1170
 
 
1171
{ my $a = mpq(7) << 1; ok ($a == 14); }
 
1172
 
 
1173
#------------------------------------------------------------------------------
 
1174
# GMP::Mpq::overload_lshifteq
 
1175
 
 
1176
{ my $a = mpq(7); $a <<= 1; ok ($a == 14); }
 
1177
{ my $a = mpq(7); my $b = $a; $a <<= 1; ok ($a == 14); ok ($b == 7); }
 
1178
 
 
1179
#------------------------------------------------------------------------------
 
1180
# GMP::Mpq::overload_mul
 
1181
 
 
1182
ok (mpq(2) * 3 == 6);
 
1183
 
 
1184
#------------------------------------------------------------------------------
 
1185
# GMP::Mpq::overload_muleq
 
1186
 
 
1187
{ my $a = mpq(7); $a *= 3;  ok ($a == 21); }
 
1188
{ my $a = mpq(7); my $b = $a; $a *= 3;  ok ($a == 21); ok ($b == 7); }
 
1189
 
 
1190
#------------------------------------------------------------------------------
 
1191
# GMP::Mpq::overload_neg
 
1192
 
 
1193
ok (- mpq(0) == 0);
 
1194
ok (- mpq(123) == -123);
 
1195
ok (- mpq(-123) == 123);
 
1196
 
 
1197
#------------------------------------------------------------------------------
 
1198
# GMP::Mpq::overload_not
 
1199
 
 
1200
if (not mpq(0))   { ok (1); } else { ok (0); }
 
1201
if (not mpq(123)) { ok (0); } else { ok (1); }
 
1202
 
 
1203
ok ((! mpq(0)) == 1);
 
1204
ok ((! mpq(123)) == 0);
 
1205
 
 
1206
#------------------------------------------------------------------------------
 
1207
# GMP::Mpq::overload_pow
 
1208
 
 
1209
ok (mpq(0) ** 1 == 0);
 
1210
ok (mpq(1) ** 1 == 1);
 
1211
ok (mpq(2) ** 0 == 1);
 
1212
ok (mpq(2) ** 1 == 2);
 
1213
ok (mpq(2) ** 2 == 4);
 
1214
ok (mpq(2) ** 3 == 8);
 
1215
ok (mpq(2) ** 4 == 16);
 
1216
 
 
1217
ok (mpq(0) ** mpq(1) == 0);
 
1218
ok (mpq(1) ** mpq(1) == 1);
 
1219
ok (mpq(2) ** mpq(0) == 1);
 
1220
ok (mpq(2) ** mpq(1) == 2);
 
1221
ok (mpq(2) ** mpq(2) == 4);
 
1222
ok (mpq(2) ** mpq(3) == 8);
 
1223
ok (mpq(2) ** mpq(4) == 16);
 
1224
 
 
1225
#------------------------------------------------------------------------------
 
1226
# GMP::Mpq::overload_poweq
 
1227
 
 
1228
{ my $a = mpq(3); $a **= 4; ok ($a == 81); }
 
1229
{ my $a = mpq(3); my $b = $a; $a **= 4; ok ($a == 81); ok ($b == 3); }
 
1230
 
 
1231
#------------------------------------------------------------------------------
 
1232
# GMP::Mpq::overload_rshift
 
1233
 
 
1234
{ my $a = mpq(32) >> 1; ok ($a == 16); }
 
1235
 
 
1236
#------------------------------------------------------------------------------
 
1237
# GMP::Mpq::overload_rshifteq
 
1238
 
 
1239
{ my $a = mpq(32); $a >>= 1; ok ($a == 16); }
 
1240
{ my $a = mpq(32); my $b = $a; $a >>= 1; ok ($a == 16); ok ($b == 32); }
 
1241
 
 
1242
#------------------------------------------------------------------------------
 
1243
# GMP::Mpq::overload_spaceship
 
1244
 
 
1245
ok (mpq(0) < 1);
 
1246
ok (mpq(0) > -1);
 
1247
 
 
1248
ok (mpq(0) != 1);
 
1249
ok (mpq(0) != -1);
 
1250
ok (mpq(1) != 0);
 
1251
ok (mpq(1) != -1);
 
1252
ok (mpq(-1) != 0);
 
1253
ok (mpq(-1) != 1);
 
1254
 
 
1255
ok (mpq(3,2) > 1);
 
1256
ok (mpq(3,2) < 2);
 
1257
 
 
1258
ok (mpq(0) < 1.0);
 
1259
ok (mpq(0) < '1');
 
1260
ok (mpq(0) < substr('-1',1,1));
 
1261
ok (mpq(0) < mpz(1));
 
1262
ok (mpq(0) < mpq(1));
 
1263
ok (mpq(0) < mpf(1));
 
1264
ok (mpq(0) < $uv_max);
 
1265
 
 
1266
#------------------------------------------------------------------------------
 
1267
# GMP::Mpq::overload_string
 
1268
 
 
1269
{ my $x = mpq(0);    ok("$x" eq "0"); }
 
1270
{ my $x = mpq(123);  ok("$x" eq "123"); }
 
1271
{ my $x = mpq(-123); ok("$x" eq "-123"); }
 
1272
 
 
1273
{ my $q = mpq(5,7);  ok("$q" eq "5/7"); }
 
1274
{ my $q = mpq(-5,7); ok("$q" eq "-5/7"); }
 
1275
 
 
1276
#------------------------------------------------------------------------------
 
1277
# GMP::Mpq::overload_sub
 
1278
 
 
1279
ok (mpq(0) - 1 == -1);
 
1280
ok (mpq(1) - 1 == 0);
 
1281
ok (1 - mpq(0) == 1);
 
1282
ok (1 - mpq(1) == 0);
 
1283
 
 
1284
ok (mpq(1,2)-mpq(1,3) == mpq(1,6));
 
1285
ok (mpq(1,2)-mpq(-1,3) == mpq(5,6));
 
1286
ok (mpq(-1,2)-mpq(1,3) == mpq(-5,6));
 
1287
ok (mpq(-1,2)-mpq(-1,3) == mpq(-1,6));
 
1288
 
 
1289
#------------------------------------------------------------------------------
 
1290
# GMP::Mpq::overload_subeq
 
1291
 
 
1292
{ my $a = mpq(7); $a -= 1; ok ($a == 6); }
 
1293
{ my $a = mpq(7); my $b = $a; $a -= 1; ok ($a == 6); ok ($b == 7); }
 
1294
 
 
1295
#------------------------------------------------------------------------------
 
1296
# GMP::Mpq::canonicalize
 
1297
 
 
1298
{ my $q = mpq(21,15); canonicalize($q);
 
1299
  ok (num($q) == 7);
 
1300
  ok (den($q) == 5);
 
1301
}
 
1302
 
 
1303
#------------------------------------------------------------------------------
 
1304
# GMP::Mpq::den
 
1305
 
 
1306
{ my $q = mpq(5,9); ok (den($q) == 9); }
 
1307
 
 
1308
#------------------------------------------------------------------------------
 
1309
# GMP::Mpq::num
 
1310
 
 
1311
{ my $q = mpq(5,9); ok (num($q) == 5); }
 
1312
 
 
1313
 
 
1314
 
 
1315
 
 
1316
#------------------------------------------------------------------------------
 
1317
# GMP::Mpf
 
1318
 
 
1319
#------------------------------------------------------------------------------
 
1320
# GMP::Mpf::new
 
1321
 
 
1322
ok (mpf(0) == 0);
 
1323
ok (mpf('0') == 0);
 
1324
ok (mpf(substr('101',1,1)) == 0);
 
1325
ok (mpf(0.0) == 0);
 
1326
ok (mpf(mpz(0)) == 0);
 
1327
ok (mpf(mpq(0)) == 0);
 
1328
ok (mpf(mpf(0)) == 0);
 
1329
 
 
1330
{ tie my $t, 'Mytie', 0; ok (mpf($t) == 0); }
 
1331
{ tie my $t, 'Mytie', '0'; ok (mpf($t) == 0); }
 
1332
{ tie my $t, 'Mytie', substr('101',1,1); ok (mpf($t) == 0); }
 
1333
{ tie my $t, 'Mytie', 0.0; ok (mpf($t) == 0); }
 
1334
{ tie my $t, 'Mytie', mpz(0); ok (mpf($t) == 0); }
 
1335
{ tie my $t, 'Mytie', mpq(0); ok (mpf($t) == 0); }
 
1336
{ tie my $t, 'Mytie', mpf(0); ok (mpf($t) == 0); }
 
1337
 
 
1338
ok (mpf(-123) == -123);
 
1339
ok (mpf('-123') == -123);
 
1340
ok (mpf(substr('1-1231',1,4)) == -123);
 
1341
ok (mpf(-123.0) == -123);
 
1342
ok (mpf(mpz(-123)) == -123);
 
1343
ok (mpf(mpq(-123)) == -123);
 
1344
ok (mpf(mpf(-123)) == -123);
 
1345
 
 
1346
{ tie my $t, 'Mytie', -123; ok (mpf($t) == -123); }
 
1347
{ tie my $t, 'Mytie', '-123'; ok (mpf($t) == -123); }
 
1348
{ tie my $t, 'Mytie', substr('1-1231',1,4); ok (mpf($t) == -123); }
 
1349
{ tie my $t, 'Mytie', -123.0; ok (mpf($t) == -123); }
 
1350
{ tie my $t, 'Mytie', mpz(-123); ok (mpf($t) == -123); }
 
1351
{ tie my $t, 'Mytie', mpq(-123); ok (mpf($t) == -123); }
 
1352
{ tie my $t, 'Mytie', mpf(-123); ok (mpf($t) == -123); }
 
1353
 
 
1354
ok (mpf($ivnv_2p128) == $str_2p128);
 
1355
{ tie my $t, 'Mytie', $ivnv_2p128; ok (mpf($t) == $str_2p128); }
 
1356
 
 
1357
ok (mpf(-1.5) == -1.5);
 
1358
ok (mpf(-1.0) == -1.0);
 
1359
ok (mpf(-0.5) == -0.5);
 
1360
ok (mpf(0) == 0);
 
1361
ok (mpf(0.5) == 0.5);
 
1362
ok (mpf(1.0) == 1.0);
 
1363
ok (mpf(1.5) == 1.5);
 
1364
 
 
1365
ok (mpf("-1.5") == -1.5);
 
1366
ok (mpf("-1.0") == -1.0);
 
1367
ok (mpf("-0.5") == -0.5);
 
1368
ok (mpf("0") == 0);
 
1369
ok (mpf("0.5") == 0.5);
 
1370
ok (mpf("1.0") == 1.0);
 
1371
ok (mpf("1.5") == 1.5);
 
1372
 
 
1373
ok (mpf($uv_max) > 0);
 
1374
ok (mpf($uv_max) == mpf($uv_max_str));
 
1375
{ tie my $t, 'Mytie', $uv_max; ok (mpf($t) > 0); }
 
1376
{ tie my $t, 'Mytie', $uv_max; ok (mpf($t) == mpf($uv_max_str)); }
 
1377
 
 
1378
{ my $x = 123.5;
 
1379
  kill (0, $x);
 
1380
  ok (mpf($x) == 123.5);
 
1381
  tie my $t, 'Mytie', $x;
 
1382
  ok (mpf($t) == 123.5);
 
1383
}
 
1384
 
 
1385
#------------------------------------------------------------------------------
 
1386
# GMP::Mpf::overload_abs
 
1387
 
 
1388
ok (abs(mpf(0)) == 0);
 
1389
ok (abs(mpf(123)) == 123);
 
1390
ok (abs(mpf(-123)) == 123);
 
1391
 
 
1392
{ my $x = mpf(-123); $x = abs($x); ok ($x == 123); }
 
1393
{ my $x = mpf(0);    $x = abs($x); ok ($x == 0);   }
 
1394
{ my $x = mpf(123);  $x = abs($x); ok ($x == 123); }
 
1395
 
 
1396
{ tie my $t, 'Mytie', mpf(0); ok (abs($t) == 0); }
 
1397
{ tie my $t, 'Mytie', mpf(123); ok (abs($t) == 123); }
 
1398
{ tie my $t, 'Mytie', mpf(-123); ok (abs($t) == 123); }
 
1399
 
 
1400
#------------------------------------------------------------------------------
 
1401
# GMP::Mpf::overload_add
 
1402
 
 
1403
ok (mpf(0) + 1 == 1);
 
1404
ok (mpf(-1) + 1 == 0);
 
1405
ok (1 + mpf(0) == 1);
 
1406
ok (1 + mpf(-1) == 0);
 
1407
 
 
1408
#------------------------------------------------------------------------------
 
1409
# GMP::Mpf::overload_addeq
 
1410
 
 
1411
{ my $a = mpf(7); $a += 1; ok ($a == 8); }
 
1412
{ my $a = mpf(7); my $b = $a; $a += 1; ok ($a == 8); ok ($b == 7); }
 
1413
 
 
1414
#------------------------------------------------------------------------------
 
1415
# GMP::Mpf::overload_bool
 
1416
 
 
1417
if (mpf(0))   { ok (0); } else { ok (1); }
 
1418
if (mpf(123)) { ok (1); } else { ok (0); }
 
1419
 
 
1420
#------------------------------------------------------------------------------
 
1421
# GMP::Mpf::overload_dec
 
1422
 
 
1423
{ my $a = mpf(0); ok ($a-- == 0); ok ($a == -1); }
 
1424
{ my $a = mpf(0); ok (--$a == -1); }
 
1425
 
 
1426
{ my $a = mpf(0); my $b = $a; $a--; ok ($a == -1); ok ($b == 0); }
 
1427
 
 
1428
#------------------------------------------------------------------------------
 
1429
# GMP::Mpf::overload_div
 
1430
 
 
1431
ok (mpf(6) / 2 == 3);
 
1432
ok (mpf(-6) / 2 == -3);
 
1433
ok (mpf(6) / -2 == -3);
 
1434
ok (mpf(-6) / -2 == 3);
 
1435
 
 
1436
#------------------------------------------------------------------------------
 
1437
# GMP::Mpf::overload_diveq
 
1438
 
 
1439
{ my $a = mpf(21); $a /= 3; ok ($a == 7); }
 
1440
{ my $a = mpf(21); my $b = $a; $a /= 3; ok ($a == 7); ok ($b == 21); }
 
1441
 
 
1442
#------------------------------------------------------------------------------
 
1443
# GMP::Mpf::overload_eq
 
1444
 
 
1445
{ my $a = mpf(0);
 
1446
  my $b = $a;
 
1447
  $a = mpf(1);
 
1448
  ok ($a == 1);
 
1449
  ok ($b == 0); }
 
1450
 
 
1451
#------------------------------------------------------------------------------
 
1452
# GMP::Mpf::overload_inc
 
1453
 
 
1454
{ my $a = mpf(0); ok ($a++ == 0); ok ($a == 1); }
 
1455
{ my $a = mpf(0); ok (++$a == 1); }
 
1456
 
 
1457
{ my $a = mpf(0); my $b = $a; $a++; ok ($a == 1); ok ($b == 0); }
 
1458
 
 
1459
#------------------------------------------------------------------------------
 
1460
# GMP::Mpf::overload_lshift
 
1461
 
 
1462
{ my $a = mpf(7) << 1; ok ($a == 14); }
 
1463
 
 
1464
#------------------------------------------------------------------------------
 
1465
# GMP::Mpf::overload_lshifteq
 
1466
 
 
1467
{ my $a = mpf(7); $a <<= 1; ok ($a == 14); }
 
1468
{ my $a = mpf(7); my $b = $a; $a <<= 1; ok ($a == 14); ok ($b == 7); }
 
1469
 
 
1470
#------------------------------------------------------------------------------
 
1471
# GMP::Mpf::overload_mul
 
1472
 
 
1473
ok (mpf(2) * 3 == 6);
 
1474
 
 
1475
#------------------------------------------------------------------------------
 
1476
# GMP::Mpf::overload_muleq
 
1477
 
 
1478
{ my $a = mpf(7); $a *= 3;  ok ($a == 21); }
 
1479
{ my $a = mpf(7); my $b = $a; $a *= 3;  ok ($a == 21); ok ($b == 7); }
 
1480
 
 
1481
#------------------------------------------------------------------------------
 
1482
# GMP::Mpf::overload_neg
 
1483
 
 
1484
ok (- mpf(0) == 0);
 
1485
ok (- mpf(123) == -123);
 
1486
ok (- mpf(-123) == 123);
 
1487
 
 
1488
#------------------------------------------------------------------------------
 
1489
# GMP::Mpf::overload_not
 
1490
 
 
1491
if (not mpf(0))   { ok (1); } else { ok (0); }
 
1492
if (not mpf(123)) { ok (0); } else { ok (1); }
 
1493
 
 
1494
ok ((! mpf(0)) == 1);
 
1495
ok ((! mpf(123)) == 0);
 
1496
 
 
1497
#------------------------------------------------------------------------------
 
1498
# GMP::Mpf::overload_pow
 
1499
 
 
1500
ok (mpf(0) ** 1 == 0);
 
1501
ok (mpf(1) ** 1 == 1);
 
1502
ok (mpf(2) ** 0 == 1);
 
1503
ok (mpf(2) ** 1 == 2);
 
1504
ok (mpf(2) ** 2 == 4);
 
1505
ok (mpf(2) ** 3 == 8);
 
1506
ok (mpf(2) ** 4 == 16);
 
1507
 
 
1508
ok (mpf(0) ** mpf(1) == 0);
 
1509
ok (mpf(1) ** mpf(1) == 1);
 
1510
ok (mpf(2) ** mpf(0) == 1);
 
1511
ok (mpf(2) ** mpf(1) == 2);
 
1512
ok (mpf(2) ** mpf(2) == 4);
 
1513
ok (mpf(2) ** mpf(3) == 8);
 
1514
ok (mpf(2) ** mpf(4) == 16);
 
1515
 
 
1516
#------------------------------------------------------------------------------
 
1517
# GMP::Mpf::overload_poweq
 
1518
 
 
1519
{ my $a = mpf(3); $a **= 4; ok ($a == 81); }
 
1520
{ my $a = mpf(3); my $b = $a; $a **= 4; ok ($a == 81); ok ($b == 3); }
 
1521
 
 
1522
#------------------------------------------------------------------------------
 
1523
# GMP::Mpf::overload_rshift
 
1524
 
 
1525
{ my $a = mpf(32) >> 1; ok ($a == 16); }
 
1526
 
 
1527
#------------------------------------------------------------------------------
 
1528
# GMP::Mpf::overload_rshifteq
 
1529
 
 
1530
{ my $a = mpf(32); $a >>= 1; ok ($a == 16); }
 
1531
{ my $a = mpf(32); my $b = $a; $a >>= 1; ok ($a == 16); ok ($b == 32); }
 
1532
 
 
1533
#------------------------------------------------------------------------------
 
1534
# GMP::Mpf::overload_sqrt
 
1535
 
 
1536
ok (sqrt(mpf(0)) == 0);
 
1537
ok (sqrt(mpf(1)) == 1);
 
1538
ok (sqrt(mpf(4)) == 2);
 
1539
ok (sqrt(mpf(81)) == 9);
 
1540
 
 
1541
ok (sqrt(mpf(0.25)) == 0.5);
 
1542
 
 
1543
#------------------------------------------------------------------------------
 
1544
# GMP::Mpf::overload_spaceship
 
1545
 
 
1546
ok (mpf(0) < 1);
 
1547
ok (mpf(0) > -1);
 
1548
 
 
1549
ok (mpf(0) != 1);
 
1550
ok (mpf(0) != -1);
 
1551
ok (mpf(1) != 0);
 
1552
ok (mpf(1) != -1);
 
1553
ok (mpf(-1) != 0);
 
1554
ok (mpf(-1) != 1);
 
1555
 
 
1556
ok (mpf(0) < 1.0);
 
1557
ok (mpf(0) < '1');
 
1558
ok (mpf(0) < substr('-1',1,1));
 
1559
ok (mpf(0) < mpz(1));
 
1560
ok (mpf(0) < mpq(1));
 
1561
ok (mpf(0) < mpf(1));
 
1562
ok (mpf(0) < $uv_max);
 
1563
 
 
1564
#------------------------------------------------------------------------------
 
1565
# GMP::Mpf::overload_string
 
1566
 
 
1567
{ my $x = mpf(0);    ok ("$x" eq "0"); }
 
1568
{ my $x = mpf(123);  ok ("$x" eq "123"); }
 
1569
{ my $x = mpf(-123); ok ("$x" eq "-123"); }
 
1570
 
 
1571
{ my $f = mpf(0.25);     ok ("$f" eq "0.25"); }
 
1572
{ my $f = mpf(-0.25);    ok ("$f" eq "-0.25"); }
 
1573
{ my $f = mpf(1.25);     ok ("$f" eq "1.25"); }
 
1574
{ my $f = mpf(-1.25);    ok ("$f" eq "-1.25"); }
 
1575
{ my $f = mpf(1000000);  ok ("$f" eq "1000000"); }
 
1576
{ my $f = mpf(-1000000); ok ("$f" eq "-1000000"); }
 
1577
 
 
1578
#------------------------------------------------------------------------------
 
1579
# GMP::Mpf::overload_sub
 
1580
 
 
1581
ok (mpf(0) - 1 == -1);
 
1582
ok (mpf(1) - 1 == 0);
 
1583
ok (1 - mpf(0) == 1);
 
1584
ok (1 - mpf(1) == 0);
 
1585
 
 
1586
#------------------------------------------------------------------------------
 
1587
# GMP::Mpf::overload_subeq
 
1588
 
 
1589
{ my $a = mpf(7); $a -= 1; ok ($a == 6); }
 
1590
{ my $a = mpf(7); my $b = $a; $a -= 1; ok ($a == 6); ok ($b == 7); }
 
1591
 
 
1592
 
 
1593
#------------------------------------------------------------------------------
 
1594
# GMP::Mpf::ceil
 
1595
 
 
1596
ok (ceil (mpf(-7.5)) == -7.0);
 
1597
ok (ceil (mpf(7.5)) == 8.0);
 
1598
 
 
1599
#------------------------------------------------------------------------------
 
1600
# GMP::Mpf::floor
 
1601
 
 
1602
ok (floor(mpf(-7.5)) == -8.0);
 
1603
ok (floor(mpf(7.5)) == 7.0);
 
1604
 
 
1605
#------------------------------------------------------------------------------
 
1606
# GMP::Mpf::mpf_eq
 
1607
 
 
1608
{ my $old_prec = get_default_prec();
 
1609
  set_default_prec(128);
 
1610
 
 
1611
  ok (  mpf_eq (mpz("0x10000000000000001"), mpz("0x10000000000000002"), 1));
 
1612
  ok (! mpf_eq (mpz("0x11"), mpz("0x12"), 128));
 
1613
 
 
1614
  set_default_prec($old_prec);
 
1615
}
 
1616
 
 
1617
#------------------------------------------------------------------------------
 
1618
# GMP::Mpf::get_default_prec
 
1619
 
 
1620
get_default_prec();
 
1621
 
 
1622
#------------------------------------------------------------------------------
 
1623
# GMP::Mpf::get_prec
 
1624
 
 
1625
{ my $x = mpf(1.0, 512);
 
1626
  ok (get_prec ($x) == 512);
 
1627
}
 
1628
 
 
1629
#------------------------------------------------------------------------------
 
1630
# GMP::Mpf::reldiff
 
1631
 
 
1632
ok (reldiff (2,4) == 1);
 
1633
ok (reldiff (4,2) == 0.5);
 
1634
 
 
1635
#------------------------------------------------------------------------------
 
1636
# GMP::Mpf::set_default_prec
 
1637
 
 
1638
{ my $old_prec = get_default_prec();
 
1639
 
 
1640
  set_default_prec(512);
 
1641
  ok (get_default_prec () == 512);
 
1642
 
 
1643
  set_default_prec($old_prec);
 
1644
}
 
1645
 
 
1646
#------------------------------------------------------------------------------
 
1647
# GMP::Mpf::set_prec
 
1648
 
 
1649
{ my $x = mpf(1.0, 512);
 
1650
  my $y = $x;
 
1651
  set_prec ($x, 1024);
 
1652
  ok (get_prec ($x) == 1024);
 
1653
  ok (get_prec ($y) == 512);
 
1654
}
 
1655
 
 
1656
#------------------------------------------------------------------------------
 
1657
# GMP::Mpf::trunc
 
1658
 
 
1659
ok (trunc(mpf(-7.5)) == -7.0);
 
1660
ok (trunc(mpf(7.5)) == 7.0);
 
1661
 
 
1662
 
 
1663
 
 
1664
#------------------------------------------------------------------------------
 
1665
# GMP::Rand
 
1666
 
 
1667
#------------------------------------------------------------------------------
 
1668
# GMP::Rand::new
 
1669
 
 
1670
{ my $r = randstate();                          ok (defined $r); }
 
1671
{ my $r = randstate('lc_2exp', 1, 2, 3);        ok (defined $r); }
 
1672
{ my $r = randstate('lc_2exp_size', 64);        ok (defined $r); }
 
1673
{ my $r = randstate('lc_2exp_size', 999999999); ok (! defined $r); }
 
1674
 
 
1675
#------------------------------------------------------------------------------
 
1676
# GMP::Rand::seed
 
1677
 
 
1678
{ my $r = randstate();
 
1679
  $r->seed(123);
 
1680
  $r->seed(time());
 
1681
}
 
1682
 
 
1683
#------------------------------------------------------------------------------
 
1684
# GMP::Rand::mpf_urandomb
 
1685
 
 
1686
{ my $r = randstate();
 
1687
  my $f = mpf_urandomb($r,1024);
 
1688
  ok (UNIVERSAL::isa($f,"GMP::Mpf")); }
 
1689
 
 
1690
#------------------------------------------------------------------------------
 
1691
# GMP::Rand::mpz_urandomb
 
1692
 
 
1693
{ my $r = randstate();
 
1694
  my $z = mpz_urandomb($r, 1024);
 
1695
  ok (UNIVERSAL::isa($z,"GMP::Mpz")); }
 
1696
 
 
1697
#------------------------------------------------------------------------------
 
1698
# GMP::Rand::mpz_rrandomb
 
1699
 
 
1700
{ my $r = randstate();
 
1701
  my $z = mpz_rrandomb($r, 1024);
 
1702
  ok (UNIVERSAL::isa($z,"GMP::Mpz")); }
 
1703
 
 
1704
#------------------------------------------------------------------------------
 
1705
# GMP::Rand::mpz_urandomm
 
1706
 
 
1707
{ my $r = randstate();
 
1708
  my $z = mpz_urandomm($r, mpz(3)**100);
 
1709
  ok (UNIVERSAL::isa($z,"GMP::Mpz")); }
 
1710
  
 
1711
 
 
1712
 
 
1713
 
 
1714
#------------------------------------------------------------------------------
 
1715
# GMP module
 
1716
 
 
1717
#------------------------------------------------------------------------------
 
1718
# GMP::fits_slong_p
 
1719
 
 
1720
ok (GMP::fits_slong_p(0));
 
1721
 
 
1722
# in perl 5.005 uv_max is only 32-bits on a 64-bit system, so won't exceed a
 
1723
# long
 
1724
# ok (! GMP::fits_slong_p($uv_max));
 
1725
 
 
1726
ok (GMP::fits_slong_p(0.0));
 
1727
 
 
1728
ok (GMP::fits_slong_p('0'));
 
1729
 
 
1730
ok (GMP::fits_slong_p(substr('999999999999999999999999999999',1,1)));
 
1731
 
 
1732
ok (! mpz("-9999999999999999999999999999999999999999999")->fits_slong_p());
 
1733
ok (  mpz(-123)->fits_slong_p());
 
1734
ok (  mpz(0)->fits_slong_p());
 
1735
ok (  mpz(123)->fits_slong_p());
 
1736
ok (! mpz("9999999999999999999999999999999999999999999")->fits_slong_p());
 
1737
 
 
1738
ok (! mpq("-9999999999999999999999999999999999999999999")->fits_slong_p());
 
1739
ok (  mpq(-123)->fits_slong_p());
 
1740
ok (  mpq(0)->fits_slong_p());
 
1741
ok (  mpq(123)->fits_slong_p());
 
1742
ok (! mpq("9999999999999999999999999999999999999999999")->fits_slong_p());
 
1743
 
 
1744
ok (! mpf("-9999999999999999999999999999999999999999999")->fits_slong_p());
 
1745
ok (  mpf(-123)->fits_slong_p());
 
1746
ok (  mpf(0)->fits_slong_p());
 
1747
ok (  mpf(123)->fits_slong_p());
 
1748
ok (! mpf("9999999999999999999999999999999999999999999")->fits_slong_p());
 
1749
 
 
1750
#------------------------------------------------------------------------------
 
1751
# GMP::get_d
 
1752
 
 
1753
ok (GMP::get_d(123) == 123.0);
 
1754
 
 
1755
ok (GMP::get_d($uv_max) > 0);
 
1756
 
 
1757
ok (GMP::get_d(123.0) == 123.0);
 
1758
 
 
1759
ok (GMP::get_d('123') == 123.0);
 
1760
 
 
1761
ok (GMP::get_d(mpz(123)) == 123.0);
 
1762
 
 
1763
ok (GMP::get_d(mpq(123)) == 123.0);
 
1764
 
 
1765
ok (GMP::get_d(mpf(123)) == 123.0);
 
1766
 
 
1767
#------------------------------------------------------------------------------
 
1768
# GMP::get_d_2exp
 
1769
 
 
1770
{ my ($dbl, $exp) = get_d_2exp (0);
 
1771
  ok ($dbl == 0); ok ($exp == 0); }
 
1772
{ my ($dbl, $exp) = get_d_2exp (1);
 
1773
  ok ($dbl == 0.5); ok ($exp == 1); }
 
1774
 
 
1775
{ my ($dbl, $exp) = get_d_2exp ($uv_max);
 
1776
  ok ($dbl > 0.0); ok ($exp > 0); }
 
1777
 
 
1778
{ my ($dbl, $exp) = get_d_2exp (0.5);
 
1779
  ok ($dbl == 0.5); ok ($exp == 0); }
 
1780
{ my ($dbl, $exp) = get_d_2exp (0.25);
 
1781
  ok ($dbl == 0.5); ok ($exp == -1); }
 
1782
 
 
1783
{ my ($dbl, $exp) = get_d_2exp ("1.0");
 
1784
  ok ($dbl == 0.5); ok ($exp == 1); }
 
1785
 
 
1786
{ my ($dbl, $exp) = get_d_2exp (mpz ("256"));
 
1787
  ok ($dbl == 0.5); ok ($exp == 9); }
 
1788
 
 
1789
{ my ($dbl, $exp) = get_d_2exp (mpq ("1/16"));
 
1790
  ok ($dbl == 0.5); ok ($exp == -3); }
 
1791
 
 
1792
{ my ($dbl, $exp) = get_d_2exp (mpf ("1.5"));
 
1793
  ok ($dbl == 0.75); ok ($exp == 1); }
 
1794
{ my ($dbl, $exp) = get_d_2exp (mpf ("3.0"));
 
1795
  ok ($dbl == 0.75); ok ($exp == 2); }
 
1796
 
 
1797
#------------------------------------------------------------------------------
 
1798
# GMP::get_str
 
1799
 
 
1800
ok (get_str(-123) eq '-123');
 
1801
ok (get_str('-123') eq '-123');
 
1802
ok (get_str(substr('x-123x',1,4)) eq '-123');
 
1803
ok (get_str(mpz(-123)) eq '-123');
 
1804
ok (get_str(mpq(-123)) eq '-123');
 
1805
 
 
1806
ok (get_str(-123,10) eq '-123');
 
1807
ok (get_str('-123',10) eq '-123');
 
1808
ok (get_str(substr('x-123x',1,4),10) eq '-123');
 
1809
ok (get_str(mpz(-123),10) eq '-123');
 
1810
ok (get_str(mpq(-123),10) eq '-123');
 
1811
 
 
1812
ok (get_str(-123,16) eq '-7b');
 
1813
ok (get_str('-123',16) eq '-7b');
 
1814
ok (get_str(substr('x-123x',1,4),16) eq '-7b');
 
1815
ok (get_str(mpz(-123),16) eq '-7b');
 
1816
ok (get_str(mpq(-123),16) eq '-7b');
 
1817
 
 
1818
ok (get_str(-123,-16) eq '-7B');
 
1819
ok (get_str('-123',-16) eq '-7B');
 
1820
ok (get_str(substr('x-123x',1,4),-16) eq '-7B');
 
1821
ok (get_str(mpz(-123),-16) eq '-7B');
 
1822
ok (get_str(mpq(-123),-16) eq '-7B');
 
1823
 
 
1824
# is a float in past versions of perl without UV type
 
1825
{ my ($str, $exp) = get_str($uv_max);
 
1826
  ok ($str eq $uv_max_str); }
 
1827
 
 
1828
ok (get_str(mpq(5/8)) eq "5/8");
 
1829
ok (get_str(mpq(-5/8)) eq "-5/8");
 
1830
ok (get_str(mpq(255/256),16) eq "ff/100");
 
1831
ok (get_str(mpq(255/256),-16) eq "FF/100");
 
1832
ok (get_str(mpq(-255/256),16) eq "-ff/100");
 
1833
ok (get_str(mpq(-255/256),-16) eq "-FF/100");
 
1834
 
 
1835
{ my ($s,$e) = get_str(1.5, 10);      ok ($s eq '15'); ok ($e == 1); }
 
1836
{ my ($s,$e) = get_str(mpf(1.5), 10); ok ($s eq '15'); ok ($e == 1); }
 
1837
 
 
1838
{ my ($s,$e) = get_str(-1.5, 10);      ok ($s eq '-15'); ok ($e == 1); }
 
1839
{ my ($s,$e) = get_str(mpf(-1.5), 10); ok ($s eq '-15'); ok ($e == 1); }
 
1840
 
 
1841
{ my ($s,$e) = get_str(1.5, 16);      ok ($s eq '18'); ok ($e == 1); }
 
1842
{ my ($s,$e) = get_str(mpf(1.5), 16); ok ($s eq '18'); ok ($e == 1); }
 
1843
 
 
1844
{ my ($s,$e) = get_str(-1.5, 16);      ok ($s eq '-18'); ok ($e == 1); }
 
1845
{ my ($s,$e) = get_str(mpf(-1.5), 16); ok ($s eq '-18'); ok ($e == 1); }
 
1846
 
 
1847
{ my ($s,$e) = get_str(65536.0, 16);      ok ($s eq '1'); ok ($e == 5); }
 
1848
{ my ($s,$e) = get_str(mpf(65536.0), 16); ok ($s eq '1'); ok ($e == 5); }
 
1849
 
 
1850
{ my ($s,$e) = get_str(1.625, 16);      ok ($s eq '1a'); ok ($e == 1); }
 
1851
{ my ($s,$e) = get_str(mpf(1.625), 16); ok ($s eq '1a'); ok ($e == 1); }
 
1852
 
 
1853
{ my ($s,$e) = get_str(1.625, -16);      ok ($s eq '1A'); ok ($e == 1); }
 
1854
{ my ($s,$e) = get_str(mpf(1.625), -16); ok ($s eq '1A'); ok ($e == 1); }
 
1855
 
 
1856
{ my ($s, $e) = get_str(255.0,16,0);      ok ($s eq "ff"); ok ($e == 2); }
 
1857
{ my ($s, $e) = get_str(mpf(255.0),16,0); ok ($s eq "ff"); ok ($e == 2); }
 
1858
 
 
1859
{ my ($s, $e) = get_str(255.0,-16,0);      ok ($s eq "FF"); ok ($e == 2); }
 
1860
{ my ($s, $e) = get_str(mpf(255.0),-16,0); ok ($s eq "FF"); ok ($e == 2); }
 
1861
 
 
1862
#------------------------------------------------------------------------------
 
1863
# GMP::get_si
 
1864
 
 
1865
ok (GMP::get_si(123) == 123.0);
 
1866
 
 
1867
# better not assume anything about the relatives sizes of long and UV
 
1868
ok (GMP::get_si($uv_max) != 0);
 
1869
 
 
1870
ok (GMP::get_si(123.0) == 123.0);
 
1871
 
 
1872
ok (GMP::get_si('123') == 123.0);
 
1873
 
 
1874
ok (GMP::get_si(mpz(123)) == 123.0);
 
1875
 
 
1876
ok (GMP::get_si(mpq(123)) == 123.0);
 
1877
 
 
1878
ok (GMP::get_si(mpf(123)) == 123.0);
 
1879
 
 
1880
#------------------------------------------------------------------------------
 
1881
# GMP::integer_p
 
1882
 
 
1883
ok (  GMP::integer_p (0));
 
1884
ok (  GMP::integer_p (123));
 
1885
ok (  GMP::integer_p (-123));
 
1886
 
 
1887
ok (  GMP::integer_p ($uv_max));
 
1888
 
 
1889
ok (  GMP::integer_p (0.0));
 
1890
ok (  GMP::integer_p (123.0));
 
1891
ok (  GMP::integer_p (-123.0));
 
1892
ok (! GMP::integer_p (0.5));
 
1893
ok (! GMP::integer_p (123.5));
 
1894
ok (! GMP::integer_p (-123.5));
 
1895
 
 
1896
ok (  GMP::integer_p ('0'));
 
1897
ok (  GMP::integer_p ('123'));
 
1898
ok (  GMP::integer_p ('-123'));
 
1899
ok (! GMP::integer_p ('0.5'));
 
1900
ok (! GMP::integer_p ('123.5'));
 
1901
ok (! GMP::integer_p ('-123.5'));
 
1902
ok (! GMP::integer_p ('5/8'));
 
1903
 
 
1904
ok (  GMP::integer_p (mpz(1)));
 
1905
 
 
1906
ok (  GMP::integer_p (mpq(1)));
 
1907
ok (! GMP::integer_p (mpq(1,2)));
 
1908
 
 
1909
ok (  GMP::integer_p (mpf(1.0)));
 
1910
ok (! GMP::integer_p (mpf(1.5)));
 
1911
 
 
1912
#------------------------------------------------------------------------------
 
1913
# GMP::odd_p
 
1914
 
 
1915
ok (! odd_p(0));
 
1916
ok (  odd_p(1));
 
1917
ok (! odd_p(2));
 
1918
 
 
1919
ok (  odd_p($uv_max));
 
1920
 
 
1921
ok (  odd_p(mpz(-3)));
 
1922
ok (! odd_p(mpz(-2)));
 
1923
ok (  odd_p(mpz(-1)));
 
1924
ok (! odd_p(mpz(0)));
 
1925
ok (  odd_p(mpz(1)));
 
1926
ok (! odd_p(mpz(2)));
 
1927
ok (  odd_p(mpz(3)));
 
1928
 
 
1929
#------------------------------------------------------------------------------
 
1930
# GMP::printf
 
1931
 
 
1932
GMP::printf ("hello world\n");
 
1933
 
 
1934
sub via_printf {
 
1935
  my $s;
 
1936
  open TEMP, ">test.tmp" or die;
 
1937
  GMP::printf TEMP @_;
 
1938
  close TEMP or die;
 
1939
  open TEMP, "<test.tmp" or die;
 
1940
  read (TEMP, $s, 1024);
 
1941
  close TEMP or die;
 
1942
  unlink 'test.tmp';
 
1943
  return $s;
 
1944
}
 
1945
 
 
1946
ok (sprintf ("%d", mpz(123)) eq '123');
 
1947
ok (sprintf ("%d %d %d", 456, mpz(123), 789) eq '456 123 789');
 
1948
ok (sprintf ("%d", mpq(15,16)) eq '15/16');
 
1949
ok (sprintf ("%f", mpf(1.5)) eq '1.500000');
 
1950
ok (sprintf ("%.2f", mpf(1.5)) eq '1.50');
 
1951
 
 
1952
ok (sprintf ("%*d", 6, 123) eq '   123');
 
1953
ok (sprintf ("%*d", 6, mpz(123))  eq '   123');
 
1954
ok (sprintf ("%*d", 6, mpq(15,16))  eq ' 15/16');
 
1955
 
 
1956
ok (sprintf ("%x", 123) eq '7b');
 
1957
ok (sprintf ("%x", mpz(123))  eq '7b');
 
1958
ok (sprintf ("%X", 123) eq '7B');
 
1959
ok (sprintf ("%X", mpz(123))  eq '7B');
 
1960
ok (sprintf ("%#x", 123) eq '0x7b');
 
1961
ok (sprintf ("%#x", mpz(123))  eq '0x7b');
 
1962
ok (sprintf ("%#X", 123) eq '0X7B');
 
1963
ok (sprintf ("%#X", mpz(123))  eq '0X7B');
 
1964
 
 
1965
ok (sprintf ("%x", mpq(15,16))  eq 'f/10');
 
1966
ok (sprintf ("%X", mpq(15,16))  eq 'F/10');
 
1967
ok (sprintf ("%#x", mpq(15,16))  eq '0xf/0x10');
 
1968
ok (sprintf ("%#X", mpq(15,16))  eq '0XF/0X10');
 
1969
 
 
1970
ok (sprintf ("%*.*f", 10, 3, 1.25) eq '     1.250');
 
1971
ok (sprintf ("%*.*f", 10, 3, mpf(1.5))   eq '     1.500');
 
1972
 
 
1973
ok (via_printf ("%d", mpz(123)) eq '123');
 
1974
ok (via_printf ("%d %d %d", 456, mpz(123), 789) eq '456 123 789');
 
1975
ok (via_printf ("%d", mpq(15,16)) eq '15/16');
 
1976
ok (via_printf ("%f", mpf(1.5)) eq '1.500000');
 
1977
ok (via_printf ("%.2f", mpf(1.5)) eq '1.50');
 
1978
 
 
1979
ok (via_printf ("%*d", 6, 123) eq '   123');
 
1980
ok (via_printf ("%*d", 6, mpz(123))  eq '   123');
 
1981
ok (via_printf ("%*d", 6, mpq(15,16))  eq ' 15/16');
 
1982
 
 
1983
ok (via_printf ("%x", 123) eq '7b');
 
1984
ok (via_printf ("%x", mpz(123))  eq '7b');
 
1985
ok (via_printf ("%X", 123) eq '7B');
 
1986
ok (via_printf ("%X", mpz(123))  eq '7B');
 
1987
ok (via_printf ("%#x", 123) eq '0x7b');
 
1988
ok (via_printf ("%#x", mpz(123))  eq '0x7b');
 
1989
ok (via_printf ("%#X", 123) eq '0X7B');
 
1990
ok (via_printf ("%#X", mpz(123))  eq '0X7B');
 
1991
 
 
1992
ok (via_printf ("%x", mpq(15,16))  eq 'f/10');
 
1993
ok (via_printf ("%X", mpq(15,16))  eq 'F/10');
 
1994
ok (via_printf ("%#x", mpq(15,16))  eq '0xf/0x10');
 
1995
ok (via_printf ("%#X", mpq(15,16))  eq '0XF/0X10');
 
1996
 
 
1997
ok (via_printf ("%*.*f", 10, 3, 1.25) eq '     1.250');
 
1998
ok (via_printf ("%*.*f", 10, 3, mpf(1.5))   eq '     1.500');
 
1999
 
 
2000
#------------------------------------------------------------------------------
 
2001
# GMP::sgn
 
2002
 
 
2003
ok (sgn(-123) == -1);
 
2004
ok (sgn(0)    == 0);
 
2005
ok (sgn(123)  == 1);
 
2006
 
 
2007
ok (sgn($uv_max) == 1);
 
2008
 
 
2009
ok (sgn(-123.0) == -1);
 
2010
ok (sgn(0.0)    == 0);
 
2011
ok (sgn(123.0)  == 1);
 
2012
 
 
2013
ok (sgn('-123') == -1);
 
2014
ok (sgn('0')    == 0);
 
2015
ok (sgn('123')  == 1);
 
2016
ok (sgn('-123.0') == -1);
 
2017
ok (sgn('0.0')    == 0);
 
2018
ok (sgn('123.0')  == 1);
 
2019
 
 
2020
ok (sgn(substr('x-123x',1,4)) == -1);
 
2021
ok (sgn(substr('x0x',1,1))    == 0);
 
2022
ok (sgn(substr('x123x',1,3))  == 1);
 
2023
 
 
2024
ok (mpz(-123)->sgn() == -1);
 
2025
ok (mpz(0)   ->sgn() == 0);
 
2026
ok (mpz(123) ->sgn() == 1);
 
2027
 
 
2028
ok (mpq(-123)->sgn() == -1);
 
2029
ok (mpq(0)   ->sgn() == 0);
 
2030
ok (mpq(123) ->sgn() == 1);
 
2031
 
 
2032
ok (mpf(-123)->sgn() == -1);
 
2033
ok (mpf(0)   ->sgn() == 0);
 
2034
ok (mpf(123) ->sgn() == 1);
 
2035
 
 
2036
 
 
2037
 
 
2038
#------------------------------------------------------------------------------
 
2039
# overloaded constants
 
2040
 
 
2041
if ($] > 5.00503) {
 
2042
  if (! do 'test2.pl') {
 
2043
    die "Cannot run test2.pl\n";
 
2044
  }
 
2045
}
 
2046
 
 
2047
 
 
2048
 
 
2049
 
 
2050
#------------------------------------------------------------------------------
 
2051
# $# stuff
 
2052
#
 
2053
# For some reason "local $#" doesn't leave $# back at its default undefined
 
2054
# state when exiting the block.
 
2055
 
 
2056
{ local $# = 'hi %.0f there';
 
2057
  my $f = mpf(123);
 
2058
  ok ("$f" eq 'hi 123 there'); }
 
2059
 
 
2060
 
 
2061
 
 
2062
# Local variables:
 
2063
# perl-indent-level: 2
 
2064
# End: