GMP.pm
上传用户:qaz666999
上传日期:2022-08-06
资源大小:2570k
文件大小:21k
源码类别:

数学计算

开发平台:

Unix_Linux

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