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 (for-from-

by-to-while), a new form (for-in-while) 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 for-part

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

index  may  be  tested  in  the while-part 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 pretty-printer: 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

angle-bracket 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 finitely-presented group package

      linalg:     linear algebra package

      np:         Newman-Penrose 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 B-spline 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) floating-point numbers.

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

  than x.

- gcdex(p,q,x,'s','t'):   now  allows p and q to be non-polynomial 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  Euler-Maclaurin  expansions when

  appropriate.

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

  dec-graphics  character set.  Plot can also produce postcript-compatible 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 user-defined 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  left-hand-sides  (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 non-parametric 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 sub-procedures) 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.