Maple 4.3 - Maple Help

Online Help

All Products    Maple    MapleSim




           New features that have been added to Maple for version 4.3


Development of improved user interfaces


      The  user  interface,  known  as  Iris, is programmed separately from the

Maple  "algebra  engine".   Availability of particular features is workstation-

dependent.   All  implementations of Maple include a new version of the pretty-

printer  (see  below)  and a new lexical scanner.  The lexical scanner now pro-

vides  improved error messages, with a caret symbol pointing to the most likely

place  where  a  syntax  error  has  occurred  and  the line number at which it

occurred is also specified (for input from a file).

      Versions  of  Iris  which  exploit  workstation features such as windows,

mouse  selection,  session  history,  and editing have been developed.  An Iris

facility  with  these advanced features is available for the Macintosh and will

soon be released for X-Windows and SunView.

3-D plotting


      A  3-D plotting facility has been developed.  Availability of this facil-

ity  is workstation-dependent.  The 3-D plotting facility will soon be released

for  X-Windows,  SunView, and the Macintosh.  Both 2-D and 3-D plotting exploit

the  new  `evalhf` function (see below) to achieve improved efficiency of point


New prettyprinter


      The  generic  Iris  facility available on all host systems now uses a new

prettyprinter.  The new prettyprinter supports the following:

      1) break on interrupt -- the new prettyprinter is interruptible;

      2) prettyprinting of Maple procedures;

      3) columns of matrices are aligned where possible;

      4) automatic labelling of common subexpressions in large output

          as %1, %2, ... ;

      5) the labelled subexpressions can be used for subsequent input.

Improved help facility


      The  help facility has been improved so that the information is displayed

one screenfull at a time, when such a facility is supported by the host system.

In addition, when the help system fails to find information for the word speci-

fied,  a list of "nearby names" is displayed.  The definition of "nearby names"

is  all names known to help which match the given name in the first three char-

acters.   For example, help(f) will display all names known to help which begin

with  the  letter  f.   A facility to generate examples of Maple expressions is

also available.

Macro and alias facilities


      A  macro facility and an alias facility provide the user with a mechanism

for macros and abbreviations, respectively.  For example, a user may state:


This  allows  the  user  to use the abbreviation J on input, Maple receives the

value BesselJ which it understands, and the abbreviation J will be used on out-


Rule-based facility for function definition


      A  new facility allows functions to be defined via the specification of a

sequence  of  rules  which  will be applied based on pattern and type matching.

For example, the following defines a linear operator:

      define( L, forall( [x,y], L(x+y) =  L(x)+L(y) ),

                 forall( [constant(n),x], L(n*x) = n*L(x) ) );

Operators may also be defined in terms of properties such as commutative, asso-

ciative, antisymmetric, etc.  See help(define) and its subtopics.

Internal support for polynomials over the integers modulo n


      An  internal  routine  called  'modp1' provides support for arithmetic in

Zn[x],  i.e.  univariate polynomials over the integers modulo n.  Modp1 greatly

enhances the performance of many operations including greatest common divisors,

resultants,  and  factorization  of  univariate  polynomials over the integers.

Modp1  is  designed  to  compute  with both small primes (word-size primes) and

large primes.  All the basic arithmetic operations are supported including Quo,

Rem, Eval, Interp, Gcd, Gcdex, Resultant, Discrim, Irreduc, Roots, and Factors.

Modp1  also makes possible an efficient implementation of Galois fields (see GF

and evalgf).

Hardware floating-point evaluation


      A  new  function  'evalhf'  is available.  Like 'evalf' its purpose is to

evaluate  an  expression  in floating-point mode but the new function evaluates

using  the hardware floating-point capabilities (if available) of the host sys-

tem.   In  particular,  it  uses  the fixed-precision numerical accuracy of the

"double  precision" hardware floats.  The argument may be an expression involv-

ing  the invocation of built-in functions or Maple procedures but all data must

evaluate  to  numeric  values  (unlike  evalf  which  allows mixed symbolic and

numeric data).  Evalhf achieves much faster numeric evaluation than evalf which

uses a software floating-point facility.

Numerical computation facilities


      The  numerical  integration  facility `evalf/int` exploits the new evalhf

function to achieve improved speed of execution (at moderate precision require-

ments).   There  have  also  been  functionality  improvements  in singularity-

handling and infinite-range capabilities.  The inert function name Int is known

to  evalf  and  therefore  the  invocation evalf(Int(f,x)) can be used to apply

numerical integration without first invoking symbolic integration.

      New numerical computation facilities include Eigenvals (eigenvalue compu-

tation)  and  Svd  (singular  value  decomposition).  The floating-point solver

(fsolve)  has  been enhanced to handle a wider class of problems, including the

computation of all complex roots of a polynomial.

New mathematical functions and constants known to Maple


- the Bessel functions BesselJ, BesselY, BesselI, BesselK

- the Beta function Beta

- the  generalized  Gamma  constants  gamma(1),  gamma(2),  ...  (replacing the

  former notation gamma1, gamma2, ...)

- the Fresnel integrals C and S have been renamed FresnelC and FresnelS

- the  evalf knowledge of the Psi function has been enhanced to handle the n-th

  derivative Psi(n,x)

- the incomplete GAMMA function

               GAMMA(a,x) = int( exp(-t)*t^(a-1), t = x..infinity)

Enhanced integration facilities


      The  Risch  integration algorithm now handles some cases of radical func-

tions.   The  Risch-Norman  method  is  now applied prior to the standard Risch

algorithm,  providing  a  fast  heuristic method which deals with trigonometric

functions in real form rather than in complex exponential form.

      New  capabilities  for definite integration have been added, particularly

for  infinite  ranges when the integrand involves exponential, logarithmic, and

trigonometric functions.

New simplification routines


      A  facility  for  simplification  with respect to side relations (rewrite

rules) has been installed.  For example,

      e := -1/3*x^5*y + x^4*y^2 + 1/3*x*y^3 + 1;

      simplify( e, {x^3 = x*y, y^2 = x+1} );

causes the rewrite rules (specified as a set of equations) to be applied to the

expression e via an algorithm which uses a Groebner basis, resulting in the sim-

plified expression:

      x^2*y + x^2 + x + 1 .

See help(simplify,siderels) for further information.

      The  following  special  functions  are  now  known  to  simplify  -- see

help(simplify) for the complete list of simplification procedures:

                   BesselJ,BesselY  Bessel functions

                   BesselI,BesselK  Modified Bessel functions

                   Ei               Exponential integral

                   dilog            Dilogarithm function

Other simplification enhancements:

- simplify/GAMMA  extended;   it  now knows Gauss's multiplication formula, the

  reflection formula, and it handles quotients of GAMMA functions

- simplify/power now does a^x*(-a)^y ==> (-1)^y*a^(x+y)

- simplify/hypergeom  now includes all summation theorems given in Appendix III

  of L.J.Slater's Generalized Hypergeometric Functions

- simplify(..,infinity)  simplifies  expressions  which  contain  infinity when

  there are no ambiguities

Combine function


      The  new  function  "combine"  provides  another class of transformations

which  are  a  form  of  simplification.   Its  purpose  is to combine terms of

specific  forms,  in a sense which is generally the inverse of expand.  It han-

dles  trigonometric  functions, exponentials, logarithms, powers, limits, sums,

and integrals.  For example:

      combine( sin(x)*cos(x), trig );  ==>  1/2*sin(2*x)

      expand( 1/2*sin(2*x) );  ==>  sin(x)*cos(x)

New features of fsolve


- incorporation of the option "complex" to compute complex roots of polynomials

- new  options  and  new  formats  (ranges can use "infinity" now, and a single

  range is used for all variables)

- a new algorithm for a Newton iteration on systems of equations

- a  new  algorithm for systems of equations based on reducing the system (with

  the  symbolic  solver)  for  all the "simple" substitutions, and then solving

  numerically for what is left

- a  new  algorithm  for  polynomials works in three stages: a heuristic method

  based  on a Newton-type iteration complemented with bisection, a complex New-

  ton  iteration  to find complex quadratic factors, and a routine for refining

  the roots found;  the refinement of roots is done for each root over the ori-

  ginal  polynomial before deflating and hence relative errors should be signi-

  ficantly reduced

- for  scalar  equations, the scalar zero finder has been made faster by recog-

  nizing  the  case  of  slow  convergence and accelerating the steps in such a


Type expressions and structured types


      The  notion of a type (as defined by the type function) has been extended

to  include  "structured types".  A structured type is a Maple expression which

is   interpreted   as   a   composite   type;   for  example,  list(algebraic),

name=integer..integer  .   Structured types allow for more concise and complete

argument checking and type analysis.  For example,

      type( expr, name=algebraic..algebraic );

returns  true  iff expr is an equation whose left-hand side is a name and whose

right-hand  side  is  a  range  of  algebraic's.  See help(type,structured) for

details.  Additionally, the following new types are known:

                  type/RootOf    a RootOf expression

                  type/anything  matches any type

                  type/even      an even integer

                  type/odd       an odd integer

                  type/negative  a negative number

                  type/nonneg    a non-negative number

                  type/positive  a positive number

                  type/square    a perfect square

                  type/type      a valid Maple type expression

The interface function


      The interface function allows one to set or inquire about values relating

to  the  user  interface.   This  provides a unique mechanism for communication

between  the  Iris  interface  and  the  Maple "algebra engine".  The variables

relating to the interface are:

 variable      type/value     description


 echo          0,1,2,3,4      for echoing of input

 indentamount  integer        indentation for multiline expressions/procedures

 labelling     true/false     labelling of expressions on output

 labelwidth    integer        minimum size to be labelled

 prettyprint   true/false     for two dimensional output

 printfile     string         system command for displaying a file

 prompt        string         user prompt

 quiet         true/false     suppress auxiliary printing

 screenheight  integer        screen height in characters

 screenwidth   integer        screen width in characters

 plotdevice    string         name of the plotting device

 plotoutput    string         file name for plot output

 preplot       list(integer)  terminal escape sequence

 postplot      list(integer)  terminal escape sequence

 terminal      string         terminal setup for plotting

 verboseproc   0,1,2          controls printing of procedure bodies

 version       string         name of the interface

Miscellaneous new features in version 4.3


- series expansion of unknown functions now uses the D operator

- enhanced computation of generalized series, particularly for the case of tri-

  gonometric functions with non-analytic function arguments

- asymptotic  series  with  respect  to  expressions  other  than  names;  e.g.

  asympt( sin(1/ln(n)), ln(n) )

- gcd  now  has  special code for the case of a very small against a very large

  argument;  it factors the small one and does trial divisions

- a  facility  for  modifying  or creating Maple procedures is provided via two

  functions:   procbody  and  procmake;   a  neutralized  language  is  used to

  represent  as expressions the <statement sequence> which makes up the body of

  a procedure

- the  optimize  code includes a utility routine which allows a Maple procedure

  to   be   dynamically   constructed   from   a   computation   sequence;  see

  help(optimize,makeproc) for details

- match  has  been  extended  to handle various cases with missing powers which

  were not previously handled

- definite  and  indefinite summation have improved handling of logarithms, and

  of Psi(x) and its derivatives

- d  in  the difforms package does a better job of expanding a scalar w.r.t.  a

  basis    of   one-forms;    for   example,   d(f,   [d(x),d(y),d(z)])   gives


- dsolve,  laplace,  and powseries[powsolve] use the D operator to express ini-

  tial conditions;  for example, D(x)(0)=5 instead of xp(0)=5

- dsolve(..,..,series) now uses the method of Frobenius for linear differential

  equations at regular singular points

- dsolve  now  solves  systems  of  linear  ODEs  (previously handled only via

  laplace transforms or series)

- convert(....,rational,exact)  with  the  new  option  "exact"  performs exact

  conversion  of  a floating-point number to a rational number (rather than the

  more intelligent and more expensive conversion via continued fractions)

- the  function  symmpoly  has  been renamed recipoly (computes the "reciprocal


- three-valued  logic:  true,  false, or FAIL, is now used when evaluating in a

  boolean  context;  FAIL is treated like false for branching decisions and for

  evaluating boolean expressions

- internal  format  files  (".m"  files)  are now identified by version so that

  Maple  will  not  attempt  to  read  incorrect ".m" files; furthermore, Maple

  understands  how  to  read  ".m"  files whether they have been generated by a

  VAX-type integer ordering or its reverse

- sort  is  now  an  internal function;  it uses a variation of the basic merge

  sort algorithm, consequently sorting is much faster

- cat is now an internal function

- the  evalgf  evaluator  has  been  added  for computing over non-prime finite

  fields  (i.e.  GF(p^k)  == algebraic extension of degree k over Z mod p for a

  prime p); multiple extensions are supported

- various drivers have been added to the plotting routine;  the present list of

  drivers is:

        plotdevice  description


        char        character plot

        i300        imagen 300 laser printer

        ln03        DEC LN03 laser printer

        mac         Macintosh plot

        pic         output file for use with the troff pic preprocessor

        postscript  PostScript-compatible printer

        regis       terminals with Regis graphics

        tek         Tektronix graphics terminals

        1        output file for use with the Unix plot command

        vt100       VT100 line graphics

- when  loading  a  package  via "with", the list of functions available in the

  package is now sorted

- the memory usage messages now report in bytes, rather than words

- diff can now operate over equations, lists, and sets

- taylor  now  checks  that  the  resulting  series is a true Taylor series and

  returns  an  error otherwise;  the series function will compute a generalized

  series expansion

- `if` function incorporated into Maple.  E.g.

    absx := `if`( x<0, -x, x );

- asymptotic  and generalized series expansions can be computed for unevaluated


- generalized  series,  asymptotic  series,  and  limits  can  be  computed for

  unevaluated integrals

- limit now handles the GAMMA and erf functions for all cases

- the "asympt" function now can develop asymptotic series with essential singu-

  larities;   these  have the same power as the generalized hierarchical series

  used in limit computation

- collect  now supports an option to allow any Maple function (procedure) to be

  applied to the coefficients

- computation  over  algebraic  number  fields has been improved via the use of

  fast heuristic methods and improved factorization over the rationals

New functions


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

alias      Define an abbreviation or denotation

allvalues  Evaluate expressions involving RootOf's and return all values

bernstein  Bernstein polynomial approximating a function

combine    Combine terms into a single term

cost       Operation evaluation count

Det        Inert determinant function for use with mod and modp1

Eigenvals  Inert eigenvalues function, for use with evalf

Eval       Inert evaluation function, for use with the mod operator

evalgf     Finite field arithmetic (including polynomial factorization)

evalhf     Evaluate using hardware floating-point arithmetic

example    Generate a random example for a specified function

Expand     Inert expand function, for use with evala, evalgf, and mod

extrema    Find relative extrema of given expression

Factors    Inert factors function, for use with mod and modp1

factors    Generate a list of factors and multiplicities

Functions  Maple function information

GF         Galois field (finite field) arithmetic

ifactors   Generate a list factors and multiplicities for an integer

interface  Setting and inquiry of interface parameters

Irreduc    Inert irreducibility test function, for mod and modp1

isqrfree   Integer square-free factorization

lhs        The left-hand-side of an equation, relation, or range

macro      Define a macro (input abbreviation)

modp1      Efficient polynomial arithmetic over the integers mod n

modpol     Expression evaluation in a quotient field

norm       Compute the norm of a polynomial

Normal     Inert normal form function, for evala and evalgf

optimize   Generate an optimized computation sequence

plot3d     Generate a 3-dimensional surface plot

plotsetup  Parameter setting for plotting

Power      Inert power function, for use with mod and modp1

Powmod     Inert powering modulo a polynomial, for use with mod and modp1

procbody   Maple procedure created in a "neutralized form"

procmake   Maple procedure creation

recipoly   Reciprocal polynomial

rhs        The right-hand-side of an equation, relation, or range

Roots      Inert roots function, for use with mod and modp1

Sqrfree    Inert square-free factorization function, for evala, mod, modp1

Svd        Inert singular value decomposition function, for evalf

series     Generalized series expansion (replaces taylor)

taylor     Now computes a pure Taylor series, else returns an Error

unassign   Unassign a sequence of names

convert/hypergeom  Convert summations to hypergeometrics

convert/mod2       Reduce modulo 2

New functions in packages


(use "help(<packagename>,<funcname>);" for help)


      finduni   Find smallest univariate polynomial in an ideal

      finite    Determine if system has finitely many solutions

      gsolve    Reduced Groebner basis (for solving a system of polynomials)

      solvable  Determine if system is solvable


      basis        Basis of a vector space

      charmat      Characteristic matrix

      charpoly     Characteristic polynomial

      col          Pick off the j'th column of a matrix as a vector

      copyinto     Copy one matrix into another

      eigenvects   Eigenvectors of a matrix of rationals

      equal        Test for matrix equivalence

      exponential  Matrix exponential

      extend       Extend a matrix by n rows and m columns

      fibonacci    Fibonacci matrix

      gaussjord    Gauss-Jordan form (row echelon form) over a field

      hermite      Hermite normal form (row echelon form) for polynomials

      htranspose   Hermitian transpose

      ihermite     Hermite normal form (row echelon form) for integers

      intbasis     Basis for intersection of spaces

      iszero       Test for zero matrix

      mdet         removed -- use Det(..) mod p

      minpoly      Minimal polynomial

      randmatrix   Generate random matrix

      row          Pick off the i'th row of a matrix as a vector

      sumbasis     Basis for sum of spaces

      swapcol      Changed to run in place (destructive)

      swaprow      Changed to run in place (destructive)


      B          Synonym for bernoulli

      binomial   Moved to combinat

      E          Synonym for euler

      fermat     Fermat primes

      fibonacci  Moved to combinat

      issqrfree  Test for square-free (formerly named isqrfree)

      mersenne   Mersenne primes

      nthpow     Greatest integer power which divides n

      sigma      Sum of the positive divisors of an integer


      leftbox      Graph of an approximation to an integral

      leftsum      Numerical approximation to an integral using rectangles

      middlesum    Numerical approximation to an integral using rectangles

      rightbox     Graph of an approximation to an integral

      rightsum     Numerical approximation to an integral using rectangles

      showtangent  Plot of a tangent to a function

      simpson      Numerical approximation to an integral using Simpson's rule

      trapezoid    Numerical approximation to an integral using trapezoids

      value        Evaluate inert forms (formerly named Eval)

New packages


(use "help(<packagename>);" for information about a specific package)


      A combinatorial functions package has been added.  It is named "combinat"

      and it includes the following functions:

      bell          Bell numbers B(n)

      binomial      Binomial coefficients C(n,k)

      combine       Construct the combinations of size m from n objects

      combinations  Count the combinations

      fibonacci     Fibonacci numbers F(k)

      multinomial   Multinomial coefficients (n; k1, k2, ..., km)

      partition     Construct the partitions of an integer

      partitions    Count the partitions

      kpartition    Construct the k-partitions of an integer

      kpartitions   Count the k-partitions

      permute       Construct the permutations of a list of objects

      permutations  Count the permutations

      powerset      Generate the power set for a set or multiset

      randperm      Generate random permutation of n objects

      stirling1     Stirling numbers of the first kind

      stirling2     Stirling numbers of the second kind


      A package dealing with two-dimensional Euclidean geometry has been added.

      The  package  is  named "geometry" and the following functions are avail-


          Appolonius         Eulercircle      Eulerline       Gergonnepoint

          Nagelpoint         Simsonline       altitude        are_collinear

          are_concurrent     are_harmonic     are_orthogonal  are_parallel

          are_perpendicular  are_similar      are_tangent     area

          bisector           center           centroid        circle

          circumcircle       conic            convexhull      coordinates

          detailf            diameter         distance        ellipse

          excircle           find_angle       harmonic        incircle

          inter              inversion        is_equilateral  is_right

          line               make_square      median          midpoint

          on_circle          on_line          onsegment       orthocenter

          parallel           perpen_bisector  perpendicular   point

          polar_point        pole_line        powerpc         projection

          rad_axis           rad_center       radius          reflect

          rotate             sides            similitude      square

          symmetric          tangent          tangentpc       triangle


      A package dealing with projective geometry has been added.  This package,

      named "projgeom", includes the following functions:

                 collinear  concur     conic      conjugate  ctangent

                 fpconic    harmonic   inter      join       lccutc

                 lccutr     lccutr2p   line       linemeet   midpoint

                 onsegment  point      polarp     poleline   ptangent