Maple V - Maple Help

Online Help

All Products    Maple    MapleSim

New Features in Maple V

Development of Improved User Interfaces


1: X Window interface


A user interface for X Window has been designed.

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.


    > 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

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

6: 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.


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

    > complex(1,2);

                                   1 + 2 I

7: 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 ODEs.

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


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


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


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


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


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


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.


    > 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



 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-D 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

- The rules for last-name evaluation have changed.

   Recall that the purpose of last-name evaluation is to allow vectors,

   matrices and arrays to have one (or more) as yet undefined entries, e.g.

    > A := array(1..2,1..2):

    > linalg[det](A);

                       A[1, 1] A[2, 2] - A[1, 2] A[2, 1]

    > A;


    > op(A);

                              [ ?[1, 1]  ?[1, 2] ]

                              [                  ]

                              [ ?[2, 1]  ?[2, 2] ]

   In Maple V this has been extended to subscripted names e.g.

   replace A by t[1] in the above.

    > t[1] := array(1..2,1..2):

    > linalg[det](t[1]);

                 t[1][1, 1] t[1][2, 2] - t[1][1, 2] t[1][2, 1]

   However, to access the array object one cannot use op, since op(t[1]);

   would then yield 1, the index.

   The way to access the array object now is to use the eval function, e.g.

    > eval(t[1]);

                              [ ?[1, 1]  ?[1, 2] ]

                              [                  ]

                              [ ?[2, 1]  ?[2, 2] ]

   Finally, a reminder not to make the following mistake.

# Interchange matrices A and B

t := A; A := B; B := t;

   If A and B are assigned arrays, tables or procedures, one must write

t := eval(A); A := eval(B); B := eval(t);