Maple 4.1 - Maple Help

 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,) 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.