/ 
Math-Pari-2.001501
River stage two • 5 direct dependents • 16 total dependents
/ Math::Pari

NAME

Math::Pari - Perl interface to PARI.

SYNOPSIS

use Math::Pari;
$a = PARI 2;
print $a**10000;

or

use Math::Pari qw(Mod);
$a = Mod(3,5);
print $a**10000;

DESCRIPTION

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, or Math::libPARI).

EXPORTed functions

DEFAULT

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

One integer

Is converted to a PARI integer.

One float

Is converted to a PARI float.

One string

Is executed as a PARI expresion (so should not contain whitespace).

PARI object

Is passed unchanged.

Reference to a Perl array

Each element is converted using the same rules, PARI vector-row with these elements is returned.

Several of above

The same as with a reference to array.

Conflicts of rules in PARI()

In deciding what rule of the above to apply the preference is given to the uppermost choice of those 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.

Note that for Perl these data are synonimous, since Perl freely converts between integers, float and strings. However, to PARI() only what the argument is now is important.

PARIcol() and PARImat()

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 with arguments

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 qw(factorint PARI);
use Math::Pari qw(:DEFAULT factorint);

or simply do it in two steps

use Math::Pari;  
use Math::Pari 'factorint';

The other tags recognized are :PARI, :all, prec=NUMBER, 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.

Giving ? command to gp PARI calculator lists the following classes:

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, or functions from the given section using listPari() function.

Starting from version 5.005 of Perl, three additional tags are supported: :int, :float, :hex. If used, all the integer/float/hex-or-octal literals in Perl will be automatically converted to became PARI objects. Say

use Math::Pari ':int';
print 2**1000;

is equivalent to

print PARI(2)**PARI(1000);

(The support for this feature is buggy before 5.005_57 unless Perl uses mymalloc options - check with perl -V:usemymalloc.)

Available functions

Directly accessible from Perl

This package supports all the functions from the PARI library with a signature which can be recognized by Math::Pari. 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 supported). 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 (not checked with PARI 2.0).

The following functions are specific to GP calculator, thus are not available to Math::Pari in any way:

allocatemem default error extern input print print1 printp printp1
printtex quit read system whatnow write write1 writetex

whatnow() function is useless, since Math::Pari does not support the "compatibility" mode (with older PARI library). The functionality of print(), write() and variants is available via automatic string translation, and pari_print() function and its variants.

allocatemem() and default() are the only two important functions with functionality not supported by the current interface. Note however, that two most important default() actions are supported by setprecision() and setseriesprecision() functions.

Arguments

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 T_INT (i.e., a Pari integer), the corresponding function of Math::Pari will silently convert the argument to long. Each argument is converted by the rules applicable to PARI.

Return values

PARI functions return PARI type or a Perl's integer depending on what the actual library function returns.

Additional functions

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.

Infix, prefix and postfix operations

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, or Math::libPARI). Note that all these functions are more readily available via operator overloading, so instead of

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).

Conversion functions
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.

Printout functions
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, and whitespace in the output.)

Constant functions

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:

$x = Pi ** Euler;
Low-level functions

For convenience of low-level PARI programmers some low-level functions are made available as well (they are not exported):

typ(x) changevalue(name,newvalue)
Uncompatible functions
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.

ifact(n)

integer factorial functions, available from gp as n!.

Looping functions

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');

or

$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").

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):

$x = 0;
$j = PARI 'j';
fordiv(28, $j, sub { $x += $j } );

However, if absolutely required, one can make a delayed variable $j which will always reference the same thing j references in PARI now by using PARIvar constructor

$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.

Accessing Perl functions from PARI code

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, @ 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 unsupported function for explicitely importing Perl functions into Pari, possibly with a different name, and possibly with explicitely specifying number of arguments.

PARI objects

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

ref $obj eq 'Math::Pari';

Most the time you do not need this due to automatic conversions.

PARI polynomials and Perl barewords

Some bareletters denote Perl operators, like q, x, y, s. This can lead to errors in Perl parsing your expression. Say, while

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)),

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, the best advice: do not use barewords anywhere in your program!

Overloading and automatic conversion

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:

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.

PREREQUISITES

Perl

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.

PARI

Starting from version 2.0, this module comes without a PARI library included.

For the source of PARI library see ftp://megrez.math.u-bordeaux.fr/pub/pari.

Perl vs. PARI: different syntax

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.

\ and \/

There are no such operators in Perl, use the word forms gdivent(x,y) and gdivround(x,y) instead.

~

There is no postfix ~ Perl operator. Use mattranspose() instead.

'

There is no postfix ' Perl operator. Use deriv() instead.

!

There is no postfix ! Perl operator. Use factorial()/ifact() instead (returning a real or an integer correspondingly).

big integers

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').

Starting from version 5.005 of Perl, if the tag :int is used, all the integer literals in Perl will be automatically converted to became PARI objects. Say

use Math::Pari ':int';
print 2**1000;

is equivalent to

print PARI(2)**PARI(1000);
doubles

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

setprecision(38);
print pari_print(0.01),   "\n",
      pari_print('0.01'), "\n";

shows.

Note that setprecision() changes the output format of pari_print() and friends, as well as internal precision. The generic PARI===>string conversion does not take into account the output format, thus

setprecision(38);
print PARI(0.01),       "\n",
      PARI('0.01'),     "\n",
      pari_print(0.01), "\n";

will print all the lines with different number of digits after the point: the first one with 22, since the double 0.01 was converted to a low-precision PARI object, the second one with 41, since internal form for precision 38 requires that many digits for representation, and the last one with 39 to have 38 significant digits.

Starting from version 5.005 of Perl, if the tag :float is used, all the float literals in Perl will be automatically converted to became PARI objects. Say

use Math::Pari ':float';
print atan(1.);

is equivalent to

print atan(PARI('1.'));
array base

Arrays are 1-based in PARI, are 0-based in Perl. So while array access is possible in Perl, you need to use different indices:

$nf = PARI 'nf';	# number field
$a = PARI('nf[7]');
$b = $nf->[6];

Now $a nd $b contain the same value.

matrices

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.

builtin perl functions

Some PARI functions, like length and eval, are Perl (semi-)reserved words. To reach these functions, one should either import them:

use Math::Pari qw(length eval);

or call them with prefix (like &length) or the full name (like Math::Pari::length).

string($w, $text)

will not coerce a number into 8+3 format. You need to use sprintf "%8.3f", $text explicitely.

High-resolution graphics

If you have Term::Gnuplot installed, you may use high-resolution graphic primitives of PARI. Before the usage you need to establish a link between Math::Pari and Term::Gnuplot by calling link_gnuplot(). You can change the output filehandle by calling set_plot_fh(), and output terminal by calling plotterm(), as in

use Math::Pari qw(:graphic asin);

open FH, '>out.tex' or die;
link_gnuplot();
set_plot_fh(\*FH);
plotterm('emtex');
ploth($x, .5, .999, sub {asin $x});
close FH or die;

libPARI documentation

libPARI documentation is included, see Math::libPARI. It is converted from Chapter 3 of PARI/GP documentation by paridoc_to_pod script.

ENVIRONMENT

No environment variables are used.

BUGS

  • A few of PARI functions are available indirectly only.

  • t/*_will_fail.t

    These tests expose several bugs.

AUTHOR

Ilya Zakharevich, ilya@math.ohio-state.edu

1 POD Error

The following errors were encountered while parsing the POD:

Around line 613:

Expected '=item *'