1 # GMP perl module 2 3 # Copyright 2001-2004 Free Software Foundation, Inc. 4 # 5 # This file is part of the GNU MP Library. 6 # 7 # The GNU MP Library is free software; you can redistribute it and/or modify 8 # it under the terms of either: 9 # 10 # * the GNU Lesser General Public License as published by the Free 11 # Software Foundation; either version 3 of the License, or (at your 12 # option) any later version. 13 # 14 # or 15 # 16 # * the GNU General Public License as published by the Free Software 17 # Foundation; either version 2 of the License, or (at your option) any 18 # later version. 19 # 20 # or both in parallel, as here. 21 # 22 # The GNU MP Library is distributed in the hope that it will be useful, but 23 # WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY 24 # or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 25 # for more details. 26 # 27 # You should have received copies of the GNU General Public License and the 28 # GNU Lesser General Public License along with the GNU MP Library. If not, 29 # see https://www.gnu.org/licenses/. 30 31 # [Note: The above copyright notice is repeated in the documentation section 32 # below, in order to get it into man pages etc generated by the various pod 33 # conversions. When changing, be sure to update below too.] 34 35 36 # This code is designed to work with perl 5.005, so it and the sub-packages 37 # aren't as modern as they could be. 38 39 package GMP; 40 41 require Symbol; 42 require Exporter; 43 require DynaLoader; 44 @ISA = qw(Exporter DynaLoader); 45 46 @EXPORT = qw(); 47 @EXPORT_OK = qw(version); 48 %EXPORT_TAGS = ('all' => [qw( 49 get_d get_d_2exp get_si get_str integer_p 50 printf sgn sprintf)], 51 'constants' => [()]); 52 Exporter::export_ok_tags('all'); 53 54 $VERSION = '2.00'; 55 bootstrap GMP $VERSION; 56 57 58 # The format string is cut up into "%" specifiers so GMP types can be 59 # passed to GMP::sprintf_internal. Any "*"s are interpolated before 60 # calling sprintf_internal, which saves worrying about variable 61 # argument lists there. 62 # 63 # Because sprintf_internal is only called after the conversion and 64 # operand have been checked there won't be any crashes from a bad 65 # format string. 66 # 67 sub sprintf { 68 my $fmt = shift; 69 my $out = ''; 70 my ($pre, $dummy, $pat, $rest); 71 72 while (($pre, $dummy, $pat, $rest) = ($fmt =~ /^((%%|[^%])*)(%[- +#.*hlLqv\d]*[bcdfeEgGinopsuxX])(.*)$/s)) { 73 74 $out .= $pre; 75 76 my $pat2 = $pat; # $pat with "*"s expanded 77 my @params = (); # arguments per "*"s 78 while ($pat2 =~ /[*]/) { 79 my $arg = shift; 80 $pat2 =~ s/[*]/$arg/; 81 push @params, $arg; 82 } 83 84 if (UNIVERSAL::isa($_[0],"GMP::Mpz")) { 85 if ($pat2 !~ /[dioxX]$/) { 86 die "GMP::sprintf: unsupported output format for mpz: $pat2\n"; 87 } 88 $pat2 =~ s/(.)$/Z$1/; 89 $out .= sprintf_internal ($pat2, shift); 90 91 } elsif (UNIVERSAL::isa($_[0],"GMP::Mpq")) { 92 if ($pat2 !~ /[dioxX]$/) { 93 die "GMP::sprintf: unsupported output format for mpq: $pat2\n"; 94 } 95 $pat2 =~ s/(.)$/Q$1/; 96 $out .= sprintf_internal ($pat2, shift); 97 98 } elsif (UNIVERSAL::isa($_[0],"GMP::Mpf")) { 99 if ($pat2 !~ /[eEfgG]$/) { 100 die "GMP::sprintf: unsupported output format for mpf: $pat2\n"; 101 } 102 $pat2 =~ s/(.)$/F$1/; 103 $out .= sprintf_internal ($pat2, shift); 104 105 } elsif ($pat =~ /n$/) { 106 # do it this way so h, l or V type modifiers are respected, and use a 107 # dummy variable to avoid a warning about discarding the value 108 my $dummy = sprintf "%s$pat", $out, $_[0]; 109 shift; 110 111 } else { 112 $out .= sprintf $pat, @params, shift; 113 } 114 115 $fmt = $rest; 116 } 117 $out .= $fmt; 118 return $out; 119 } 120 121 sub printf { 122 if (ref($_[0]) eq 'GLOB') { 123 my $h = Symbol::qualify_to_ref(shift, caller); 124 print $h GMP::sprintf(@_); 125 } else { 126 print STDOUT GMP::sprintf(@_); 127 } 128 } 129 130 1; 131 __END__ 132 133 134 135 =head1 NAME 136 137 GMP - Perl interface to the GNU Multiple Precision Arithmetic Library 138 139 =head1 SYNOPSIS 140 141 use GMP; 142 use GMP::Mpz; 143 use GMP::Mpq; 144 use GMP::Mpf; 145 use GMP::Rand; 146 147 =head1 DESCRIPTION 148 149 This module provides access to GNU MP arbitrary precision integers, 150 rationals and floating point. 151 152 No functions are exported from these packages by default, but can be 153 selected in the usual way, or the tag :all for everything. 154 155 use GMP::Mpz qw(gcd, lcm); # just these functions 156 use GMP::Mpq qw(:all); # everything in mpq 157 158 =head2 GMP::Mpz 159 160 This class provides arbitrary precision integers. A new mpz can be 161 constructed with C<mpz>. The initial value can be an integer, float, 162 string, mpz, mpq or mpf. Floats, mpq and mpf will be automatically 163 truncated to an integer. 164 165 use GMP::Mpz qw(:all); 166 my $a = mpz(123); 167 my $b = mpz("0xFFFF"); 168 my $c = mpz(1.5); # truncated 169 170 The following overloaded operators are available, and corresponding 171 assignment forms like C<+=>, 172 173 =over 4 174 175 =item 176 177 + - * / % E<lt>E<lt> E<gt>E<gt> ** & | ^ ! E<lt> E<lt>= == != E<gt> E<gt>= 178 E<lt>=E<gt> abs not sqrt 179 180 =back 181 182 C</> and C<%> round towards zero (as per the C<tdiv> functions in GMP). 183 184 The following functions are available, behaving the same as the 185 corresponding GMP mpz functions, 186 187 =over 4 188 189 =item 190 191 bin, cdiv, cdiv_2exp, clrbit, combit, congruent_p, congruent_2exp_p, 192 divexact, divisible_p, divisible_2exp_p, even_p, fac, fdiv, fdiv_2exp, fib, 193 fib2, gcd, gcdext, hamdist, invert, jacobi, kronecker, lcm, lucnum, lucnum2, 194 mod, mpz_export, mpz_import, nextprime, odd_p, perfect_power_p, 195 perfect_square_p, popcount, powm, probab_prime_p, realloc, remove, root, 196 roote, scan0, scan1, setbit, sizeinbase, sqrtrem, tdiv, tdiv_2exp, tstbit 197 198 =back 199 200 C<cdiv>, C<fdiv> and C<tdiv> and their C<2exp> variants return a 201 quotient/remainder pair. C<fib2> returns a pair F[n] and F[n-1], similarly 202 C<lucnum2>. C<gcd> and C<lcm> accept a variable number of arguments (one or 203 more). C<gcdext> returns a triplet of gcd and two cofactors, for example 204 205 use GMP::Mpz qw(:all); 206 $a = 7257; 207 $b = 10701; 208 ($g, $x, $y) = gcdext ($a, $b); 209 print "gcd($a,$b) is $g, and $g == $a*$x + $b*$y\n"; 210 211 C<mpz_import> and C<mpz_export> are so named to avoid the C<import> keyword. 212 Their parameters are as follows, 213 214 $z = mpz_import ($order, $size, $endian, $nails, $string); 215 $string = mpz_export ($order, $size, $endian, $nails, $z); 216 217 The order, size, endian and nails parameters are as per the corresponding C 218 functions. The string input for C<mpz_import> is interpreted as byte data 219 and must be a multiple of $size bytes. C<mpz_export> conversely returns a 220 string of byte data, which will be a multiple of $size bytes. 221 222 C<invert> returns the inverse, or undef if it doesn't exist. C<remove> 223 returns a remainder/multiplicity pair. C<root> returns the nth root, and 224 C<roote> returns a root/bool pair, the bool indicating whether the root is 225 exact. C<sqrtrem> and C<rootrem> return a root/remainder pair. 226 227 C<clrbit>, C<combit> and C<setbit> expect a variable which they can modify, 228 it doesn't make sense to pass a literal constant. Only the given variable 229 is modified, if other variables are referencing the same mpz object then a 230 new copy is made of it. If the variable isn't an mpz it will be coerced to 231 one. For instance, 232 233 use GMP::Mpz qw(setbit); 234 setbit (123, 0); # wrong, don't pass a constant 235 $a = mpz(6); 236 $b = $a; 237 setbit ($a, 0); # $a becomes 7, $b stays at 6 238 239 C<scan0> and C<scan1> return ~0 if no 0 or 1 bit respectively is found. 240 241 =head2 GMP::Mpq 242 243 This class provides rationals with arbitrary precision numerators and 244 denominators. A new mpq can be constructed with C<mpq>. The initial value 245 can be an integer, float, string, mpz, mpq or mpf, or a pair of integers or 246 mpz's. No precision is lost when converting a float or mpf, the exact value 247 is retained. 248 249 use GMP::Mpq qw(:all); 250 $a = mpq(); # zero 251 $b = mpq(0.5); # gives 1/2 252 $b = mpq(14); # integer 14 253 $b = mpq(3,4); # fraction 3/4 254 $b = mpq("7/12"); # fraction 7/12 255 $b = mpq("0xFF/0x100"); # fraction 255/256 256 257 When a fraction is given, it should be in the canonical form specified in 258 the GMP manual, which is denominator positive, no common factors, and zero 259 always represented as 0/1. If not then C<canonicalize> can be called to put 260 it in that form. For example, 261 262 use GMP::Mpq qw(:all); 263 $q = mpq(21,15); # eek! common factor 3 264 canonicalize($q); # get rid of it 265 266 The following overloaded operators are available, and corresponding 267 assignment forms like C<+=>, 268 269 =over 4 270 271 =item 272 273 + - * / E<lt>E<lt> E<gt>E<gt> ** ! E<lt> E<lt>= == != E<gt> E<gt>= 274 E<lt>=E<gt> abs not 275 276 =back 277 278 The following functions are available, 279 280 =over 4 281 282 =item 283 284 den, inv, num 285 286 =back 287 288 C<inv> calculates 1/q, as per the corresponding GMP function. C<num> and 289 C<den> return an mpz copy of the numerator or denominator respectively. In 290 the future C<num> and C<den> might give lvalues so the original mpq can be 291 modified through them, but this is not done currently. 292 293 =head2 GMP::Mpf 294 295 This class provides arbitrary precision floating point numbers. The 296 mantissa is an arbitrary user-selected precision and the exponent is a fixed 297 size (one machine word). 298 299 A new mpf can be constructed with C<mpf>. The initial value can be an 300 integer, float, string, mpz, mpq or mpf. The second argument specifies the 301 desired precision in bits, or if omitted then the default precision is used. 302 303 use GMP::Mpf qw(:all); 304 $a = mpf(); # zero 305 $b = mpf(-7.5); # default precision 306 $c = mpf(1.5, 500); # 500 bits precision 307 $d = mpf("1.0000000000000001"); 308 309 The following overloaded operators are available, with the corresponding 310 assignment forms like C<+=>, 311 312 =over 4 313 314 =item 315 316 + - * / E<lt>E<lt> E<gt>E<gt> ** ! E<lt> E<lt>= == != E<gt> E<gt>= 317 E<lt>=E<gt> abs not sqrt 318 319 =back 320 321 The following functions are available, behaving the same as the 322 corresponding GMP mpf functions, 323 324 =over 4 325 326 =item 327 328 ceil, floor, get_default_prec, get_prec, mpf_eq, set_default_prec, set_prec, 329 trunc 330 331 =back 332 333 C<mpf_eq> is so named to avoid clashing with the perl C<eq> operator. 334 335 C<set_prec> expects a variable which it can modify, it doesn't make sense to 336 pass a literal constant. Only the given variable is modified, if other 337 variables are referencing the same mpf object then a new copy is made of it. 338 If the variable isn't an mpf it will be coerced to one. 339 340 Results are the same precision as inputs, or if two mpf's are given to a 341 binary operator then the precision of the first is used. For example, 342 343 use GMP::Mpf qw(mpf); 344 $a = mpf(2.0, 100); 345 $b = mpf(2.0, 500); 346 $c = $a + $b; # gives 100 bits precision 347 348 Mpf to string conversion via "" or the usual string contexts uses C<$#> the 349 same as normal float to string conversions, or defaults to C<%.g> if C<$#> 350 is not defined. C<%.g> means all significant digits in the selected 351 precision. 352 353 =head2 GMP class 354 355 The following functions are available in the GMP class, 356 357 =over 4 358 359 =item 360 361 fits_slong_p, get_d, get_d_2exp, get_si, get_str, integer_p, printf, sgn, 362 sprintf, version 363 364 =back 365 366 C<get_d_2exp> accepts any integer, string, float, mpz, mpq or mpf operands 367 and returns a float and an integer exponent, 368 369 ($dbl, $exp) = get_d_2exp (mpf ("3.0")); 370 # dbl is 0.75, exp is 2 371 372 C<get_str> takes an optional second argument which is the base, defaulting 373 to decimal. A negative base means upper case, as per the C functions. For 374 integer, integer string, mpz or mpq operands a string is returned. 375 376 use GMP qw(:all); 377 use GMP::Mpq qw(:all); 378 print get_str(mpq(-5,8)),"\n"; # -5/8 379 print get_str(255,16),"\n"; # ff 380 381 For float, float strings or mpf operands, C<get_str> accepts an optional 382 third parameter being how many digits to produce, defaulting to 0 which 383 means all digits. (Only as many digits as can be accurately represented by 384 the float precision are ever produced though.) A string/exponent pair is 385 returned, as per the C mpf_get_str function. For example, 386 387 use GMP qw(:all); 388 use GMP::Mpf qw(:all); 389 ($s, $e) = get_str(111.111111111, 10, 4); 390 printf ".$se$e\n"; # .1111e3 391 ($s, $e) = get_str(1.625, 10); 392 print "0.$s*10^$e\n"; # 0.1625*10^1 393 ($s, $e) = get_str(mpf(2)**20, 16); 394 printf ".%s@%x\n", $s, $e; # .1@14 395 396 C<printf> and C<sprintf> allow formatted output of GMP types. mpz and mpq 397 values can be used with integer conversions (d, o, x, X) and mpf with float 398 conversions (f, e, E, g, G). All the standard perl printf features are 399 available too. For example, 400 401 use GMP::Mpz qw(mpz); 402 use GMP::Mpf qw(mpf); 403 GMP::printf ("%d %d %s", 123, mpz(2)**128, 'foo'); 404 GMP::printf STDERR "%.40f", mpf(1.234); 405 406 In perl 5.6.1 it doesn't seem to work to export C<printf>, the plain builtin 407 C<printf> is reached unless calls are C<&printf()> style. Explicit use of 408 C<GMP::printf> is suggested. C<sprintf> doesn't suffer this problem. 409 410 use GMP qw(sprintf); 411 use GMP::Mpq qw(mpq); 412 $s = sprintf "%x", mpq(15,16); 413 414 C<version> is not exported by default or by tag :all, calling it as 415 C<GMP::version()> is recommended. It returns the GMP library version 416 string, which is not to be confused with the module version number. 417 418 The other GMP module functions behave as per the corresponding GMP routines, 419 and accept any integer, string, float, mpz, mpq or mpf. For example, 420 421 use GMP qw(:all); 422 use GMP::Mpz qw(mpz); 423 $z = mpz(123); 424 print sgn($z); # gives 1 425 426 Because each of GMP::Mpz, GMP::Mpq and GMP::Mpf is a sub-class of GMP, 427 C<-E<gt>> style calls work too. 428 429 use GMP qw(:all); 430 use GMP::Mpq qw(mpf); 431 $q = mpq(-5,7); 432 if ($q->integer_p()) # false 433 ... 434 435 =head2 GMP::Rand 436 437 This class provides objects holding an algorithm and state for random number 438 generation. C<randstate> creates a new object, for example, 439 440 use GMP::Rand qw(randstate); 441 $r = randstate(); 442 $r = randstate('lc_2exp_size', 64); 443 $r = randstate('lc_2exp', 43840821, 1, 32); 444 $r = randstate('mt'); 445 $r = randstate($another_r); 446 447 With no parameters this corresponds to the C function 448 C<gmp_randinit_default>, and is a compromise between speed and randomness. 449 'lc_2exp_size' corresponds to C<gmp_randinit_lc_2exp_size>, 'lc_2exp' 450 corresponds to C<gmp_randinit_lc_2exp>, and 'mt' corresponds to 451 C<gmp_randinit_mt>. Or when passed another randstate object, a copy of that 452 object is made. 453 454 'lc_2exp_size' can fail if the requested size is bigger than the internal 455 table provides for, in which case undef is returned. The maximum size 456 currently supported is 128. The other forms always succeed. 457 458 A randstate can be seeded with an integer or mpz, using the C<seed> method. 459 /dev/random might be a good source of randomness, or time() or 460 Time::HiRes::time() might be adequate, depending on the application. 461 462 $r->seed(time())); 463 464 Random numbers can be generated with the following functions, 465 466 =over 4 467 468 =item 469 470 mpf_urandomb, mpz_rrandomb, mpz_urandomb, mpz_urandomm, 471 gmp_urandomb_ui, gmp_urandomm_ui 472 473 =back 474 475 Each constructs a new mpz or mpf and with a distribution per the 476 corresponding GMP function. For example, 477 478 use GMP::Rand (:all); 479 $r = randstate(); 480 $a = mpz_urandomb($r,256); # uniform mpz, 256 bits 481 $b = mpz_urandomm($r,mpz(3)**100); # uniform mpz, 0 to 3**100-1 482 $c = mpz_rrandomb($r,1024); # special mpz, 1024 bits 483 $f = mpf_urandomb($r,128); # uniform mpf, 128 bits, 0<=$f<1 484 $f = gmp_urandomm_ui($r,56); # uniform int, 0 to 55 485 486 =head2 Coercion 487 488 Arguments to operators and functions are converted as necessary to the 489 appropriate type. For instance C<**> requires an unsigned integer exponent, 490 and an mpq argument will be converted, so long as it's an integer in the 491 appropriate range. 492 493 use GMP::Mpz (mpz); 494 use GMP::Mpq (mpq); 495 $p = mpz(3) ** mpq(45); # allowed, 45 is an integer 496 497 It's an error if a conversion to an integer or mpz would cause any 498 truncation. For example, 499 500 use GMP::Mpz (mpz); 501 $p = mpz(3) + 1.25; # not allowed 502 $p = mpz(3) + mpz(1.25); # allowed, explicit truncation 503 504 Comparisons, however, accept any combination of operands and are always done 505 exactly. For example, 506 507 use GMP::Mpz (mpz); 508 print mpz(3) < 3.1; # true 509 510 Variables used on the left of an assignment operator like C<+=> are subject 511 to coercion too. An integer, float or string will change type when an mpz, 512 mpq or mpf is applied to it. For example, 513 514 use GMP::Mpz (mpz); 515 $a = 1; 516 $a += mpz(1234); # $a becomes an mpz 517 518 =head2 Overloading 519 520 The rule for binary operators in the C<overload> mechanism is that if both 521 operands are class objects then the method from the first is used. This 522 determines the result type when mixing GMP classes. For example, 523 524 use GMP::Mpz (mpz); 525 use GMP::Mpq (mpq); 526 use GMP::Mpf (mpf); 527 $z = mpz(123); 528 $q = mpq(3,2); 529 $f = mpf(1.375) 530 print $q+$f; # gives an mpq 531 print $f+$z; # gives an mpf 532 print $z+$f; # not allowed, would lose precision 533 534 =head2 Constants 535 536 A special tag C<:constants> is recognised in the module exports list. It 537 doesn't select any functions, but indicates that perl constants should be 538 GMP objects. This can only be used on one of GMP::Mpz, GMP::Mpq or GMP::Mpf 539 at any one time, since they apply different rules. 540 541 GMP::Mpz will treat constants as mpz's if they're integers, or ordinary 542 floats if not. For example, 543 544 use GMP::Mpz qw(:constants); 545 print 764861287634126387126378128,"\n"; # an mpz 546 print 1.25,"\n"; # a float 547 548 GMP::Mpq is similar, treating integers as mpq's and leaving floats to the 549 normal perl handling. Something like 3/4 is read as two integer mpq's and a 550 division, but that's fine since it gives the intended fraction. 551 552 use GMP::Mpq qw(:constants); 553 print 3/4,"\n"; # an mpq 554 print 1.25,"\n"; # a float 555 556 GMP::Mpf will treat all constants as mpf's using the default precision. 557 BEGIN blocks can be used to set that precision while the code is parsed. 558 For example, 559 560 use GMP::Mpf qw(:constants); 561 BEGIN { GMP::Mpf::set_default_prec(256); } 562 print 1/3; 563 BEGIN { GMP::Mpf::set_default_prec(64); } 564 print 5/7; 565 566 A similar special tag :noconstants is recognised to turn off the constants 567 feature. For example, 568 569 use GMP::Mpz qw(:constants); 570 print 438249738748174928193,"\n"; # an mpz 571 use GMP::Mpz qw(:noconstants); 572 print 438249738748174928193,"\n"; # now a float 573 574 All three 'integer', 'binary' and 'float' constant methods are captured. 575 'float' is captured even for GMP::Mpz and GMP::Mpq since perl by default 576 treats integer strings as floats if they don't fit a plain integer. 577 578 =head1 SEE ALSO 579 580 GMP manual, L<perl>, L<overload>. 581 582 =head1 BUGS 583 584 In perl 5.005_03 on i386 FreeBSD, the overloaded constants sometimes provoke 585 seg faults. Don't know if that's a perl bug or a GMP module bug, though it 586 does seem to go bad before reaching anything in GMP.xs. 587 588 There's no way to specify an arbitrary base when converting a string to an 589 mpz (or mpq or mpf), only hex or octal with 0x or 0 (for mpz and mpq, but 590 not for mpf). 591 592 These modules are not reentrant or thread safe, due to the implementation of 593 the XSUBs. 594 595 Returning a new object from the various functions is convenient, but 596 assignment versions could avoid creating new objects. Perhaps they could be 597 named after the C language functions, eg. mpq_inv($q,$q); 598 599 It'd be good if C<num> and C<den> gave lvalues so the underlying mpq could 600 be manipulated. 601 602 C<printf> could usefully accept %b for mpz, mpq and mpf, and perhaps %x for 603 mpf too. 604 605 C<get_str> returning different style values for integer versus float is a 606 bit unfortunate. With mpz, mpq and mpf objects there's no doubt what it 607 will do, but on a plain scalar its action depends on whether the scalar was 608 promoted to a float at any stage, and then on the GMP module rules about 609 using the integer or float part. 610 611 =head1 INTERNALS 612 613 In usual perl object style, an mpz is a reference to an object blessed into 614 class C<GMP::Mpz>. The object holds a pointer to the C language C<mpz_t> 615 structure. Similarly for mpq, mpf and randstate. 616 617 A free list of mpz and mpq values is kept to avoid repeated initializing and 618 clearing when objects are created and destroyed. This aims to help speed, 619 but it's not clear whether it's really needed. 620 621 mpf doesn't use a free list because the precision of new objects can be 622 different each time. 623 624 No interface to C<mpf_set_prec_raw> is provided. It wouldn't be very useful 625 since there's no way to make an operation store its result in a particular 626 object. The plain C<set_prec> is useful though, for truncating to a lower 627 precision, or as a sort of directive that subsequent calculations involving 628 that variable should use a higher precision. 629 630 The overheads of perl dynamic typing (operator dispatch, operand type 631 checking or coercion) will mean this interface is slower than using C 632 directly. 633 634 Some assertion checking is available as a compile-time option. 635 636 =head1 COPYRIGHT 637 638 Copyright 2001-2004 Free Software Foundation, Inc. 639 640 This file is part of the GNU MP Library. 641 642 The GNU MP Library is free software; you can redistribute it and/or modify 643 it under the terms of either: 644 645 * the GNU Lesser General Public License as published by the Free 646 Software Foundation; either version 3 of the License, or (at your 647 option) any later version. 648 649 or 650 651 * the GNU General Public License as published by the Free Software 652 Foundation; either version 2 of the License, or (at your option) any 653 later version. 654 655 or both in parallel, as here. 656 657 The GNU MP Library is distributed in the hope that it will be useful, but 658 WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY 659 or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 660 for more details. 661 662 You should have received copies of the GNU General Public License and the 663 GNU Lesser General Public License along with the GNU MP Library. If not, 664 see https://www.gnu.org/licenses/. 665 666 =cut 667 668 # Local variables: 669 # perl-indent-level: 2 670 # fill-column: 76 671 # End: 672
Indexes created Sun Jun 14 00:25:39 UTC 2026