Math::Pari - Perl interface to PARI.
Math::Pari
use Math::Pari; $a = PARI 2; print $a**10000;
or
use Math::Pari qw(mod); $a = mod(3,5); print $a**10000;
This package is a Perl interface to famous library PARI for numerical/scientific/number-theoretic calculations. It allows use of most PARI functions as Perl functions, and (almost) seamless merging of PARI and Perl data. In what follows we suppose prior knowledge of what PARI is (see ftp://megrez.math.u-bordeaux.fr/pub/pari).
By default the package exports functions PARI(), PARIcol() and PARImat() that converts its argument(s) to a PARI object. (In fact PARI() is just an alias for new Math::Pari). The function PARI() accepts following data as its arguments
new Math::Pari
Is converted to a PARI integer.
Is converted to a PARI float.
Is executed as a PARI expresion (so should not contain whitespace).
Is passed unchanged.
Each element is converted using the same rules, PARI vector-row with these elements is returned.
The same as with a reference to array.
In deciding what rule of the above to apply the preference is given to the uppermost choice of available now, if none matches, then the string rule is used. So PARI(1) returns integer, PARI(1.) returns float, PARI("1") evaluates "1" as a PARI expression, though all these data can be converted inside Perl into integer, float or string. Only what the argument is now is important.
PARI(1)
PARI(1.)
PARI("1")
PARIcol() behaves in the same way as PARI() unless given several arguments. In the latter case it returns a vector-column instead of vector-row.
PARImat() constructs a matrix out of the given arguments. It will work if PARI() will construct a vector of vectors given the same arguments.
use
If arguments are specified in the use Math::Pari directive, the PARI functions appearing as arguments are exported in the caller context. In this case the function PARI() and friends is not exported, so if you need them, you should include them into export list explicitely, or include :DEFAULT tag.
use Math::Pari
:DEFAULT
The other tags recognized are :PARI, :all, and number tags, like :4, and section names tags. The number tags export functions from the PARI library from the given class (except for :PARI, which exports all the classes). Tag :all exports all the exportable symbols and :PARI.
:PARI
:all
:4
Giving ? command to gp PARI calculator lists the following classes:
?
gp
1: Standard monadic or dyadic OPERATORS 2: CONVERSIONS and similar elementary functions 3: TRANSCENDENTAL functions 4: NUMBER THEORETICAL functions 5: Functions related to ELLIPTIC CURVES 6: Functions related to general NUMBER FIELDS 7: POLYNOMIALS and power series 8: Vectors, matrices, LINEAR ALGEBRA and sets 9: SUMS, products, integrals and similar functions 10: GRAPHIC functions 11: PROGRAMMING under GP
One can use section names instead of number tags. Recognized names are
:standard :conversions :transcendental :number :elliptic :fields :polynomials :vectors :sums :graphic :programming
One can get a list of all Math::Pari accessible functions using listPari() function.
listPari()
This package supports all the functions from the PARI library with a signature from a long list. This means that when you update the PARI library, the newly added function will we available without any change to this package (provided their signature is in the supported list). You can reach unsupported functions using string argument of PARI() function, as in
3 + PARI('O(x^17)')
(or some special wrapper functions, like O(variable,power)). A perl script parifonc is provided that lists the functions from the current release of PARI that are unavailable with the current release of this glue code.
O(variable,power)
parifonc
The output as of 9/22/97 is
Builtins, unsupported as functions (but available in Perl): label, while, goto, until, read, pprint, print, texprint, pprint1, print1, O, if, o Total number of unsupported interfaces: 19: Interface 16 used in 1 function(s): plotterm. Interface 19 used in 2 function(s): rlinetype, rpointtype. Interface 44 used in 1 function(s): rcopy. Interface 45 used in 1 function(s): rplothraw. Interface 57 used in 1 function(s): string. Interface 59 used in 1 function(s): scale. Interface 73 used in 1 function(s): rploth. Interface 85 used in 1 function(s): kill. Interface 86 used in 1 function(s): forstep. Interface 87 used in 1 function(s): forvec. Interface 89 used in 1 function(s): buchinitforcefu. Interface 90 used in 1 function(s): buchinitfu. Interface 91 used in 1 function(s): buchinit. Interface 92 used in 1 function(s): buchgen. Interface 94 used in 1 function(s): buchgenfu. Interface 95 used in 1 function(s): buchgenforcefu. Interface 96 used in 1 function(s): buchimag. Interface 97 used in 1 function(s): buchreal. Interface 99 used in 1 function(s): addhelp. Total number of unsupported functions: 20: group 4: buchimag, buchreal group 6: buchgen, buchgenforcefu, buchgenfu, buchinit, buchinitforcefu, buchinitfu group 10: forstep, forvec, plotterm, rcopy, rlinetype, rploth, rplothraw, rpointtype, scale, string group 11: addhelp, kill
Arguments to PARI functions are converted to long or PARI type depending on what type the actual library function requires. No error checking on arguments is done, so if gp rejects your code since a particular argument should be of type 1 (i.e., a Pari integer), Math::Pari will silently convert it to long. Each argument is converted by the rules applicable to PARI.
long
type 1
PARI functions return PARI type or a Perl's integer depending on what the actual library function returns.
Some PARI functions are available in gp (i.e., in PARI calculator) via infix notation only. In Math::Pari these functions are available in functional notations too. Some other convenience functions are also made available.
PARI
are available under names
gneg, gadd, gsub, gmul, gdiv, gdivent, gmod, gpui, gle, gge, glt, ggt, geq, gne, gegal, gor, gand, gcmp, gcmp0, gcmp1, gcmp_1.
gdivent means euclidean quotient, gpui is power, gegal checks whether two objects are equal, gcmp is applicable to two real numbers only, gcmp0, gcmp1, gcmp_1 compare with 0, 1 and -1 correspondingly (see PARI user manual for details). Note that all these functions are more readily available via operator overloading, so instead of
gdivent
gpui
gegal
gcmp
gcmp0
gcmp1
gcmp_1
gadd($x, gneg($y))
one can write
$x+(-$y)
(as far as overloading may be triggered, so we assume that $x or $y is of PARI type already).
pari2iv, pari2nv, pari2num, pari2pv, pari2bool
convert a PARI object to an integer, float, integer/float (whatever is better), string, and a boolean value correspondingly. Most the time you do not need these functions due to automatic conversions.
pari_print, pari_pprint, pari_texprint
perform conversions to strings as their PARI counterparts, but do not print the result. The difference of pari_print() with pari2pv() is the number of significant digits they print.)
Some mathematical constant appear as function without arguments in PARI. Perl has a facility to have similar functions. If you export them like in
use Math::Pari qw(:DEFAULT pi i euler);
they can be used as barewords in your program.
For convenience of low-level PARI programmers some low-level functions are made available as well (they are not exported):
typ
O
Since implementing O(7**6) would be very tedious, we provide a two-argument form O(7,6) instead. Note that with polynomials there is no problem like this one, both O($x,6) and O($x**6) work.
O(7**6)
O(7,6)
O($x,6)
O($x**6)
ifact(n)
integer factorial functions, available from gp as n!.
n!
PARI has a big collection of functions which loops over some set. Such a function takes two special arguments: loop variable, and the code to execute in the loop.
The code can be either a string (which contains PARI code to execute - thus should not contain whitespace), or a Perl code reference. The loop variable can be a string giving the name of PARI variable (as in
fordiv(28, 'j', 'a=a+j+j^2');
$j= 'j'; fordiv(28, $j, 'a=a+j+j^2');
), or a Perl variable containing a PARI variable (as in
$j = PARI 'j'; fordiv(28, $j, sub { $a += $j + $j**2 });
).
If the loop variable is not of these two types, then an appropriate name will be autogenerated. Note that since you have no control over this name, you will not be able to use this variable from your PARI code, say
$j = 7.8; fordiv(28, $j, 'a=a+j+j^2');
will not (obviously) expand j to mirror $j (unless you set up j to mirror $j explicitely, see "Accessing Perl functions from PARI code").
j
Useless musing alert! Do not read the rest of this section!
In fact a very hairy type of access is also supported. Note that the following code will not do what you expect
$x = 0; $j = PARI 'j'; fordiv(28, 'j', sub { $x += $j } );
since fordiv will localize j inside the loop, so $j will still reference the old value, which is an independent variable, not the index of the loop. The simplest workaround is not to use the above syntax (i.e., not mixing literal loop variable with Perl loop code, just using $j as the second argument to fordiv is enough).
fordiv
However, if absolutely required, one can make a delayed variable $j which will always reference the same thing j references now by using PARIvar constructor
PARIvar
$x = 0; $j = PARIvar 'j'; fordiv(28, 'j', sub { $x += $j } );
This problem is related to
$ref = \$_; # $$ref is going to be old value even after # localizing $_ in Perl's grep/map
not accessing localized values of $_ in the plain Perl.
This is possible. Just use the same name for the function:
sub counter { $i += shift; } $i = 145; PARI 'k=5' ; fordiv(28, 'j', 'k=k+counter(j)'); print PARI('k'), "\n";
prints
984
Note that if the subroutine takes a variable number of arguments, each @ in the prototype (or a missing prototype) counts as 6 optional arguments are supported. If called from PARI with fewer arguments optional arguments will be set to integer PARI 0.
@
Note also that no direct import of Perl variables is available yet (but you can write a function wrapper for this):
sub getv () {$v}
There is an undocumented function for explicitely importing Perl functions into Pari, possibly with a different name, and possibly with explicitely specifying number of arguments.
Functions from PARI library take as arguments and/or return objects of type GEN (in C notations). In Perl these data are encapsulated into special kind of Perl variables: PARI objects. You can check for a variable $obj to be a PARI object using
GEN
C
$obj
ref $obj eq 'Math::Pari';
Most the time you do not need this due to automatic conversions.
Some bareletters denote Perl operators, like q, x, y, s. This can lead to errors in Perl parsing your expression. Say, while
q
x
y
s
print sin(tan(x))-tan(sin(x))-asin(atan(x))+atan(asin(x));
may parse OK (after use Math::Pari qw(sin tan asin atan)),
use Math::Pari qw(sin tan asin atan)
print sin(tan(y))-tan(sin(y))-asin(atan(y))+atan(asin(y));
does not. You should avoid lower-case barewords used as PARI variables, say, do
$y = PARI('y'); print sin(tan($y))-tan(sin($y))-asin(atan($y))+atan(asin($y));
to get
-1/18*y^9+26/4725*y^11-41/1296*y^13+328721/16372125*y^15+O(y^16)
Well, frankly speaking you should not use barewords anywhere in your program!
Whenever an arithmetic operation includes a PARI object the other arguments are converted to a PARI type and the corresponding PARI library functions is used to implement the operation. Numeric comparison operations use gcmp and friends, string comparisons compare in lexicographical order using lex. Currently the following arithmetic operations are overloaded:
lex
unary - + - * / % ** abs cos sin exp log sqrt <= == => < > != <=> le eq ge lt gt ne cmp
Whenever a PARI object appears in a situation that requires integer, numeric, boolean or string data, it is converted to the corresponding type. Boolean conversion is subject to usual PARI pitfalls related to imprecise zeros (see documentation of gcmp0 in PARI reference).
Note that a check for equality is subject to same pitfalls as in PARI due to imprecise values. PARI may also refuse to compare data of different types for equality if it thinks this may lead to counterintuitive results.
Note also that numeric ordering is not defined for some types of PARI objects. For string comparison operations we use PARI-lexicographical ordering.
In the versions of perl earlier than 5.003 overloading used a different interface, so you may need to convert use overload line to %OVERLOAD, or, better, upgrade.
use overload
%OVERLOAD
Starting from version 0.5, this module comes with a PARI library included.
If you want to put in a different PARI library, you need at least version 1.39 of PARI. (See ftp://megrez.math.u-bordeaux.fr/pub/pari.)
Note that the PARI notations should be used in string arguments to PARI() function, while Perl notations should be used otherwise.
^
Power is denoted by ** in Perl.
**
\
\/
There are no such operators in Perl, use the word forms gdivent(x,y) and gdivround(x,y) instead.
gdivent(x,y)
gdivround(x,y)
~
There is no postfix ~ Perl operator. Use trans() instead.
_
There is no postfix _ Perl operator. Use conj() instead.
!
There is no postfix ! Perl operator. Use fact()/ifact() instead (returning a real or an integer correspondingly).
Currently Perl will convert big literal integers to doubles if they could not be put into C 32-bit signed integers. If you want to input such an integer, use PARI('12345678901234567890').
Doubles in Perl are of precision approximately 15 digits. When you use them as arguments to PARI functions, they are converted to PARI real variables, and due to intermediate 15-decimal-to-binary conversion of Perl variables the result may be different than with the PARI many-decimal-to-binary conversion. Say, PARI(0.01) and PARI('0.01') differ at 19-th place, as
PARI(0.01)
PARI('0.01')
setprecision(38); print pari_print(0.01), "\n", pari_print('0.01'), "\n";
shows.
Arrays are 1-based in PARI, are 0-based in Perl.
Note that PARImat([[...],...,[...]) constructor creates a matrix with specified columns, while PARI's [1,2,3;4,5,6] constructor creates a matrix with specified rows. Use a convenience function PARImat_tr() which will transpose a matrix created by PARImat() to use the same order of elements as in PARI.
PARImat([[...],...,[...])
[1,2,3;4,5,6]
libPARI documentation is included, see libPARI. It is converted from Chapter 3 of PARI/GP documentation by chap3_to_pod script.
No environment variables are used.
Not all the PARI functions are directly available.
t/Testout.t
This test suite is not completely converted, it gives many false negatives.
Ilya Zakharevich, ilya@math.ohio-state.edu
1 POD Error
The following errors were encountered while parsing the POD:
Expected '=item *'
To install Math::Pari, copy and paste the appropriate command in to your terminal.
cpanm
cpanm Math::Pari
CPAN shell
perl -MCPAN -e shell install Math::Pari
For more information on module installation, please visit the detailed CPAN module installation guide.