Karim Belabas on Fri, 14 Nov 1997 17:48:48 +0100

[Date Prev] [Date Next] [Thread Prev] [Thread Next] [Date Index] [Thread Index]


	Announcement of the Pari-2.0.ALPHA release

  This message is to announce the alpha release of version 2.0 of the
PARI/GP system. It can be found at:


  For those who do not yet know (?), PARI/GP is a package which is aimed at
efficient computations in number theory, but also contains a large number
of other useful functions. It is somewhat related to a Computer Algebra
System, but is not really one since it treats symbolic expressions as
mathematical entities such as polynomials, series, matrices, etc..., and
not as expressions per se. However it is often much faster than other
CAS, and contains a huge number of specific functions not found
elsewhere, essentially for use in number theory. In particular, and
especially so in the present release, there is a very large package for
working in general algebraic number fields.

  This package can be used in an interactive shell (GP) or as a C/C++
library (PARI).

  In addition, it is free!

For all questions related to Pari itself, mail to



>From the README file:

  The ALPHA status means that bugs might still be lurking around, that
the documentation might not be absolutely accurate, and that some
features or function names might change on short notice. Apart from that
word of caution, we believe this version is stable enough to warrant an
immediate release.

  We think it is important for you and for us that you try this new
version and send us feedback, since we can then improve the BETA version
(scheduled in a few months) and finally the RELEASE version.

  To save us time and worries, this is a UNIX-only, source-code-only,
release. We will provide binaries for later, stabler, versions.

Some NEW features:

I) The GP/PARI structure has been cleaned up.

   * The whole configuration process has been automated, and a Configure
     file is provided. Just typing 'Configure' should see you home in most 

   * PARI is now available as a dynamic library, thanks to Louis Granboulan.
     (you can link gp with it should you wish to). This saves a tremendous
     amount of disk space, and is generaly more convenient as you don't need
     to re-link your files when updating the library (or when debugging.
     or profiling, or...).

   * types now have a symbolic mnemotechnic name (e.g t_INT for an integer,
     t_VEC for a vector, and so on).

   * General speed-up (depends on your applications, about 20% for our
     generic testing file).

   * Experimental module loading structure (the actual function tree
     has not yet been cut into modules, but for the GP specific functions).

II) Many new or improved functions in the PARI library.

   * MANY class-field related functions. In particular:
     - is it now possible to try and remove the GRH assumption on class group
     - ray class groups computations (including discrete log).
     - explicit defining equations in simple cases (Kummer extensions of prime
       degree, quadratic base field).

   * roots is now entirely reliable, thanks to Xavier Gourdon.

   * some core routines have been optimized: Karatsuba fast multiplication,
     a specific function gsqr() for squarings (twice as fast as
     gmul(x,x) in the most favourable cases),...

   * input/output is much more flexible now:
     - a function GENtostring has been added, generalizing gitoascii to any 
     PARI object (with a simpler syntax: GENtostring(g) returns a malloced
     string containing g as gp would print it).

     - lisexpr has a relative flisexpr (for filtered lisexpr), which enables
     you to use input containing whitespaces.

     - you can use GENs in formatted output, a la printf.

   * improved garbage collecting.

   * private variables can be created without an explicit lisexpr(), using
     fetch_var() and delete_var(). 

III) GP has been completely re-written:

   * lowercaps/uppercaps are now significant. All predefined constants 
     (Euler, I, Pi) have been renamed (as well, the o() notation for series
     and padics has been superseded by O()).

     for (i=1,10, print(i)) will not yield an error anymore.

   * human-readable error messages, including a caret to indicate where
     a GP syntax error occured.

   * function names were renamed according to a more logical scheme. The
     file new.dico provides a translation (available under GP using "whatnow")
   * You can retrieve basic information from complicated objects using member
     functions (you cannot define your own, though). For instance x.disc will
     yield the discriminant of x, whether it was created by nfinit (aka
     initalg), bnfinit (aka buchinit), ellinit (aka initell).

   * A .gprc file is available to set "permanent" defaults (such as
     global variables, aliases, common functions, etc...).  For instance,
     you can put all your scripts in some special directories, and
     point them out to GP using "path". See lib/gprc.default for examples.

     The function "default" enables to change most defaults under gp.
     For instance: default(compatible,2) will give you back the former gp
     function names and helpmessages. (default(compatible,3) undoes the
     lowercaps/uppercaps changes as well). Try "default".

   * the basic C idiosyncrasies such as for instance i++ (for i=i+1), i<<1 
     (for left shift) or i+=j (for i=i+j) are now allowed within GP scripts.
     /* */ multi-line comments are understood.

   * lists and (primitive) string support have been added. Characters can be
     quoted with the usual meaning. For instance, try
       default(prompt,"\e[1mgp\e[m > ")

     As a result, set functions can now be used with arbitrary elements.

   * if your terminal supports color (variants of color_xterm for instance), 
     you can tell GP to highlight its output in different (user configurable)
     colors. This is done by fiddling with the default "colors".

   * The familiar functions "break", "next" and "return" are now available.
     These should supersede the buggy label/goto provided in old versions 
     of GP.

   * somewhat enhanced on-line help. Even more: if you have perl on your
     system, try ?? function-name (?? bnfinit for instance). This is provided
     by external scripts which can be used independently, outside of any GP

   * If readline is installed on your system, a context-dependent completion
     (not yet user-programmable) is now available (try hitting <TAB> here and
     there). Try ?? readline.

   * many functions now have default arguments (shown between braces {} in
     the on-line description). gp first reads user-supplied arguments, and
     then fills in the arg list with these default values. Optional args can
     be entirely omitted, comma included (for a function with no mandatory
     arguments, even parentheses are optional !). For instance:

       Mat = Mat()
       bnfclassunit(x^2+1,0) = bnfclassunit(x^2+1)
       bnfclassunit(x^2+1,,[0.2,0.2]) = bnfclassunit(x^2+1,0,[0.2,0.2])

       The "else" part of the "if" function can be entirely omitted.
       if (a,1) is now correct; of course, the former syntax if (a,1,) is
       still valid.

   * functions "extern" and "system" have been added to interface with
     external programs (UNIX only). You can do for instance
     extern("myprog"), or system("ls -l *.gp").

   * even better, "install" enables you to load any function provided by 
     a dynamically linked library, and have the GP interpreter use it. This 
     makes it easy to have your own customized version of GP with your own set
     of functions on startup (you can document them using "addhelp").

   * On 32-bit machines, maximum number of variables has been increased from
     254 to 16382. Arrays can have up to 16777215 elements (instead of 65535).
     In addition vector/matrix operations in GP now perform orders of
     magnitudes faster than in version 1.39

Karim Belabas                          e-mail:
Max-Planck-Institut fuer Mathematik       karim@mpim-bonn.mpg.de
Gottfried-Claren-Str. 26               tel:
53225 Bonn (Germany)                      (00 49 228) 402-245