New features that have been added to Maple for version 4.1

           ----------------------------------------------------------

A "plot" facility.

        The basic syntax is

                plot( f, x=l..r )

      for plotting the expression f, a function of x on the real range l..r The

      argument  f may also be a Maple procedure which is to be evaluated.  Mul-

      tiple  plots,  infinity  plots  and  parametric plots are available.  See

      help(plot)  and  help(plot,<topic>) for further information.  Drivers are

      available for

                dumb terminal   -- a character plot

                tektronix 4010 and 4014

                regis

      The  plot  facility  uses  Maple's  arbitrary precision model of floating

      point  arithmetic,  which  is  implemented in software.  The advantage of

      using Maple floats is that any Maple expression, mathematical function or

      Maple procedure can be plotted to arbitrary precision.  A plot is a Maple

      structure which can be manipulated, stored in files, slightly changed and

      redisplayed, assigned to variables, passed as an argument, etc.

Translation to Fortran.

        A first attempt at a fortran translation facility.  Currently,

        written in Maple, translates single Maple algebraic expressions

        into fortran 77 using either single or double precision.

        There is a optional code optimization facility available.

        See  help(fortran)  for further information.

Wrap program obsolete.

        The wrap program for breaking up long lines output by Maple

        is now obsolete as long lines (lines exceeding screenwidth in

        length), including comments, are now automatically broken up

        on output by Maple.  Note: tokens are not broken if possible.

The "-l" option has been eliminated.

        This option is no longer necessary.

        WARNING: the internal maple format of version 4.0 is

        incompatible with version 4.1 .  All Maple source files

        should be reloaded into Maple format using the new Maple

        load procedure i.e. "maple < filename"

Remember function replaced by assignment to a function call.

      The  remember  function  call  remember( f(x) = y )  has been replaced by

      the functional assignment  f(x) := y .  The evaln function (evaluate to a

      name)  now  accepts a function call as an argument.  The evaluation rules

      for  this  case are the same as for a subscripted argument such as f[x] .

      That  is,  the  function  name  f  is evaluated, then the arguments x are

      evaluated  from left to right.  The function call is not executed.  Thus,

      the  semantics of the functional assignment  f(x) := y  are:  evaluate to

      a  name  f(x),  evaluate the right hand side y, storing the result in f's

      remember table.

        If f does not evaluate to a procedure, it is assigned the procedure

                proc() options remember; 'procname(args)' end

      A  consequence  of  this  change is that all side effects in Maple can be

      traced  to the use of the assignment operator, either explicit, or impli-

      cit  (e.g.,  assigning  the  quotient  to  q  in divide(a,b,'q')).  Note:

      Assignments  to builtin functions are disallowed.  Note:  The only func-

      tions with special evaluation rules are

                eval, evaln and assigned .

Automatic Simplifications for Standard Mathematical Functions

        In previous versions of Maple, only the simplifications

                sin(0) ==> 0, cos(0) ==> 1, exp(0) ==> 1,

                ln(1) ==> 0, exp(ln(x)) ==> x, ln(exp(x)) ==> x

      were performed automatically by the internal simplifier.  Simplifications

      like  sin(Pi)  ==>  0  were typically not done.  In this version, a Maple

      library  procedure for each function performs these and other simplifica-

      tions  as  evaluations of a function call.  Such procedures exist for the

      following  Mathematical  functions: abs, signum, exp, ln, erf, Psi, Zeta,

      GAMMA,  binomial,  bernoulli  euler,  sqrt,  sin,  cos, tan and the other

      trig/arctrig functions.  Also, procedures exist for stir1, stir2, Ei, Si,

      Ci,  dilog fibonacci, hypergeom but these must be explicitly loaded using

      readlib.

        The simplifications performed (automatically) include

             special values:   sin(Pi/6) ==> 1/2, Zeta(0) ==> -1/2

             symmetry:         sin(-3) ==> -sin(3), cos(-x) ==> cos(x)

             floating point:   foo(float) ==> float

             complex argument: sin(I) ==> I*sinh(1), abs(3+4*I) ==> 5

             inverse function: exp(ln(x)) ==> x, sin(arccsc(x)) ==> 1/x

             idempotency:      abs(abs(x)) ==> abs(x)

             general rules:    abs(x*y)==>abs(x)*abs(y),binomial(n,1)==>n

             singularities:    cot(0) ==> Error, singularity encountered

      There is also a "cutoff" for GAMMA(n), Psi(n) and Zeta(n) where n is

      an integer.  That is for example, GAMMA(49) ==> the integer 48! but,

      GAMMA(50) is left as "GAMMA(50)".  The reason for this is as follows.

      GAMMA(1000000) is not effectively computable, but it can still be

      manipulated as the symbol GAMMA(1000000).  The "cutoffs" can easily

      be changed by the user.  For example, if the user wants GAMMA(n)

      always expressed as (n-1)!  then define  GAMMA := proc(n) (n-1)! end

      The  codes  reside  in the Maple library if you wish to determine exactly

      what  simplifications  are  being  done.  Note the code for trigonometric

      functions  resides  in  the  files trig, arctrig, trigh and arctrigh.  To

      include additional simplifications and delete/change existing simplifica-

      tions, the user has the option of changing the code.

Global variable constants for defining Mathematical constants.

        The global variable constants, initially assigned the sequence

                gamma, infinity, Catalan, E, I, Pi

        defines the Mathematical constants known to Maple.  They are

        known to Maple in several ways for example,

                ln(E) ==> 1, sin(Pi/6) ==> 1/2

                type(E+Pi,constant) ==> true

                abs(sin(Pi/12)) ==> sin(Pi/12)

                signum(cos(1/gamma)) ==> -1

                evalf(Pi) ==> 3.141592654

        and note

                type(x*Pi,polynom,integer) ==> false

                type(x*Pi,polynom,constant) ==> true

        The user can define his/her own constants

        For example the constant Z by doing  constants := constants, Z

        If Z is a Real number, and evalf/constant/Z is defined, Maple

        will be able to determine abs(Z) and signum(Z) .

Major improvements to the limit function.

      Previous  versions of limit understood only complex limits.  The new ver-

      sion understands real limits (directional limits) including a distinction

      between  infinity and -infinity.  A complex limit is specified by a third

      argument  which  is the keyword "complex".  A directional limit is speci-

      fied  by a third argument which is either "left", "right" or "real" where

      the  latter  means  bidirectional.   Limit  may also return a real range.

      This  means  that the limit is bounded, it lies within the range, but may

      be a subrange of the range or possibly a constant.  Limit may also return

      the  keyword  "undefined".  This means the limit does not exist.  The

      defaults  for  the two argument case are real bidirectional limits except

      if the limiting point is infinity or -infinity in which case limit under-

      stands   a   directional  limit,  thus  limit(f(x),x=-infinity,right)  ==

      limit(f(x),x=-infinity)       and       limit(sin(x)/x,x=0,real)       ==

      limit(sin(x)/x,x=0)

        For example

                limit(tan(x),x=Pi/2,left)     ==> infinity

                limit(tan(x),x=Pi/2,right)    ==> -infinity

                limit(tan(x),x=Pi/2,real)     ==> undefined

                limit(tan(x),x=Pi/2,complex)  ==> infinity

                limit(sin(x),x=infinity,real) ==> -1..1

                limit(exp(x),x=infinity,real) ==> infinity

                limit(exp(1/x),x=0,right)     ==> infinity

                limit(exp(1/x),x=0,left)      ==> 0

                limit(exp(x),x=infinity)      ==> infinity

                limit(exp(x),x=-infinity)     ==> 0

New package for commutators.

        The commutat package performs commutator operations.

New package for first year students.

      The  student package contains routines to help first year students follow

      step  by  step  solutions  to  problems  typical  of  first year calculus

      courses.   It enables a student to examine an integral or a summation  in

      an   unevaluated  form.  Tools are provided for changing variables,  car-

      rying   out   integration  by  parts, completing the square and replacing

      common factors by an indeterminate.  Other  routines  are  available  for

      dealing with some aspects of fact finding associated with plotting.

New notation Psi(n,x) and Zeta(n,x).

      The  n'th  derivative  of the polygamma function Psi(x) is now denoted by

      Psi(n,x)  and  not  (Psi.n)(x).   Likewise,  the  n'th  derivative of the

      Riemann  Zeta  function is denoted by Zeta(n,x) and not (zeta.n)(x).  The

      old  notations  are  unworkable  in  general.   Psi(0,x)  ==  Psi(x)  and

      Zeta(0,s) == Zeta(s).  Note: there is no floating point code for Psi(n,x)

      and Zeta(n,x) for n > 0 at present.

New function -- iscont(expr,x=a..b) -- test for continuity on an interval.

      This function replaces the old int/iscont function.  The iscont

      function returns a boolean result (true if the expr. is continuous

      on a..b, false otherwise).  This function must first be read into a

      Maple session through a "readlib(iscont):" statement.  The endpoints

      of the interval must be either real constants, "infinity" or

      "-infinity".

Obsolete Functions.

                arctan2(y,x);       use arctan(y,x);

                remember(f(x)=y);   use f(x) := y;

                C(n,k);             use binomial(n,k);

                zeta(x);            use Zeta(x);

                easyfact(n);        use ifactor(n, easy);

                diffeq(deqn,x,y);   use dsolve(deqn(s),var(s),option);

                simplify(...,Zeta); use expand(...);

New Mathematical Functions known to Maple

           bessel:    Now known to evalf and diff

           dilog:     Spence's Integral: dilog(x) = int(ln(t)/(1-t),t=1..x)

           hypergeom: Generalized Hypergeometric Functions

           stir1:     Stirling number of the first kind: stir1(n,m)

           stir2:     Stirling number of the second kind: stir2(n,m)

New functions:

    coeffs:     coeffs(p,v,'t') returns the sequence of coefficients

                and terms t of the polynomial p in the indeterminates v

    ConvexHull: ConvexHull(p) computes the Convex Hull of the points p

    discrim:    computes discriminant of a polynomial

    evalm:      evaluates matrix operations

    iroots:     finds integer roots of rational polynomial

    iscont:     tests for poles of a function over a range

    mroots:     find roots of a polynomial modulo a prime

    tcoeff:     "trailing coefficient" complementing lcoeff function

    type/algebraic: test for rational function extended by radicals

    type/quartic:   test for quartic polynomial

    type/scalar:    test for scalar

    convert/ln:     express arctrigonometric functions in terms of logs

    convert/exp:    express trigonometric functions in terms of

                    exponentials

    convert/sincos: express trigonometric functions in terms of sin and cos

                    express hyperbolic functions in terms of sinh and cosh

    convert/GAMMA:  express factorials binomials in terms of GAMMAs

    convert/expsincos: expresses trigs in terms of exp, sin, cos

    convert/degrees:   converts radians to degrees

    convert/radians:   converts degrees to radians

    convert/factorial: converts GAMMAS and binomials to factorials

    convert/lessthan:  converts relation to less than

    convert/equality:  converts relation to equality

    convert/lessthanequal: converts relation to less than equal

    convert/polar: converts complex expression to polar form

    numtheory/cyclotomic:  calculate cyclotomic polynomial

    numtheory/isqrfree:    test if integer is square free

    numtheory/mroot:   calculate modular root

    numtheory/pprimroot:  calculate pseudo primitive root

    numtheory/rootsunity: calculate modular roots of unity

    powseries/powratpoly: calculate power series from rational expression

Modified functions:

  abs:           absolute value function is now a library procedure

                 extended for general constants and complex arguments

  arctan:        arctan(x,y) replaces arctan2(x,y)

  binomial:      Extended functionality to make binomial analytic via

                 binomial(n,k) = GAMMA(n+1)/GAMMA(k+1)/GAMMA(n-k+1).

  bernoulli:     Extended functionality bernoulli(n,x) returns

                 the nth bernoulli polynomial evaluated at x

  content:       Extended functionality of content(a,v,'p') to allow

                 the coefficients of a (polynomial in v) to be rational

                 functions in other indeterminates.

  diff:          Now handles binomial, dilog, sum.

  evalc:         When computing evalc(f(x+y*I)), if x or y are floats

                 guard digits are now added with care taken to ensure

                 that the result lies in the principle range.

  expand:        Now maps onto the coefficients of a taylor series.

  euler:         Extended functionality euler(n,x) returns

                 the nth euler polynomial evaluated at x

  int:           1: Integration by parts for arctrig, arctrigh,

                       erf, Ei, Si, Ci and dilog functions

                 2: Integration of ln(x)*Q(x) where Q(x) is a rational

                       function of x.  This introduces the dilog

                       function: dilog(x) = int(ln(t)/(1-t),t=1..x)

                 3: Integration of hyperbolics

  lcoeff:        lcoeff(p,v,'t') returns the leading coefficient and

                 the term t of the polynomial p in the indeterminates v

  product:       If the lower range is greater than the upper range,

                 product now returns the reciprocal of the non-reversed

                 product, as opposed to 1.

  resultant:     `resultant/bivariate` computes the resultant of

                 two polynomials using the subresultant algorithm.

  RootOf:        The form RootOf(polynom,x) is no longer permitted.

                 RootOf(polynom=0,x) is the form to use.

  sign:          There are new parameters to sign: sign(expr,[x,y,..],name)

                 expr - any expression, [...] - indets, name - contains

                 leading term after function call.

  signum:        signum(-x) now remains as signum(-x) since -signum(x)

                 is incorrect when x=0.  Also, signum uses 10 digit

                 floating point evaluation if type(x,constant) is true

  simplify:      The simplify command now recognizes that

                 sin(x)^2+cos(x)^2 = 1 (also sinh(x)^2+1 = cosh(x)^2),

                 as well as simplifying powers of sin,cos to canonical

                 form.  It also has new simplification rules for at

                 compositions and hypergeometric expressions.

  sum:           Hypergeometric summation algorithms are used, allowing

                 more summations involving binomial coefficients to be

                 solved.  Also, the indefinite summation routines for

                 rational functions and Gosper's algorithm have been

                 extended, allowing them to handle larger expressions.

  type/constant: Option for real or complex added.

  with:          Improved functionality for user libraries.

Share Library:

        We now distribute a "share library" which contains procedures

        that have been contributed by maple users.

Efficiency Improvements:

        C runtime Stack:

                Most operating systems impose a settable limit on the size

                of the C runtime stack.  Furthermore, the space occupied by

                the C runtime stack typically is separate from the heap.

                This means that stack space cannot be used by Maple

                for Maple data structures.  Secondly, highly recursive

                Maple procedures will exceed the C runtime stack limit,

                resulting in a crash.  On small systems, the number of

                levels of recursion available is quite small, sometimes

                50 or even less.  We have replaced some C locals which use

                C stack space with Maple data structures approximately

                tripling the number of recursion levels achieved for

                the same stack space.

        Integration of series:

              `int/series`( f, x )

              This fundamental operation has been encoded internally.

              (Note that differentiation of a SERIES data structure

              was encoded internally for maple version 4.0)

              This has resulted in much improved times for computing

              series for the functions  ln, erf, dilog, Ei, Si, Ci, arctrig

        Composition of series:

                The algorithms for computing Power series expansions

                for ln(f(x)), exp(f(x)), tan(f(x)), cot(f(x))

                Also sqrt(f(x)) ==> arcsin(f(x)), sin(f(x)) and cos(f(x))

                proceed by solving the differential equation which for

                dense f(x) leads to O(n^2) coefficient operations.

        Large polynomial divisions:

                For large calls to divide(a,b,q), the external routine

                expand/bigdiv is called.  Let x = indets(a) minus indets(b)

                For the case where x is not empty, the coeffs function is

                used to obtain the coefficients in x.  Divide is then

                applied to each coefficient.

        Taylor of logarithms

                This has been made much faster.

        `normal/numden`

                This procedure is now internal.  As a result, normal,

                numer and denom are much more efficient.

        gcd/gcdheu

              The heuristic gcd algorithm has been improved and it is

              able to handle problems at least twice as big.  Consequently

              some gcd times have improved dramatically.