updates[v41]
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) ==> 0New 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 expressionModified 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.