New features that have been added to Maple for version 4.2



Extended syntax of the repetition statement



In addition to the previous form of the repetition statement (forfrom

bytowhile), a new form (forinwhile) has been added. Specifically, the syn

tax of the new form is:

for <name> in <expr> while <expr> do <statseq> od

where any of `for <name>', `in <expr>', or `while <expr>' may be omitted. The

successive values of the loop index (i.e., the <name> specified in the forpart

of the statement) are the successive operands of <expr>. The value of the

index may be tested in the whilepart of the statement and, of course, the

value of the index is available when executing the <statseq>. As in the other

form of the repetition statement, if the `while <expr>' part is present then

the test for termination is checked at the beginning of each iteration.

Notation for inert functions



In general, the convention to represent the inert form of a function is

to capitalize the first letter of the function name. The following inert func

tions are known to the prettyprinter: Int, Sum, and Product. More generally,

inert functions are used when it is desired to control the domain of computa

tion (see next item).

Specifying the domain of computation



The general mechanism to cause a computation to be performed with respect

to a specific coefficient domain is as follows. The function to be computed is

specified in its inert form (by capitalizing the first letter) and then the

appropriate evaluator is applied to the function. At present, this mechanism

is operational for two coefficient domains:

(i) integers modulo m, via the mod operator;

(ii) rational expressions extended by algebraic numbers (specified using the

RootOf notation), via the evala function.

The following inert functions are known to the mod operator and to the evala

function:

Content Divide Factor Gcd Gcdex

Interp Prem Primpart Quo Rem

Resultant RootOf Sprem

Extended prettyprint facility



The prettyprint facility now knows about special symbols for int, sum,

and product (also Int, Sum, and Product, their inert counterparts), and diff.

Furthermore, it now correctly prints expressions involving the following opera

tors: &operators (neutral operators), $, mod, union, intersect, minus, and

anglebracket operators.

New Packages



Several new packages of library functions have been added; the complete

list of packages in this version of Maple is:

difforms: differential forms package

grobner: Groebner basis package

group: permutation and finitelypresented group package

linalg: linear algebra package

np: NewmanPenrose formalism package

numtheory: number theory package

orthopoly: orthogonal polynomial package

powseries: formal power series package

simplex: linear optimization package

stats: statistics package

student: student calculus package

Improved automatic simplifications



The automatic simplification of trigonometric functions with respect to

inverse trigonometric functions has been added.

Improved limit and integration facilities



Much of the limit function has been rewritten to improve its mathematical

power, as well as its efficiency.

The int facility for indefinite integration has been significantly

enhanced by the installation of a complete Risch decision procedure for tran

scendental elementary functions.

The numerical integration facility (`evalf/int`) has been improved to

handle a much wider class of integrands, particularly integrands involving

singularities and infinite limits of integration.

Efficiency improvements



The overall efficiency of Maple has increased about 10%. This has been

achieved by moving a few routines to the compiled kernel as well as by improved

algorithms in the external library.

New functions (use "help(f);" in a Maple session for information about f):



 primpart: primpart(a,x) = a / content(a,x).

 eqn and latex: eqn (rewritten) and latex (new) produce typesetter output

from mathematical expressions.

 singular: Find all singularities of an expression.

 RootOf: The RootOf procedure does basic simplifications. The RootOf func

tion notation is generally a placeholder for representing roots of equations.

 S, C: New math fcns, the Fresnel integrals S(x) and C(x). These functions

are known to various routines, including evalf, diff, taylor, and int.

 bspline: The function bspline(d,v,k) computes the Bspline of degree "d" as

a list of segment polynomials in "v" defined on the knots "k" where "k" is a

list of d+2 numbers or symbols (multiplicities allowed).

 zip: The function zip(f,u,v) zips u and v (two lists or vectors) into a new

list or vector by application of the binary function f to each pair of ele

ments u[i], v[i].

 evala: The evala function is used for evaluation in the domain of rational

expressions extended by algebraic numbers (using the RootOf notation).

 match: for pattern matching.

 student[combine]  This routine is used to rewrite unevaluated Sums and

Integrals as one Sum or Integral.

 student[Eval]  This routine is used to cause unevaluated Sums, Limits, and

Integrals to evaluate.

 student[makeproc]  This is an alternative name for the Maple function unap

ply().

 student[changevar]  This function now handles infinite bounds correctly.

 convert routine in student package: convert(...,nested) rewrites an expres

sion involving functional composition as nested function application; con

vert(...,`@`) rewrites nested function applications using composition of

functions.

Modified functions (use "help(f);" in a Maple session for information):



 mod: The functions `mod`, modp, and mods have been extended to work on

lists, sets, and equations.

 ConvexHull: deleted; now use simplex[convexhull].

 testeq now successfully works for:

(a) square roots when not mixed with trigonometric functions;

(b) nested algebraic numbers and functions;

(c) floatingpoint numbers.

 resultant(p,q,x): now allows p and q to be nonpolynomial in variables other

than x.

 gcdex(p,q,x,'s','t'): now allows p and q to be nonpolynomial in variables

other than x.

 diophant(p,q,r,x,'s','t'): now deleted; see gcdex for this functionality.

 numtheory[jacobi]: improved from cubic time / quadratic space to quadratic

time / linear space.

 asympt: asympt( sum(..), ..) now uses EulerMaclaurin expansions when

appropriate.

 plot: now accepts an ln03 laser printer as a plotdevice and vt100 using the

decgraphics character set. Plot can also produce postcriptcompatible out

put.

 indets: indets(expr,typename) returns all of the subexpressions in expr

which are of type "typename".

 minimize: extended and improved functionality.

 type: type(a, type_set); where type_set is a set of type names, will return

true if a is any one of the types contained in the set.

 type/algnum: test for an algebraic number.

 type/polynom: The code has a user interface allowing for userdefined coef

ficient domains. For example:

type(a, polynom, v, d);

tests whether "a" is a polynomial in the variable(s) "v" with coefficients of

type "d".

 type/ratpoly: The code has the same extension as type/polynom. For example:

type(a, ratpoly, [x,y], algnum)

tests whether "a" is a rational function in the indeterminates "x" and "y"

with coefficients which are algebraic numbers.

 type/point: A point is formally defined to be a set of equations with vari

ables as lefthandsides (identical to the explicit output format of the

solve function). Many functions will now take points as arguments  for

example, limit now accepts points as well as single equations, as in: limit(

1/(x+a), {x=0,a=0} ) .

 int/def: all of the nonparametric definite integrals of the CRC tables have

been included in the definite integration tables (when they are not otherwise

computed by the integration algorithm).

 trace: The trace facility has been improved so that not only entry and exit

points are displayed, but also statements executed within the procedure (but

not in subprocedures) are displayed. Also, option "trace" may be specified

for a procedure (this is the mechanism used by the trace function).

 sum: a new algorithm has been implemented for the summation of tri

gonometrics and exponentials. Also, there is a user interface such that if

`sum/<funcname>` is defined as a procedure then it will be invoked by sum

when the arbitrary function <funcname> is encountered in an expression.

 taylor: When floats are present, all coefficients are now evaluated by

evalf.

 iroots: removed; it is now part of isolve.

 mod functions: The mod functions (names beginning with m) have been deleted;

now use inert (capitalized) function names and the mod operator. I.e.

mfactor > Factor(..) mod p

mgcd > Gcd(..) mod p

mgcdex > Gcdex(..) mod p

minterp > Interp(..) mod p

mquo > Quo(..) mod p

mrem > Rem(..) mod p

mres > Resultant(..) mod p

 solve: improvements include solving inequalities, solving equations contain

ing RootOfs, and solving equations with radicals in a general form.

 solve: solve( identity( <eqn>, x ), <vars> ) solves identities in a single,

given variable. This is equivalent to a powerful pattern matching in one

main variable.

 msolve: special code is now used for solving large systems of equations mod

2.
