
				MAPLE

The following list of machines for Maple is almost up to date.
See address at bottom to obtain further information.


                       Availability of MAPLE
                       ---------------------

Machine                Operating System     Version  Distributor
-------                ----------------     -------  -----------

Amdahl S/370 family    UTS/V 1.1            4.2      WMS
Amiga 1000             Amiga DOS            4.2      WMS
Apollo 3000, 570, 580  Domain IX 9.2        4.1      WMS
Apollo 10000                                4.2      WMS
Atari ST                                    4.2      WMS
ATT 7300, 3B1          Unix V.2             4.1      WMS
Convex                 Convex Unix          4.2      WMS
Cray 2                 Unicos               4.0      WMS
DEC Microvax           Ultrix 32m           4.2      Watcom
DEC Vax 11             4.2 or 4.3 BSD Unix  4.2      Watcom
DEC Vax 11             VMS 4.4 or 4.5       4.1      Watcom
Gould NPI              Unix                 4.1      WMS
Gould DN 9082          Unix                 4.2      WMS
IBM 43xx               VM/SP CMS Rel 4      4.2      Watcom
IBM S/370 family       Amdahl UTS/V 1.1     4.2      Watcom
IBM RT                 AIX 1.1              4.2      WMS
Macintosh Plus,SE      MPW 1.0B2            4.2      WMS
Macintosh Plus,SE,II   Finder               4.2      Brooks/Cole (N.America)
Macintosh Plus,SE,II   Finder               4.2      WMS (outside N.America)
Masscomp 5xxx          Unix                 4.0      WMS
NCR Tower              Unix                 4.2      WMS
PCS Cadmus             Munix                4.1      WMS
Pyramid 96xx           Unix                 4.1      WMS
Sequent Balance        Dynix                4.2      WMS
Sequent Symmetry       Dynix                4.1      WMS
Sun 3                  Sun Unix 3.0         4.2      WMS
Sun 4                  Sun OS Unix          4.2      WMS

For information on the availability of Maple on these or other machines,
please contact:

          Waterloo Maple Software
          608 Weber St. N.
          Waterloo, Ontario                  wmsi@watmum.uwaterloo.ca
          Canada N2V 1K4                     wmsi@watmum.waterloo.edu
          (519) 747-2373                     wmsi@watmum.watmath.uucp

			
				MAPLE   V

We are proud to announce the availability of a new version of Maple, version V.
(for those of you waiting for version 4.4, we have renamed it version V)
Maple V represents a major step forward in the capabilities of Maple.
We'd like to thank everyone, especially people from outside the group,
who have contributed.

Maple V incorporates a new user interface for the X Window System that includes
3-D plotting, command line editing, and maintains a log of a Maple session.
We are also nearing the completion of a SunView interface for Maple V.

As with previous new versions of Maple, Maple V also includes many new
mathematical facilities.
There are 11 new applications packages including 4 tensor packages.
Maple V includes many efficiency and algorithmic improvements,
and other improvements to the capabilities of the existing facilities.

A list of the new facilities and improvements, together with examples
in Maple V, will be given in a separate message on sci.math.symbolic.

The generic version of Maple V and the X version are being presently
distributed for the following systems:

	Sun-3
	Sun-4
	SparcStation
	MIPS RS2030, RC3240, RC3260, RC6280, M/2000

SunView users who order now will receive the SunView interface as soon
as it becomes available.
Maple V versions for the following systems (generic and X interface)
are near completion:

	DEC Vax (Ultrix or BSD)
	DEC Microvax (Ultrix)
	DEC station 2100, 3100, 5000, 5400, 5800 (Ultrix)

Academic discounts, site licenses, and the library source code are
also available.
To order and for further information about Maple V, please contact:

Waterloo Maple Software,
160 Columbia Street West,
Waterloo, Ontario,
Canada, N2L 3L3

Phone: (519) 747-2373			wmsi@daisy.uwaterloo.ca
Fax: (519) 747-5284			wmsi@daisy.waterloo.edu


This is a list of the new facilities and improvements made to Maple V.
For information about Maple V please contact Waterloo Maple Software at

I also have a LaTeX version of this document.  If anyone would like a copy,
just let me know and I will send it to you by email.
Many thanks to all who contributed.

Mike
monagan@inf.ethz.ch


           New features that have been added to Maple for version V
           --------------------------------------------------------

Development of Improved User Interfaces
=======================================

1: X Window interface
---------------------
A user interface for X Window has been designed.
The user interface program is a separate process which can be run
on a local workstation while Maple runs on a remote system.
The X Window user interface provides separate help and plot windows,
allows editing of input expressions, maintains a log of a Maple session,
and supports an assortment of other options.  The various methods of
setting defaults, key bindings, etc. are documented in the help file
for X11. 

2: 3-Dimensional graphics
-------------------------
Maple V supports 3-D surface plots under several software platforms,
including X Window.  Printed output is provided for a variety of printers,
including Postscript devices.
Surfaces can be described either by a single function of two variables
or parametrically.  The coordinate system can be either cartesian, spherical,
or cylindrical.  The surface can be rendered as surface patches, a wire frame
plot (with optional hidden line removal), or a collection of points.
There is also a "plots" package which contains a number of specialized
plotting facilities e.g. matrix plots, conformal plots, tube plots etc.
Additional documentation is available on-line for the plots package.


3: New arrow syntax for specifying operators (functions)
--------------------------------------------------------
In addition to the "proc ... end" and the angle bracket < ... > notations
for defining functions (procedures), the following "arrow" notation
has been adopted as an alternative syntax

    f := x -> x^2
    g := (x,y) -> sin(x+exp(y))

4: Sorting polynomials
----------------------
Expressions in Maple are usually stored in the order they were created.
Consequently polynomials often appear in a seemingly random order.
The sort command can now be applied to sort any polynomials that appear
in an expression.  Univariate polynomials are sorted in descending order.
Multivariate polynomials may be sorted by "total degree" (default) with
ties broken by lexicographical order, or in pure lexicographical order.
An optional argument may be given to specify the variable ordering.
Example: 

    > a := y^3+y^2*x^2+x^3;
                                    3    2  2    3
                              a := y  + y  x  + x
    > sort(a,[x,y],tdeg);
                                 2  2    3    3
                                x  y  + x  + y
    > sort(a,[x,y],plex);
                                 3    2  2    3
                                x  + x  y  + y

4: Improved display of output
-----------------------------
The output of matrices, vectors, and repeated composition has been improved.
Example: compute a Taylor series expansion for an unknown function F

    > s := taylor(f(x),x=0,4);

                                  (2)        2        (3)        3      4
     s := f(0) + D(f)(0) x + 1/2 D   (f)(0) x  + 1/6 D   (f)(0) x  + O(x )

    > linalg[vector]( 4, i -> coeff(s,x,i-1) );

                                     (2)             (3)
               [ f(0), D(f)(0), 1/2 D   (f)(0), 1/6 D   (f)(0) ]

5: User defined formatting routines
-----------------------------------
Maple's pretty printer understands how to display certain objects such as
polynomials, plots, matrices, vectors, integrals, subscripts, etc.
Users may now specify how their own functions are to be displayed as follows:
To format a function foo(...) the user may assign to the name
`print/foo` a Maple procedure.  The Maple procedure will be invoked
during output of a Maple expression once for each different instance
of foo in the output.  The procedure can return any expression.
Example: 

    > `print/complex` := proc(r,i) r+i*I end:
    > complex(1,2);
                                   1 + 2 I

6: New help syntax and user defined help routines
-------------------------------------------------
Help is now also available using the ? syntax.
For example, to get help for the mod operator, one types simply
    > ?mod 

The searching component of the help system has been much improved.
The help files themselves now include the actual Maple output.
The user may tell Maple how to generate help for a function "foo"
by assigning the name `help/text/foo` to a TEXT object, e.g.

    > `help/text/foo` := TEXT(`this is line 1`, `and this is line 2`):
    > ?foo 

    this is line 1
    and this is line 2


New and enhanced mathematical facilities
========================================

1: New Mathematical functions known to Maple
--------------------------------------------
- Complementary error function erfc(z) = 1-erf(z)
    (diff/erfc, limit/erfc, evalf/erfc, series/erfc)
- Airy wave functions Ai(x) and Bi(x) (evalf/Ai, evalf/Bi)
- The 3 argument limiting case only of the Meijer G function
    (diff/MeijerG, evalf/MeijerG, series/MeijerG)
- The Dirac delta function Dirac(x) and its derivatives Dirac(n,x)
- The generalized Riemann Zeta function Zeta(0,x,s)
    and its derivatives Zeta(n,x,s).

2: Enhanced numerical facilities
--------------------------------
- Asymptotic series are now used to numerically evaluate the following
    functions for large x: Si(x) and Ci(x) (Sine and Cosine integrals), Ai(x)
    and Bi(x) (Airy wave functions), erfc(x) (complementary error function),
    BesselJ and BesselY (Bessel functions J(v,x) and Y(v,x)).
- Evalf of sum(f(r),r=RootOf(a(x),x)) sums f(r) over the
    complex roots of a polynomial a(x).
- Dsolve has been extended to use a Runga Kutta based numerical method for
    solving initial value ODE's.
- The library routines shake and evalr provide a model of interval arithmetic
    which is used for simplifications of signum of exact real constants.

3: Enhanced integration facilities
----------------------------------
Definite integration has been extended to handle more
integrands of the following form:

     int( R(t)*exp(-u*t^s)*ln(b*t)^m*cos(c*t^r), t=a..infinity )
                                  or sin

where r in {0,s,2*s,s/2} and other restrictions on the constants apply.
In general these integrals can be expressed in terms of the Gamma function,
incomplete Gamma function GAMMA(a,x), and the Polygamma function Psi(x),
the Riemann Zeta function Zeta(x), the error function and Fresnel integrals,
and the Meijer G function.
Examples where R(t) is a power of t (possibly negative and/or fractional):

    > int( exp(-t^2)*cos(2*t)*t^2, t=0..infinity );

                                      1/2
                              - 1/4 Pi    exp(-1)

    > int( exp(-sqrt(2*Pi)*t)*sin(t^2), t=0..infinity );

                       1/2   1/2        1/2   1/2
                  1/4 2    Pi    - 1/2 2    Pi    FresnelS(1)

    > int( exp(-t)/t^(1/3), t=1..infinity );

                                 GAMMA(2/3, 1)

    > int( exp(-t)*ln(t)/t, t=1..infinity );

                                MeijerG(3, 0, 1)

    > int( exp(-t)*ln(t)/t^(1/2), t=1..infinity );

                               MeijerG(3, 1/2, 1)

Maple can do some cases where the denominator of R(t) is of the
form 1-exp(-v*t^s), e.g.

    > int( exp(-t)*t^2/(1-exp(-2*t)), t=0..infinity );

                                  7/4 Zeta(3)

And also a few cases where R(t) includes an error function, e.g.

    > int( t*exp(-t^2)*erf(2*t+1), t=0..infinity );
                                                      1/2   1/2
                 1/2 erf(1) + 1/5 exp(-1/5) erfc(2/5 5   ) 5

    > int( ln(2*t^2)*erf(t/2)/t^(3/2), t=0..infinity );

                          1/2          1/2         1/2
                  ln(2) Pi           Pi          Pi    Psi(1/4)
                6 ----------- + 8 ---------- + 2 --------------
                   GAMMA(3/4)     GAMMA(3/4)       GAMMA(3/4)

4: The derivative operator D
----------------------------
The D operator has been extended to handle partial derivatives.
The notation D[i](f) means the derivative of f with respect to the
i'th argument.  The chain rule is applied and by default and it is
assumed that partial derivatives commute.  Examples:

    > g := (x,y) -> sin(x+cos(y)):
    > D[1](g);
                            (x,y) -> cos(x + cos(y))

    > D[1,2](g);
                        (x,y) -> sin(x + cos(y)) sin(y)

Consequently the mtaylor function (for multivariate Taylor series)
will now expand an unknown function of more than one argument, e.g.

    > mtaylor(f(x,y),[x=0,y=0],3);

                                                                         2
     f(0, 0) + D[1](f)(0, 0) x + D[2](f)(0, 0) y + 1/2 D[1, 1](f)(0, 0) x

                                                         2
          + D[1, 2](f)(0, 0) x y + 1/2 D[2, 2](f)(0, 0) y

5: Enhanced limit and series facilities
---------------------------------------
Asymptotic series have been extended to allow exponential terms
to appear in the resulting series.  Example:

    > asympt( Psi(2*exp(x))-x, x, 4 );

                               1           1            1
                   ln(2) - -------- - ---------- + O(-------)
                           4 exp(x)            2           4
                                      48 exp(x)      exp(x)

    > limit( Psi(2*exp(x))-x, x=infinity );

                                     ln(2)

Series expansions for erfc(x), GAMMA(a,x) for a > 0, and MeijerG(a,b,x)
for a > 1, a an integer have been added.  Also asymptotic expansions
for the GAMMA and binomial functions have been added.  Examples:

    > asympt( GAMMA(x)*Ei(x)/x^x/sqrt(2*Pi), x );

         1       13        601       319721        60973877         1
       ---- + ------- + -------- + ---------- + ------------- + O(-----)
        3/2       5/2        7/2          9/2            11/2      13/2
       x      12 x      288 x      51840 x      2488320 x         x

    # An indefinite summation using Gosper's algorithm
    > s := sum( binomial(2*n,n)/(n+1)/(2^n)^2, n );

                                     binomial(2 n, n)
                          s := - 1/2 ----------------
                                          (n - 1) 2
                                        (2       )

    > asympt(s,n,3);

                    2             1              1             1
             - ---------- + ------------ - ------------- + O(----)
                 1/2  1/2       1/2  3/2        1/2  5/2      7/2
               Pi    n      4 Pi    n      64 Pi    n        n

    # Hence since s = -2 at n = 0, we have
    > sum( binomial(2*n,n)/(n+1)/(2^n)^2, n=0..infinity );

                                       2

6: Definite sums and products over roots of polynomials
-------------------------------------------------------
Let alpha denote the set of roots of the polynomial a(x).
In Maple, the roots of a(x) are expressed as RootOf( a(x), x ).
Let sum(f(k),k=alpha) mean the sum of f over the roots of a(x).
Likewise let product(f(i),k=alpha) be the product of f over the roots of a(x).
Then Maple can evaluate such sums and products when f is a polynomial
or rational function in k, e.g.

    > alpha := RootOf(x^5+x+11,x):
    > sum( 1/(k^2+1), k=alpha );
                                      35/57

    > product( k^2+1, k=alpha );
                                      1/171

7: Polynomial factorization and root finding
--------------------------------------------
The factor command now accepts an additional argument,
an algebraic extension which specifies an algebraic number field
over which the polynomial is to be factored.
The extension can be specified as a single RootOf or radical,
or in the case of multiple extensions, a list or set of such.
Example: factor the polynomial y^4+2 over Q(sqrt(2))

    > factor(y^4-2,sqrt(2));

                              2    1/2    2    1/2
                            (y  + 2   ) (y  - 2   )

    > alias(alpha = RootOf(x^2-2));
    > factor(y^4-2,alpha);

                             2            2
                           (y  + alpha) (y  - alpha)

An algebraic extension can also be given to the roots and irreduc functions.
Similarly for finite fields (see below).

8: Arithmetic over finite fields (Galois fields)
------------------------------------------------
A special representation for univariate polynomials over finite fields
defined by a single algebraic extension over Z mod p has been implemented.
The new facility includes support for computing polynomial gcd's,
factorization and root finding.  It is accessed via the mod function.
Example: factor the polynomial x^6+x^5+x^4+x^3+1 over GF(2) then GF(4)

    > f := x^6+x^5+x^4+x^3+1:
    > Factor(f) mod 2;
                             2            4
                           (x  + x + 1) (x  + x + 1)

    > alias(alpha=RootOf(x^2+x+1)):
    > Factor(f,alpha) mod 2;

                     2                                    2
       (x + alpha) (x  + x + alpha + 1) (x + alpha + 1) (x  + x + alpha)

An algebraic extension can also be given to
the Roots and Irreduc functions, e.g.

    > Roots(f,alpha) mod 2;

                          [[alpha, 1], [alpha + 1, 1]]

Future work will see the functionality extended to multivariate polynomials
and/or over finite fields defined by multiple algebraic extensions.

9: Transforms
-------------
The Mellin, Z, and discrete fast Fourier transforms have been added to the
library.  The Mellin transform of f(t) is

     g(s) = int( f(t)*t^(s-1), t=0..infinity )

The Z transform for f(n) is

     g(z) = sum( f(n)/z^n, n=0..infinity )

The discrete Fourier transform of a complex vector $z$ is the vector

     [ sum( exp(-2*Pi*j*k*I/n )*z[k], k=0..n-1) for j=0..n-1 ]

The Laplace transform package has been taught about Bessel functions.


New library functions
=====================

ellipsoid: surface area of an ellipsoid
evalr: evaluation over a range(s)
fnormal: floating point normalization
galois: computes the galois group of a (univariate) polynomial (up to degree 7)
history: a history mechanism (an alternative to Maple "'s)
iratrecon: rational reconstruction
mellin: mellin transform
poisson: poisson series expansion
irreduc: irreducibility test of a (multivariate) polynomial
roots: computes the roots of a (univariate) polynomial
shake: real interval arithmetic (to Digits precision)
sturm: use the Sturm sequence to find the number of real roots in an interval
sturmseq: compute the Sturm sequence of a polynomial over Q or R
thiele: continued fraction interpolation
userinfo: generate user information
ztrans, invztrans: the Z-transform and it's inverse

C: Maple to C language translator
FFT: Fast Fourier transform
Hermite: computes the Hermite normal form of a matrix over a finite field
Irreduc: irreducibility test of a (univariate) polynomial mod p
MOLS: generates mutually orthogonal Latin squares
Nullspace: computes the nullspace of a matrix over a finite field
Primitive: tests if a univariate polynomial over a finite field is primitive
Randpoly: random univariate polynomial of degree k mod p
Randprime: random monic irreducible univariate polynomial of degree k mod p
Smith: computes the Smith normal form of a matrix over a finite field


New library packages
====================

1: bianchi (3-d Lie algebra classification package)
2: cartan (special-purpose relativity tensor package -- Cartan's formalism)
3: debever (special-purpose relativity tensor package -- Debever's formalism)
4: finance (amortization and Black Scholes stock call option pricing)
5: geom3d (3-d geometry package)
6: heap (priority queue data structure)
7: liesymm: (Lie symmetries package -- obtains the determining equations for
        the Lie symmetries of a system of partial differential equations)
8: logic (boolean algebra package)
9: oframe (orthonormal frame package using the Ellis-MacCallum formalism)
10: petrov (Weyl tensor classification package)
11: plots (2-d and 3-d special plots package)
12: tensor (relativity tensor package)


New functionality in library packages
=====================================

1: linalg (linear algebra package)
----------------------------------
backsub -- back substitution in an augmented triangular matrix
companion -- constructs the companion matrix for a monic polynomial
concat -- concatenate matrices and/or column vectors together
ffgausselim -- "fraction-free" Gaussian elimination
gausselim -- changed to do "ordinary Gaussian elimination" over a field
GramSchmidt -- Gram-Schmidt orthogonalization
innerprod -- the inner product of a sequence of matrices and vectors
JordanBlock -- constructs a Jordan block matrix
linsolve -- extended to solve A*X = B where B is a matrix
matrix -- utility routine for creating a matrix
minor -- utility routine for picking off the i,j'th minor of a matrix
randmatrix -- utility routine to generate matrices with random entries
pivot -- do one row elimination step on a matrix
stack -- stack matrices and/or row vectors on top of each other
vector -- utility routine for creating a vector
rank, rowspace, colspace -- generalized to work for rational functions
eigenvects -- has been modified to return a sequence of lists of the form
     [e[i],m[i],{v[i,1],...,v[i,n[i]]}] where e[i] is the eigenvalue,
     m[i] it's multiplicity, and {v[i,1], ..., v[i,n[i]]} a set of vectors
     for the basis for the eigenspace of e[i].  It has also been
     generalized to work for a matrix over any algebraic number field.

2: combinat (combinatorial functions package)
---------------------------------------------
character -- character table for Sn the symmetric group on n letters
cartprod -- iterator for the cartesian product of two lists
fibonacci -- extended to compute the fibonacci polynomials F[n](x)
numbcomb -- replaces combinations (computes the number of combinations)
numbpart -- replaces partitions (computes the number of partitions)
numbperm -- replaces permutations (computes the number of permutations)
randcomb -- generate a random combination of m objects from s objects
randpart -- generate a random partition of and integer
subsets -- iterator for a powerset (iterates over the subsets of a set)
vectoint, inttovec -- bijection of the monomials represented as exponent
     vectors using the total degree reverse lexicographical ordering
     with the non-negative integers

3: numtheory (number theory package)
------------------------------------
mipolys(n,p,k) -- computes the number of monic irreducible polynomials
          of degree n over a finite field with p^k elements
sigma -- now accepts a subscript sigma[k](n) and computes
          the sum of the kth powers of divisors
order(n,m) -- solves n^k == 1 mod m for the first integer k > 0

4: stats (statistics package)
-----------------------------
Added random variate generators for the following distributions:
RandUniform(a..b): Uniform distribution on [a,b)
RandNormal(u,s): Normal distribution with mean u, standard deviation s
RandExponential(l): Exponential distribution with mean l
RandGamma(a): Gamma distribution of order a
RandBeta(a,b): Beta distribution of order a and b
RandChiSquare(v): X-square distribution with v degrees of freedom
RandFdist(v1,v2): F-distribution with v1 and v2 degrees of freedom


New and enhanced system facilities
==================================

1: Type testing in Maple V
--------------------------
In Maple version 4.3, we extended the notion of a "type" to include
"structured" types.  A structured type is a Maple expression that describes
the type of a composite object.  The type "set" specifies a set,
but not the type of the objects in the set.  The type set(`=`) however
specifies a set of equations.  And the type set(name=algebraic)) specifies
a set of equations whose left hand sides are (variable) names, and whose
right hand sides are algebraic expressions.
In Maple V, all types are now structured types.  The old polynomial type test
        type( p, polynom, [x,y], rational )
which tests if p is a polynomial in x and y with rational coefficients becomes
        type( p, polynom(rational,[x,y]) )
Because all types are now single objects, one can describe the type of
arbitrarily complex objects very concisely.  For example, the type
        matrix( polynom(algnum), square )
specifies a square matrix whose entries are polynomials
(in any number of variables) over an algebraic number field, and the type
        [ exp(anything}, {name,name=constant..constant} ]
specifies a list of exactly two objects, the first an exponential
(of any type), the second either a variable name, or an equation of the
form indicated -- the set brackets denote alternation.
For a more detailed description see type[structure].

2: Debugging facilities
-----------------------
On an ERROR condition, if printlevel is higher than 1 the
statement being executed and the values of the local variables
are all printed.

3: Sequences and for loops
--------------------------
A new "seq" operator (for constructing sequences) has been added to
the language.  It has the same evaluation semantics as the Maple for loop
and as such should be easier to use and understand than the $ operator
which it will eventually replace.  There are two versions, modelled
on the two kinds of for loops as indicated by the comments below.

    > s := seq( bernoulli(i), i=1..10 ); # for i to 10 do bernoulli(i) od;

             s := -1/2, 1/6, 0, -1/30, 0, 1/42, 0, -1/30, 0, 5/66

    > seq( abs(x), x=s ); # for x in s do abs(x) od;

                  1/2, 1/6, 0, 1/30, 0, 1/42, 0, 1/30, 0, 5/66


4: Table and array entries
--------------------------
Arrays and tables can now be descended (picked apart) using the "op" function.
Hence the only objects in Maple now which cannot be descended are procedures.
In addition to the indices function (which computes a sequence of a tables
indices (keys)) the entries function computes a sequence of a tables entries.
Example: 

    > t := table([red = rot, blue = blau, yellow = gelb, grey = grau]):
    > indices(t);
                        [blue], [yellow], [grey], [red]
    > entries(t);
                         [blau], [gelb], [grau], [rot]
    > op(op(t));
              [blue = blau, yellow = gelb, grey = grau, red = rot]

5: Procedure execution
----------------------
This version includes a new implementation of non-local goto's
(as generated by ERROR, RETURN, interrupts and system errors).
The new implementation results in a lower overhead for procedure invocation.
Simple procedure calls execute 4 times faster in Maple V

6: Language translation facilities
----------------------------------
The library routine C translates Maple expressions and arrays into C code.
There is an optional code optimization facility.
The library routine fortran has been fixed to break up expressions
which exceed the 19 line continuation limit of Fortran.
The library routine latex for typesetting Maple output in TeX now handles
products, composition, vectors, tables and some operators.
The library routine eqn for troff output now handles products and operators.


Algorithmic improvements
========================

1: Polynomial gcd's
-------------------
Univariate polynomial gcd's over the integers are now computed using the
following modular method.  For n word size prime moduli p[1], ..., p[n], the
gcd is computed over Z/(p[k]) efficiently using in-place machine arithmetic.
The n modular gcd's are then combined by application of the Chinese remainder
theorem.  This new method is an order of magnitude more efficient for large
problems.  This improves the performance of arithmetic in Q(x).

2: Polynomial resultants
------------------------
Bivariate polynomial resultants over the integers are now computed using using
the following modular method.  For n word size prime moduli p[1], ..., p[n],
the resultant is computed in Z/(p[k])[x,y], and these images are combined
using the Chinese remainder theorem.  Each resultant calculation in
Z/(p)[x,y] is reduced to d resultant calculations in Z/(p)[x] by polynomial
evaluation and interpolation.  This method (due to George Collins)
gives better performance for polynomials of large degree.

3: Arbitrary precision floating point arithmetic
------------------------------------------------
A routine for evaluating hypergeometric functions to arbitrary precision
has been added to the kernel.
Since an elementary function can be expressed as a hypergeometric function,
this routine is used to evaluate elementary functions as well.
The time to compute sin(1) and ln(3) to 1000 digits, for example, is reduced
from 70 to 26 and 120 to 8 seconds respectively on a Sun 3/280 computer.

4: Computation of Pi
--------------------
Maple is now using the Chudnovsky's formula for computing Pi to high precision.
Their formula is
                     infinity
                      -----
 1        6541681608   \   (  13591409     )     (6*k)!         (-1)^k
---  =  --------------  )  (----------- + k) -------------- -------------
 Pi      640320^(3/2)  /   (  545140134    )  (3*k)!*(k!)^3  640320^(3*k)
                      -----
                      k = 0

To implement this formula, the series has been expressed as a 4, 3 argument
hypergeometric function which is computed using the routine mentioned in point
3 above.  This method is about 30% faster in Maple than the previous method
(a similar formula due to Ramanujan).

5: Integration of rational functions
------------------------------------
Integration of rational functions now returns a sum of logarithms over the
roots of a polynomial a(x) of smallest possible degree in the form

   sum( f(alpha)*log(x+g(alpha)), alpha=RootOf(a(x)) )

The resulting sum, if evaluated in floating point, will be expressed
as an explicit sum of logarithms over the complex roots of alpha.
The above can also be manipulated as a function of x, i.e.
differentiated, expanded as a series in x etc.
The new form is much more concise and usable than the old technology
which produced a "mess" of nested radicals.

6: Polynomial root finding over finite rings
--------------------------------------------
The Roots function has been extended to work for a composite modulus n.
The roots are computed mod each prime factor of n then lifted using padic
lifting and combined by application of the Chinese remainder theorem.
The result returned is a list of the roots and their multiplicities.
Example: find the roots of the polynomial x^2 mod 72
    > Roots(x^2) mod 72;

             [[36, 2], [24, 1], [12, 1], [60, 1], [0, 2], [48, 1]]


Miscellaneous changes
=====================

- Maple no longer has two representations for the complex unit i .
   The unique representation is (-1)^(1/2) and the symbol I is initially
   an alias for (-1)^(1/2).
- Radical powers of rationals are now automatically reduced, e.g.

    > (2/3)^(-3/2);
                                      1/2  1/2
                                 3/4 3    2

- Different radicals are no longer automatically combined so as to
   preserve a canonical form.  The combine function can be used to
   combine radicals except the imaginary constant I, e.g.

    > a := I+2^(1/2)+3^(1/2):
    > a := expand(a^2);
                                 1/2        1/2      1/2  1/2
                   a := 4 + 2 I 2    + 2 I 3    + 2 2    3

    > combine(a,power);
                                 1/2        1/2      1/2
                        4 + 2 I 2    + 2 I 3    + 2 6

- The library routine userinfo can be used to generate user information
   messages for a function during the course of a computation.
   In future versions of Maple, this facility will be exploited in the
   Maple library to generate information about what Maple is doing.
- The library routine log has been extended to allow for different bases.
   The syntax is log[b](x) meaning log base b of x.
- The mtaylor function (multivariate taylor series)
   now returns a Maple sum of products and accepts integral weights
   for the variables.
- Addition of norm and trace operations to GF (Galois Field package)
- Addition of Bessels equation to dsolve.
- The solve command for solving systems of equations now accepts
   an additional argument "split" which directs solve to try to split a system
   into one or more simpler systems using factorization at every step.
- The coeff function has been extended to understand coeff(p,x^n) for n<>0
   to be equivalent to coeff(p,x,n) meaning the coefficient of x^n in p.
- The alias and macro facilities no longer affect parameters and locals.
   I.e. one can have an alias I and a local variable I simultaneously.
   Also, alias now will return a sequence of all current alias's.
- The POINT option in the 2-dimensional plotting has been improved
   to print crosses + instead of dots.
- Map map's onto named arrays and tables, e.g. map(simplify,A);
   i.e simplify each entry in the array
- All entries of an antisymmetric array can now be assigned.
- Saving procedures in src format inserts back-quotes where necessary.
- Since the neutral operator &* is being used for matrix multiplication
   it has been given the same precedence as * (multiplication)
- New Iris variable "endcolon" returns true iff the last statement was
   terminated with a colon (instead of a semi-colon).
- These functions that previously existed are now readlib defined:
   allvalues, compoly, discrim, eqn, fortran, latex, norm, plot3d, select.
- The semantics of the read statement inside a Maple procedure has changed
   from stacking the input to reading and executing the input immediately.
- The rsolve function now takes an optional directive "ztrans" to solve
   recurrences or systems of recurrence equations using Z transforms.
- The rsolve function can now solve a large class of 1st order equations
   and more complicated nonhomogeneous linear equations, e.g.

    > rsolve( {y(n) = n*y(n-1) + (n-1)!, y(0) = 1}, y(n) );

                   GAMMA(n + 1) (Psi(n + 1) + gamma + 1)

- The isolve function (for integer solutions to equations) can now solve
   a single equation of Pythagorean type, i.e. a x^2 + b y^2 + c z^2 = 0 .
   where a, b, c are integers.  In the example below, the % labels stand
   for repeated common subexpressions, and _N1, _N2, _N3 stand for
   arbitrary integers.

    >  isolve(2*x^2-7*y^2+5*z^2);

                 _N3 %1                _N3 %3                _N3 %2
       {z = ----------------, x = ----------------, y = ----------------}
            igcd(%1, %2, %3)      igcd(%1, %2, %3)      igcd(%1, %2, %3)

                               2                    2
    %1 :=               - 5 _N1  - 4 _N1 _N2 + 2 _N2

                                   2        2
    %2 :=                     5 _N1  + 2 _N2

                             2                     2
    %3 :=               5 _N1  - 10 _N1 _N2 - 2 _N2


*************************************************************************************
  
  Announcement: A MAPLE Server Facility 
                -----------------------

  The people involved with the Maple project here at the University of Waterloo
place a heavy demand on computing resources that are available to them.  Howeverthis demand is greatly reduced in the small hours of the morning.  Once computercycles are gone they are gone forever.  Rather than waste these lost cycles, themembers of the project offer to make these resources available for limited 
purposes for the mathematical community.  More specifically, we are offering 
to execute, on a first-come first-served basis,  Maple programs sent to us by
outside users.  This offer is targeted for the following group:

   1) Those that have Maple but run the program on machines that are limited by
      their memory size and thus are unable to complete large jobs.

   2) Those who are running old versions of Maple that either could not solve or      solved  too slowly problems of interest for the user.  It gives the user
      a chance to judge if the newest version has been improved in directions 
      that are of interest to them.

   3) Those users who have problems that they feel should be able to be solved 
      by the computer algebra system that they presently are using, but which 
      presently cannot be solved by their system.  These users would need to 
      get a hold of a book that shows them how to write a Maple program.

   Please note that this is in no way an attempt to draw up a list of the 
advantages of Maple over other systems.  We accept the fact that symbolic
manipulation is not a competition sport.  Each of the computer algebra 
systems such as Maple, Macsyma, Scratchpad, Reduce, Derive, Mathematica and SMP
all have their own individual strengths and weakness's.  

   The gain to the Maple group is some added information about the type of real
problems solved by CA systems along with some directions in which our algorithmsmight be improved.  In addition, Maple is a large system with significant 
development from one version to the next.  By executing code that perhaps has
unacceptable performance on older versions we hope to be able to show off 
improvements to old users (and to ourselves).

   Please send your Maple code via email to 

  mapleserv@watmum.waterloo.edu

   Such programs will be run using the resources at our disposal (Suns, 
Vax's, etc ).  We will run as many programs as the resources allow given
the provision that these programs are running during off hours.  Turnaround
time will depend on the size of the calculation desired and the number of
users wishing to use this service, and is hoped to be about 5 days to a week.
In order to handle as many users as possible we will limit each execution to
at most 10 hours of CPU time.  It would be helpful if we also received 
some indication of the guesstimated amount of time and memory that the 
particular problem might require. For example, users of Maple on small machines
or using older versions of Maple, might provide the type of machine, how long 
their problem ran on the machine and what the memory used message gave at the 
time the program (or the user) gave up. 

       - George Labahn
         Maple Group
         University of Waterloo

