Maple 4.0 - Maple Help

Online Help

All Products    Maple    MapleSim




           New features that have been added to Maple for version 4.0


Changes that require modifications to old maple source codes


$:   $ replaces maple's seq function as the repetition operator.

     It can be used in the forms:

              expr $ k=1..n     replaces  seq(expr, k=1..n)

              expr $ n          replaces  seq(expr, n)

              $ m..n            replaces  seq(m..n)


              `$`(expr, k=1..n)

     directly corresponds to the former seq function invocation, yielding

     a "quick fix" for old code using seq:  simply assign  seq := `$`.

mod: mod is now an operator (it is a keyword like and, or, not) so function

     calls of the form mod(expr,p) must all be changed to  expr mod p

     ( or to `mod`(expr,p) ).  The functions modp and mods remain as

     before, and by default `mod` := modp.  Note also that  expr mod p

     remains unevaluated if p is not a numerical constant.

union, intersect, minus:

     The operators used with sets are now "union" (formerly +), "intersect"

     (formerly *), and "minus" (formerly -).  These three operator names

     are keywords in the language.  The symbols +, *, - are now reserved

     for arithmetic expressions only.


     Previously, names beginning with @ were valid in Maple.  Now, @ is

     an operator (used in the operator algebra), and the special character

     used for forming system names is the underscore _ .  It is recommended

     that users refrain from using names beginning with an underscore

     since the system creates and uses such names globally.

internal-format files:

     Internal-format (.m) files created by a previous version of maple

     cannot be read by a newer version.  Such `.m` files must be recreated

     from source.


Subscripted (indexed) names become valid Maple names.

     Previous versions of Maple allowed subscripts (table references)

     to be used only in some places where Maple expects a variable name.

     Now, subscripted names are fully valid names in Maple.  Examples:

            divide(a,b,q[1]);        and        member(a,b,q[1]);

            irem(a,b,q[1]);          and        iquo(a,b,r[1]);

            for t[1] do ... od;      and        seq(..., t[1] = 1..n);

            taylor(..., x[1]);       and        diff(..., x[1]);


            save a[1], a[2], file;

     The definition of type "name" has changed.  What used to be type

     "name" is now type "string".  Type "name" is now defined to be

     either "string" or "indexed".  Thus

              x, x1, x_y, t[1], and t[k]  are all of type name.

Unevaluated functions.

     Some functions return unevaluated.  For example, if A is an array,

     then the array reference  A[k]  does not issue an error if k does

     not have a value.  This allows, for example:


     without having to quote the A[k] to prevent it from evaluating

     prematurely.  This feature applies for any subscript (except for

     a sparse table).  Also, it applies for the following functions:

            coeff(p,x,k)             ==>        coeff(p,x,k)

            op(k,p)                  ==>        op(k,p)

            substring(s,1..n)        ==>        substring(s,1..n)

            a.(1..n)                 ==>        a.(1..n)

            a mod p                  ==>        a mod p

Neutral Operators (&-operators).

     A neutral operator symbol is any string of two or more characters

     that starts with ampersand (&) and may contain any character except

     ()[]{};:'`& or blank.  They may be used as unary prefix operators,

     or infix binary operators, or as function calls.  They generate

     function calls, with the name of the function the same as the name

     of the neutral operator.

New evaluation rules for Locals.

     The evaluation rules for local variables have changed to "one-level"

     evaluation instead of full evaluation.  This means that evaluation

     of local variables is the same as evaluation of formal parameters,

     but different than that of global variables.  For example, suppose

     the input to a Maple session is

              a := b;

              b := 1;


     Then what does last statement yield?  In previous versions of

     Maple  a;  evaluated to 1 .  In this version, if these statements

     are entered in an interactive session (a and b are global variables)

     then  a;  still evaluates to 1 .  However, if a and b are local

     variables and these statements appear inside a Maple procedure, then

     a;  evaluates to  b .  Users should not notice any differences in

     normal usage of Maple.  If, however, it is desired to have full

     evaluation or one-level evaluation explicitly, the eval function

     (see below) provides this functionality.

Explicit remember without option remember.

     Previously, when the remember option was specified in a procedure,

     all computed values were automatically remembered.  In addition,

     it was possible to remember a particular result by an explicit

     call of the form  remember( f(x) = y );  but ONLY if the function

     f had option remember.  In this version of Maple, this can be done

     if f does not have option remember.  This is possible because unlike

     earlier versions, every procedure now has its own remember table.

     This feature allows one to remember some values but not others,

     thus providing greater flexibility.  For example, suppose we want

     to write a procedure for sin(x) that automatically evaluates sin of

     a float to a float but does not remember any of these calculations

     because they would require too much space.  On the other hand, we

     also want to remember that sin(Pi) = 0 etc.  One would do:

            sin := proc(x)

                    if type(x,float) then RETURN(evalf('sin(x)')) fi;






New evaluation function eval for one-level or full evaluation.

     The normal mode of evaluation is "full recursive evaluation".  For

     example, in

              a := b;

              b := 1;


     The variable "a" evaluates to 1.  Sometimes one needs to obtain a's

     "value", that is the object that a points to, namely "b".  The eval

     function via eval(a,1) provides this functionality.  We call this

     "one-level evaluation".  It was previously used by save when saving

     in external format and for the evaluation of parameters, and is now

     also used for local variables.  The eval function works for names,

     subscripted names, local variables, and formal parameters.  Other

     expressions are returned unevaluated.

     In contrast, in some places one wants to evaluate locals and

     parameters fully, in the same mode as global variables.  The eval

     function again provides the desired functionality via simply


New global variable "status".

     This variable returns an expression sequence of length seven, which

     contains (words used, words allocated, time, words used increment,

     gc increment, words collected at last gc, words available at last gc),

     respectively.  The words used message now prints the first three

     status values after every 20000 words used.

The following previously-existing functions are now automatically loaded:


   gcdex          extended Euclidean algorithm for polynomials

   isolve         solve for integer solutions

   mgcdex         extended Euclidean algorithm for polynomials modulo p

   msolve         solve for solutions in the integers modulo p

   resultant      resultant of two polynomials

   testeq         random-polynomial-time equivalence tester

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


   chebyshev      compute the Chebyshev series of a function

   compoly        find a non-trivial composition of a polynomial

   chrem          Garner's Chinese remainder algorithm

   define         define characteristics of an operator

   difforms       differential forms package

   dsolve         differential equation solver

   edit           expression editor (for valid Maple expressions)

   eqn            generation of EQN output for typesetting equations

   eval           one-level or full evaluation of an expression

   `evalf/int`    numerical integration for a definite integral

   fixdiv         compute the fixed divisor of a polynomial

   fsolve         floating-point equation solver

   grobner        package for Groebner basis computations

   igcdex         extended Euclidean algorithm for integers

   interp         polynomial interpolation

   iroot          the nth root of an integer

   laplace        Laplace transforms and inverse Laplace transforms

   linalg[bezout] create Bezout matrix from polynomials a(x) and b(x)

      [genmatrix] generate coefficient matrix from a linear system

      [ismith]    determine the Smith normal form for an integer matrix

      [smith]     determine the Smith normal form for a polynomial matrix

   maxnorm        the infinity norm of a polynomial (max abs of coeffs)

   mfactor        polynomial factorization over integers modulo p

   minterp        polynomial interpolation modulo p

   mres           modular resultant in Zp[x]

   mtaylor        multivariate Taylor series

   optimize       common subexpression optimization

   powseries      formal power series package

   priqueue       priority queue facility

   proot          the nth root of a polynomial

   realroot       isolating intervals for real roots of a polynomial

   residue        compute the algebraic residue of a function

   round          round a number to an integer

   rsolve         recurrence equation solver

   signum         sign of a real or complex number

   simplex        package for linear optimization, including functions

                     such as feasible, maximize, minimize, pivot

   simplify       general purpose simplifier

   sinterp        sparse polynomial interpolation

   sort           general purpose sorting routine (uses shellsort)

   symmpoly       test for symmetric polynomial

   translate      evaluate a polynomial p(x) at x = x+t

   write          primitive facility for file output

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


   convert/confrac  new case: convert ratpoly to confrac

   convert/ratpoly  new case: Chebyshev-Pade approximation

   degree,ldegree   new functionality allows for the total degree, both

                      lexicographic and homogeneous ordering

   eulermac         using a better algorithm

   evalf            maps onto parts of a general expression;  when applied

                      to an unevaluated int, performs numerical integration

   gc               now prints the first three status values

   has              has(x,y) or has(x,z)  becomes  has(x,[y,z])

   intbound         deleted (new name is maxnorm)

   length           now computes the length or size of any object

   limit            improved functionality

   minimize         solve a system of linear inequalities, using the

                      simplex algorithm;  improved algorithm

   save             now allows subscripted names and unassigned names

   seq              functionality  seq(f(i),i=n..n+3)  no longer allowed;

                      the range values must be constants;  the syntax now

                      uses the $ operator:  f(n+i) $ i=0..3

   solve            several syntax and functionality changes;  new routine

                      `solve/float` for linear systems with floating-point

                      coefficients;  substantial improvements all around

   Psi1, Psi2, ...  Psi.n        becomes Psi(n,x)

   tdegree          deleted (see degree)

   type/linear      type(expr,linear,...) is defined to be

                      type(expr,polynom,...) and degree(expr,...) = 1

   type/quadratic   type(expr,quadratic,...) is defined to be

                      type(expr,polynom,...) and degree(expr,...) = 2

   type/polynom     type(expr,polynom,integer), type(expr,polynom,rational)

                      and type(expr,polynom,numeric) mean that expr is a

                      polynomial over the domain of integers, rationals, or

                      reals, respectively;

                    type(expr,polynom,a[1])  is now valid as is


                    type(expr,polynom,integer[x,y,z]) becomes


   type/ratpoly     is available with argument sequences as in polynom

Internal efficiency improvements:


   coeff            avoid unnecessary copying for products;  avoid

                      unnecessary fragmentation for sums

   diff             special code for polynomials and series;  avoid

                      unnecessary fragmentation for sums

   divide           trial division is now performed over the integers

                      rather than over the rationals;  remember table

                      is used for successful polynomial divisions;

                      to divide out a polynomial by its icontent, do:

                      divide(p,icontent(p),'p');  not  p := p/icontent(p);

   expand           special code for recognizing monomials;  includes a

                      better algorithm for large univariate polynomials

   for-loops, $     improved for small ranges

   frontend         now includes a check for the common case where no

                      "freezing" is required, thus avoiding allocation of

                      linear space which is non-garbage-collectible;  the

                      fourth argument option has been deleted

   genpoly          now encoded internally so as to use linear space;

                      doing one integer division has doubled the speed

   maxnorm          now encoded internally so as to use constant space;

                      extended functionality for series and products

   member           now internal for direct access to the elements

   read             the following maple expressions can now be read from

                      source format in linear space:

                           lists, sets, sequences, tables,

                           sums, products, functions

   set union,intersect,minus

                    now using variations of merging rather than bubblesort

   sets             sorting using shellsort rather than bubblesort

   simpl            sort sums of length > 20 terms using shellsort during

                      the collection of like terms

   table            sorting for the indexing functions symmetric and

                      antisymmetric has been improved to use shellsort

   taylor           special code for converting a polynomial into a series;

                      improved code for sums;  improved increment sequence

                      for shellsort (used to sort exponents);  using

                      Horner's rule for evaluation of a dense univariate

                      series with integer coefficients at an integer

   type/polynom     now does one pass rather than n passes where there are

                      n indeterminates