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
dumb terminal -- a character plot
tektronix 4010 and 4014
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
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
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
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(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
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)
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
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
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.
We now distribute a "share library" which contains procedures
that have been contributed by maple users.
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.
This procedure is now internal. As a result, normal,
numer and denom are much more efficient.
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.
Download Help Document
What kind of issue would you like to report? (Optional)