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