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 (n1)! then define GAMMA := proc(n) (n1)! 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)/(1t),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(nk+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)/(1t),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 nonreversed

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.
