
         PARI: A package for number theory and simple numerical analysis

Pari is a system capable of handling complex number-theoretic and algebraic 
types with complete recursivity. The predefined types are integers (up to
300000 decimal digits), reals (same for the relative precision), elements of 
Z/nZ, rational numbers, complex numbers, p-adic numbers, quadratic numbers,
polynomials, power series, algebraic extensions, rational functions, binary
quadratic forms, vectors, matrices. Everything is recursive, so you can have 
matrices of polynomials with coefficients in an algebraic extension of Z/pZ
for example.

More than 200 special predefined functions, arithmetic or transcendental, are
implemented, in addition to the usual arithmetic operations, which can be 
used without paying attention to the type of the object. The source uses more
than 32000 lines of code, mainly in C.

Pari can be used as a library, but possesses also a powerful calculator mode
which gives instant access to all the types and functions. In this mode, one
can write programs with a simple syntax a little similar to C, but taking
also LISP-like constructs.

Pari is NOT a symbolic manipulation package, in that all expressions are
immediately expanded. For example, (x+y)^2 does give x^2+2xy+y^2, but sin(x)
gives you the taylor series expansion around x=0 (to any number of terms 
specified by the user), and is not kept in the machine as an abstract object.
It does NOT know about symbolic integration (except of course for polynomials
or power series), but it does implement a number of numerical integration 
routines.

The main advantage of Pari is its speed. On a SUN 3/xxx, it is between 5 to
100 times faster than Maple or Mathematica, depending on the applications. 
Also it is specially tailored for use by number theorists, hence contains a 
large number of predefined number-theoretical functions not found in other 
systems. It can of course profitably be used by other people as well. Finally,
it is free.

Currently, Pari has been tested on SUN 3/xxx, SUN 4/xxx (hence SPARCstations), 
and Macintoshes with a 68020/68030 processor. A version exists which could run 
on other machines as well, but this has not been tested. 

To get the MacII or Mac SE/30 version, send an email message to

        bernardi@mizar.greco-prog.fr

The version 1.34 of the PARI system for number theory is available for
anonymous ftp. In Europe, from seti.inria.fr (128.93.1.12), and in the
rest of the world from math.ucla.edu (128.97.64.16), in the directory pub/pari.

We would very much appreciate user feedback. Please understand that it is not
a polished commercial product.

Enjoy!

Henri Cohen                                        cohen@mizar.greco-prog.fr


		New version of the Pari package

					cohen@alioth.greco-prog.fr (Henri Cohen)


This is to announce that version 1.37 of the Pari package for fast
number-theoretical and simple symbolic and numerical analysis
package is available for anonymous ftp. More than 220 minor and
major modifications have been made since version 1.35, and users of
1.35 should update (it is less important for 1.36 users).

Pari now runs on many different platforms, including 386 boxes
(although we do not support this port by lack of means). The
Unix and Macintosh versions are available by anonymous ftp from
math.ucla.edu (128.97.4.254, where a NeXT version is also available)
and in Europe from 134.157.51.2, directory dist/pari, and soon on
nuri.inria.fr (128.93.1.26).

Users who are not familiar with Pari are encouraged to give it a try 
(it is free after all). Although lacking many functionalities of 
commercial systems (symbolic integration, diff. equations, sophisticated 
plotting, etc,...) you will find that it can do many things more easily 
and MUCH faster (a factor of 5 to 50 is usual).

For information, the file below describes very briefly the main changes
between versions 1.35 and 1.37.

Enjoy!

H. Cohen

cohen@geocub.greco-prog.fr
pari@alioth.greco-prog.fr

--------------------------------------------------------------------

Description of the main changes between versions 1.35 and 1.37
*** The changes since version 1.36 are preceded by ***.

(Since some intermediate releases like 1.35.01 have widely circulated, some
changes described below do not apply.)

In addition to the new programs and improvements described below, many bugs
have been corrected and improvements have been made. See the file Changes for 
details.

1) Linear algebra

a) New programs

suppl (supplement a subspace), image (image of a linear map), inverseimage
(find a preimage of a vector by a linear map), indexrank (find row and column
indices for extraction of a maximal rank square submatrix), matrixqz (primitive
matrix having the same $\Bbb Q$-image), matrixqz2 (intersection of $\Bbb Z^n$
with a lattice), matrixqz3 (intersection of $\Bbb Z^n$ with a 
$\Bbb Q$-subspace), kerint, kerint1 and kerint2 ($\Bbb Z$-kernel of a linear
map), intersect (intersection of subspaces), lllgramint and lllint (LLL when 
the gram matrix is integral, completely accurate and fast if applicable),
lllgramkerim and lllkerim ($\Bbb Z$-kernel and image of a linear map,
generalizing lllgramint and lllint to the case where the vectors may be
dependent).

b) Improvements

Modified many programs to handle empty matrices in a reasonable way.
smith modified so as to allow singular matrices, and hermite modified so as to
accept matrices of any size, in particular with more rows than columns.
norml2 accepts now any type, in particular matrices.
The LLL algorithms have been improved and speeded up. In particular, the
linear and algebraic dependence algorithms lindep2 and algdep2 now give
considerably better results than before, since they call lllint instead of lll.
hess is now (hopefully) correct.
In a GP statement, rows and columns of a matrix can now be accessed or modified
directly using m[j,] for the j-th row and m[,k] for the k-th column.
*** Addition of a scalar zero to a vector/matrix and of any scalar to a square
*** matrix is now allowed.

2) Polynomials, polymods and rational funtions

a) New programs

factfq (factorization of polynomials over any finite field), cyclo (cyclotomic
polynomials), modreverse (reverse of a polymod), polred2 (polred with the
integral basis elements), polyrev (same as poly in reverse order), 
smallpolred2 (smallpolred+polred2), factoredpolred2 (factoredpolred+polred2),
rootslong (a much slower but safer polynomial root finder), galois (galois
group of a polynomial of degree up to 7), galoisconj (list of conjugates of
an algebraic number belonging to the same number field), tchirnhausen (apply
a random tchirnhausen transformation), initalg (give basic information about
a number field), resultant2 (resultant for non-exact types), 
factornf (factoring polynomials over number fields).

b) Improvements

gcd of two polymods or between a polymod and a polynomial is now more 
reasonable, and vector/matrix arguments are allowed in gcd and lcm.
Major modifications have been introduced in the treatment of polymods which
now behave in a much more reasonable way.
The simplification of rational functions has been enhanced, resulting in
more completely simplified expressions, but also in slower speed.
*** sturmpart was incorrect.

3) Arithmetic functions.

a) New programs

factr (n! as a real number), centerlift (lift of mod(a,b) to a with |a| 
minimum), shift (left or right shift), shiftmul (multiplication or division by
a power of 2), rhorealnod and redrealnod (same as rhoreal and redreal without
distance computation), comprealraw, sqrealraw and powrealraw (composition,
squaring and powering of binary quadratic forms with positive discriminant
without performing any reduction), isisom (test isomorphism of number fields),
isincl (test inclusion of number fields), rootsof1 (number of roots of unity
in a number field), nucomp, nudupl and nupow (composition of primitive 
positive definite binary quadratic forms a la Shanks).
*** Optionally: buchimag and buchreal (sub-exponential algorithms for class
*** group structure and regulator of imaginary and real quadratic fields).

b) Improvements

sumdivk(n,k) now accepts k<0.
When an impossible inverse modulo occurs, the error message prints the culprit
so that one can factor the modulus if necessary.
smallfact and boundfact can now have rational arguments.
All operations (except nucomp and co.) on quadratic forms now accept 
nonprimitive forms (whatever the result means however).
*** Almost all arithmetic functions now accept vector or matrix arguments.

4) Transcendental functions

a) New programs

izeta (zeta function for integer arguments, not accessible from GP but called
automatically by zeta), incgam4 (incomplete gamma with given gamma value), 
cxpolylog (polylog of complex argumnet, not accessible from GP but called
automatically by polylog).

b) Improvements

incgam(a,x) now accepts a<=0.
The polylog functions have been deeply modified. They now work in the whole
complex plane, accept negative indices, and all useful modified versions
are implemented. Also power series arguments are now accepted.
gamma and lngamma now accept power series arguments.
*** arg accepts vector/matrix arguments.
*** theta(q,z) now works correctly when z is complex.

5) Elliptic curves

a) New programs
initell2 (fast initell, but for reasonable size coefficients), lseriesell
(fast computation of the L series of an elliptic curve), pointell (Weierstrass
P-function and its derivative), 
*** akell (individual value of a_k).

b) Improvements
Elliptic curves with huge coefficients can now be treated.
zell is now in priciple correct and more accurate.
The coefficients of matell have been doubled, so the determinant of the 
height matrix is the usual regulator.
isoncurve gives a reasonable answer in case of imprecise coefficients.
apell now accepts prime numbers larger than 65536.
*** smallinitell does not give an error message when D=0, but sets j=0.
*** ordell now treats correctly rational numbers.

6) Plotting functions

a) New programs

*** plothraw (plot of a set of points) has been added to the existing ploth and
*** ploth2 (at present only under X11 and suntools). In addition a large set of
*** more primitive plotting functions has been added: box and rbox (draw a 
*** rectangular box), cursor (give current position of cursor), draw 
*** (physically draw the contents of the windows, for the moment only under 
*** X11 and suntools), initrect (initialize a window), killrect (erase a
*** window), line and rline (draw a line), lines (draw a polygon), move and
*** rmove (move the cursor), point and rpoint (draw a single point), points
*** (draw a vector of points), string (draw a string or print a real number).
*** postploth, postploth2, postplothraw, postdraw (postscript output of the
*** corresponding plotting functions).

7) Miscellaneous

a) New programs

vecsort (sort by some component), read (read an expression from a GP program),
random (generate a random number), permutation (list all permutations), 
matsize (dimensions of a matrix), size (maximal number of decimal digits),
rounderror (maximum error made in rounding), lex (lexicographic comparison),
lexsort (lexicographic sort), simplify (remove a zero imaginary part in a
complex or quadratic, and convert a constant polynomial into its constant
term).

b) Improvements

The time to input a large file into GP by \r is much shorter.
suminf, prodinf, suminf1, prodinf1 can now have zero coefficients without
stopping the computation.
A vector can now be raised to an integral power componentwise (of course
not a matrix).
A new output format has been added (the prettymatrix format), which allows to
print matrices as boxes, the components being still in raw format. This is now
the default instead of the raw format (type \p to switch between the three
output formats, \a, \m and \b to print in raw, prettymatrix and prettyprint 
format respectively).
*** When the dreaded message "the pari stack overflows" appears, all is not
*** lost. Pari attempts to double the stack size, and if it succeeds, the 
*** user can proceed under GP with a larger stack by simply retyping the 
*** last command.
*** Comments can now be included inside a {...} block under GP.

8) Documentation and examples.

a) Two new chapters have been added to the manual (which now exceeds 103 pages,
not counting the table of contents and the index). Chapter 5 gives a complete
list of the low level functions of the PARI library, with a description of
their use. The last chapter is a tutorial to the use of the GP calculator. It
is not yet finished in this release. If you do not want it in the manual,
put a % sign in front of the line \input tutorial in the file users.tex.

b) Two examples of complete and non-trivial GP programs are given in the
directory examples. The first one is in the file squfof.gp. Just read in this
file under GP with the command \r squfof.gp, and use the function squfof on
positive integers which you want to factor. SQUFOF is a very nice factoring
method invented in the 70's by D. Shanks for factoring integers, and is 
reasonably fast for numbers having up to 15 or 16 digits. The squfof program
which is given is a very crude implementation. It also prints out some
intermediate information as it goes along. The final result is some factor of
the number to be factored.

*** A second example is in the file clareg.gp. This allows you in many cases
*** to compute the class number, the structure of the class group and a system
*** of fundamental units of a general number field (this programs sometimes
*** fails to give an answer). The first thing to do is to call the function
*** clareg(pol,limp,lima,extra) where pol is the monic irreducible polynomial 
*** defining the number field, limp is the prime factor base limit (try 
*** values between 19 and 113), lima is another search limit (try 50 or 100)
*** and extra is the number of desired extra relations (try 2 to 10). The
*** program prints the number of relations that it needs, and tries to find 
*** them. If you see that clearly it slows down too much before succeeding,
*** abort and try other values. If it succeeds, it will print the class number,
*** class group, regulator. These are tentative values. Then use the function
*** check(lim) (take lim=200 for example) to check if the value is consistent
*** with the value of the L-series (the value returned by check should be close
*** to 1). Finally, the function fu() returns a family of units which generates
*** the unit group.

9) New platforms

*** A sparcv8.s assembler file is included for use with version 8 and higher
*** sparc systems.
*** An HP-PA version is now included in the sources, including a small 
*** assembler file, as for the sparc versions.



