Maple 12¶
Basics¶
Maple can be started either with a command line interface or with a graphical user interface.
When you type maple
at a console you will get the Maple command line, where
the only input mode is 1D Math. Even characterrendered plotting is possible
from here.
When you type xmaple
at a console you will get Maple with a graphical user
interface. From here you edit Maple documents.
There exist two basic modes a document is entered and viewed, the (more basic and traditional) “worksheet” and a (more graphical) “document” mode. The latter has an underlying worksheet, which is merely displayed differently. You can switch anywhere inside your document between the two modes by choosing “View > Expand Document Block” or “View > Collapse Document Block” respectively.
There are two basic ways of displaying and entering math. “1D Math” (also
called “Maple Notation”) is in plain ascii text form. Input must be terminated
by either ;
(displays the result) or :
(no displaying of the result).
“2D Math” is a more graphical way of entering and displaying actual math
notation.
Hitting ‹ENTER› executes the input given. In “document” mode hitting ‹CNTR›+‹=› executes an inline expression and displays the result inline (without additional linebreak). You can hit ‹SHIFT›+‹ENTER› for a new line while postponing the execution of the input. (Don’t forget the semicolon in this case.)
In a “worksheet” or “document” you can go back, change lines and reexecute them by hitting enter.
Note
No succeeding dependent expressions are reevaluated! Choose “Edit > Execute > Worksheet” to reexecute everything.
In a “worksheet” or “document” you can enter normal (formated) text which is not executed. ‹F5› switches between entering text and math.
‹ESC› shows a list of possible completions. The right mouse button displays a list of sensible operations on the object. Executing such might write something in text and math mode.
Everything following #
is a comment and will not be interpreted.
On certain systems everything following !
is passed to the system command
line.
%
is a placeholder for the previous expression entered. %%
and %%%
are placeholders for the second and third last expression.
Math operators:
+ 
Addition 
 
Subtraction 
* 
Multiplication 
/ 
Division 
^ or ** 
Exponentiation 
Builtin variables:
% 
Most recent expression 
%% 
Second recent expression 
%%% 
Third recent expression 
Builtin functions:
sin() , sinh() 
(hyperbolic) sine 
cos() , cosh() 
(hyperbolic) cosine 
tan() , tanh() 
(hyperbolic) tangent 
sec() , sech() 
(hyperbolic) secant 
csc() , csch() 
(hyperbolic) cosecant 
cot() , coth() 
(hyperbolic) cotangent 
exp() 
exponential 
ln() or log() 
natural logarithm 
log[‹b›]() 
logarithm with base ‹b› 
abs() 
absolute value 
sqrt() 
square root 
Builtin constants:
Pi 
3.141592... 
I 
imaginary unit 
infinity 
infinity 
true and false 
boolean constants 
gamma 
Eulers constant 0.5772156... 
Invoking help¶
To show help about some command ‹command›
type ?‹command›
.
Loading packages¶
with(‹package›)
loads the Maple ‹package›. Terminate with :
to suppress
the output.
unwith(‹package›)
unloads the Maple ‹package›.
Expressions and Names¶
An expression is a string of constants, operators, other expressions, etc.
E.g. 3*x^3  4*ln(x)
.
‹name›:=‹expression›
defines a reference (“short cut” ‹name›
) for an
‹expression›
.
Names can contain any letters and numbers and the underscore and are not allowed
to start with a number. More complicated names must be enclosed in backticks
(`
) to be recognized as names, e.g. `f'`
, `some name with spaces`
.
The backtick itself is produced by \'
.
The backslash (\
) acts as a line continuation character. To use it in a
backtick delimited name type \\
.

is used to concatenate names (strings). E.g. `my test`name:=2*Pi
is the same as `my testname`:=2*Pi
.
Any name can be indexed up to any depth by some other name or expression, e.g. the following defines four names:
U[3]:=Pi
U[1][20]:=2*Pi
U[`hi there`]:=3*Pi
U[sum(k^2,k=1..K)]:=4*Pi
indices(U)
returns the four firstlevel indices used above.
U[1]:=5*Pi
would overwrite the definition of U[1][20]
.
type(‹name›, ‹type›)
returns true if ‹name›
has type ‹type›
, where
‹type›
is name, indexed, integer, etc.
subs(‹equation›, ‹expression›)
will return an expression with the
substitution given in ‹equation›
made.
Equations¶
‹expression 1›=‹expression 2›
is an equation. No definition or assignment
is taking place.
‹name›:=‹expression 1›=‹expression 2›
defines a reference ‹name›
for the
equation ‹expression 1›=‹expression 2›
.
rhs(‹equation›)
and lhs(‹equation›)
return the expression on the right
hand and the left had side of the ‹equation›
.
Data types¶
restart
clears all the allocated variables.
whattype(‹something›)
returns the type of ‹something›
.
type(‹expression›, ‹type›)
returns a boolean reflecting whether the
‹expression›
is of type ‹type›
.
To convert between certain data types, convert()
can be used.
Strings¶
Strings are delimited by "
, e.g. "a string"
. To make a doubledash or a
backslash appear in a string type \"
or \\
respectively.
Symbols¶
Some symbols (e.g. Pi
or gamma
) are protected by default and can not be
assigned. An unprotected symbol can be protected using the
protect('‹symbol›')
function.
Unknown variables, e.g. x
remain symbolic when operating on them.
If some symbol x
refers to a different type of object (e.g. equation,
function ...) the x:='x'
will turn x back into a mere symbol.
Booleans¶
Boolean variables take on values true
, false
or FAIL
, where the last
value refers to an unknown truth value.
evalb(‹expression›)
evaluates the ‹expression›
(usually an equation)
into a boolean. is(...)
and coulditbe(...)
are similar functions.
Integers¶
Normally all numbers are stored as a rational expression involving integers, so no roundoff error occurs. Integers can have arbitrary size.
Floating point numbers¶
If an expression involves floating point numbers (e.g. 3.5
) then the result
is a floating point number too.
evalf(‹expression›)
orevalf(‹expression›, ‹number of digits›)
evaluates‹expression›
to a floating point number. The number of digits can also be set globally by settingDigits := ‹number of digits›
.
Complex numbers¶
I
(capital i) is used to indicate sqrt(1).
conjugate(‹z›)
, Re(‹z›)
and Im(‹z›)
return the complex conjugate,
real part and imaginary part of ‹z›
.
evalc(‹expression›)
evaluates a complex expression to something like
‹expression1› + I‹expression2›
, e.g. with cosine and sine. All symbols in
‹expression›
are assumed to be real.
Sequences¶
‹expression 1›, ‹expression 2›,‹...›
is an expression sequence. You can
also use the seq()
function, e.g. as:
seq(‹expression(i)›, ‹i› = ‹start›..‹end›)
Lists¶
Lists are sequences enclosed by square brackets [
and ]
. Lists are
tuples and thus ordered.
Sets¶
Sets are sequences enclosed by curly brackets {
and }
. Sets are
unordered and don’t contain the same element more than once.
 Elements from sequences, lists and sets can be obtained by 1based indexing as
‹data›[‹index›]
. For nested data use‹data›[‹index1›][‹index2›]‹...›
.
Functions¶
A function can be defined as follows:
‹name› := (‹variable 1›, ‹variable 2 ...›) > ‹expression›
Executing a function as ‹name›(‹some expression for variable 1›, ‹some
expression for variable 2 ...›)
will return an expression with the variables
substituted in the function.
map(‹function›,‹data›)
returns a sequence, list, vector... which results
from applying ‹function›
to the sequence, list, vector ... ‹data›
.
zip(‹function›,‹data 1›,‹data 2›)
returns a sequence, list, vector... which
results from applying ‹function›(‹data element 1›,‹data element 2›)
for all
data elements in ‹data 1›
and ‹data 2›
.
unapply(‹expression(x)›, x)
returns a function ‹expression(x)›
which is
obtained by interpreting the ‹expression(x)›
as a function in x
.
?inifcns
opens up the help window with a list of initially known functions.
Many basic functions like Int
or Sum
have two versions, a regular one
(starting with a small letter) and an “inert” one (starting with a capital
letter). The latter “inert” version is not evaluated. In 2D Math mode it is
displayed gray integration or summation symbol. Inert functions prevent Maple
from trying to evaluate an argument, e.g. to evalf(...)
and thus shortens
computation time.
There exist compound functions like evalf/int
which in this case is
integration followed by floating point evaluation.
Functions can be composed from other functions by means of addition,
multiplication or with the function concatenation operator @
.
(‹function1›@‹function2›)(‹variable›)
is the same as
‹function1›(‹function2›(‹variable›))
. ‹function›@@‹n›
concatenates the
‹function›
‹n›
times.
Printing to the Screen¶
print(‹expression›)
usually prints the ‹expression›
in 2D Math output
mode, which is the same as just writing ‹expression›
. In this case,
trailing colon :
prevents printing.
Statements are recognized in levels, determined by the nesting of conditional or
repetition statements and the nesting of procedures. The outermost
(interactive) level is level 0. printlevel:=‹level›
sets the highest level
for which the output of ‹expression›
s are still printed. If you are
somewhere in a deeply nested loop or procedure and would like to print something
use print(...)
directly on the object.
Flow control¶
In the descriptions below, [...]
indicates an optional part of code.
For loop:
for ‹k› from ‹start› [by ‹step›] [to ‹end›] [while ‹condition›] do
‹statements›
end do;
While loop:
[for ‹k› in ‹expression›] while ‹condition› do
‹statements›
end do;
If statement:
if ‹condition 1› then
‹statements 1›
[elif ‹condition 2› then
‹statements 2›]
[else
‹statements 3›]
end if;
Procedures¶
interface(verboseproc=2)
changes the behavior of the print(...)
procedure, such that print(‹procedure›)
prints the whole code of the
‹procedure›
as it is defined.
A procedure is defined as follows:
‹name› := proc(‹argument 1›, ‹argument 2›, ...) [option ‹option›]
‹statements›
end proc;
For recursive procedures the option remember is sensible. This option lets Maple remember previously calculated results, which  in recursive procedures  might be needed in later recursions. (E.g. Fibonacci sequence)
Type checking can be done in the procedure definition by adding properties to
the arguments as ‹argument›::‹property›
, e.g. x::integer
.
Files and Scripts¶
save ‹variable 1›, ‹variable 2›, ... ‹filename›
saves the variables to a
file. load ‹filename›
loads all variables from a file. Possible filename
extensions are .m
(binary Maple data) or .mpl
(human readable but also
readable by Maple).
A Maple script is a text file with 1D Math notation instructions to Maple.
Every line must be preceded with >
. The read command will immediately
execute the read code.
Symbolic computation¶
Converting expressions¶
normal(‹expression›)
converts the ‹expression›
into factored normal
form, i.e. into a rational expression where the numerator and denominator are
relatively prime. If called with a second argument expanded
this yields
expanded polynomials in the numerator and denominator.
simplify(‹expression›)
tries to simplify the ‹expression›
. As a second
optional argument a simplification rule can be given, e.g. trig
applies
trigonometric relations.
expand(‹expression›)
multiplies terms out and does other expansions. The
result needn’t be more complex.
factor(‹expression›)
tries to convert the ‹expression›
into factors.
(The opposite of expand(...)
).
collect(‹expression›,‹var›)
collects the ‹var›
iable. To collect
several variables, a list can be given.
normal(‹expression›)
puts fractions in ‹expression›
onto the same
denominator.
coeff(‹expression›,‹var›,‹number›)
returns the coefficient of
‹var›
raised to the power ‹number›
. ‹number›
can be omitted.
convert(‹expression›, parfrac, ‹variable›)
calculates the partial fraction
expansion of ‹expression›
in ‹variable›
, e.g:
> convert(1/(z1/5)/(z2),parfrac,z);
5 25
  
9 (z  2) 9 (5 z  1)
convert(‹expression›,radical)
replaces RootOf
s of polynomials by
radical notation if possible.
convert
offers many other forms of symbolic conversion.
Symbolic Properties¶
assume(‹property(x)›)
or assume(‹x›, ‹property›)
makes Maple assume some
property on a variable, e.g. assume(x>0)
, assume(y, 'real')
.
about(‹x›)
tells what was assumed on ‹x›
.
‹x› := '‹x›'
removes the assumptions.
The RealDomain
package makes global assumptions on all symbols to be real.
This package is not compatible with the use of the assume()
function.
Integer Computation¶
ifactor(‹number›)
returns a factorization of ‹number›
into prime
numbers.
Solving equations¶
solve(‹set of equations›, ‹set of variables›)
tries to solve the ‹set of
equations›
with respect to the ‹set of variables›
. Polynomials with
degree beyond 4 are in general not solvable.
fsolve(‹set of equations›, ‹set of variables›)
solves the equations
numerically with Newtons method.
fsolve(‹set of equations›, ‹set of variables›, ‹set of intervals›)
searches
for the solution within the intervals given, where an interval is written as
‹x›=‹ax›..‹bx›
. If ‹set of variables›
contains only one variable then
‹x›=
can be omitted.
fsolve(‹set of equations›, ‹set of variables›, complex)
allows complex
solutions.
Differentiation¶
diff(‹expression(x)›, ‹x›)
computes the derivative of ‹expression(x)›
with respect to ‹x›
.
diff(‹expression(x)›, ‹x›$‹n›)
computes the ‹n›
‘th derivative.
diff(‹expression(x,y,...)›, ‹x›$‹nx›, ‹y›$‹ny› ‹...›)
computes the
‹nx›
‘th partial derivative with respect to ‹x›
, the ‹ny›
‘th
partial derivative with respect to ‹y›
, ... of ‹expression(x,y,...)›
.
D(‹function›)
returns a function which is the derivative of ‹function›
(in one variable).
D[1$‹n›](‹function›)
returns a function which is the ‹n›
‘th derivative
of ‹function›
(in one variable).
D[‹i›$‹n›](‹function›)
returns a function which is the ‹n›
‘th partial
derivative with respect to the ‹i›
‘th variable of ‹function›
(in
several variables). If $‹n›
is omitted ‹n›
is assumed to be 1.
D[‹i›$‹ni›,‹j›$‹nj›,‹...›](‹function›)
returns a function which is the
‹ni›
‘th partial derivative with respect to the ‹i›
‘th variable, the
‹nj›
‘th partial derivative with respect to the ‹j›
‘th variable, ... of
‹function›
(in several variables).
Integration¶
int(‹expression(x)›, ‹x›)
computes the indefinite integral of
‹expression›
with respect to ‹x›
.
int(‹expression(x)›, ‹x›=‹a›..‹b›)
computes the definite integral of
‹expression›
with respect to ‹x›
between ‹a›
and ‹b›
.
Differential equations¶
A differential equation can be constructed with =
and diff
as a normal
equation, e.g. eq := diff(y(x),x$2)2*diff(y(x),x)=sin(x)
.
dsolve(‹diffequation(function)›, ‹function›)
tries to solve the
‹diffequation(function)›
with respect to ‹function›
, e.g: dsolve(eq,
y(x))
.
dsolve({‹diffequation(function)›, ‹initial conditions›}, ‹function›)
tries
to solve the ‹diffequation(function)›
conforming with the ‹initial
conditions›
with respect to ‹function›
. Initial conditions can be
‹function›
values (e.g. f(0)=0
) or values of ‹function›
derivatives.
The syntax for the latter is:
D(‹function name›)(‹function variable›)=‹function value›
or:
D(‹function name›@@‹n›)(‹function variable›)=‹function value›
for the ‹n›
‘th derivative, e.g: init := y(0)=1, D(y)(0)=1; dsolve({eq,
init}, y(x))
.
An additional second or first argument numeric finds a numeric solution to the
differential equations. The DEtools
package provides more sophisticated
control.
Limits¶
limit(‹expression›, ‹x›=‹lim›)
tries to compute the limit of
‹expression›
as ‹x›
goes to ‹lim›
.
An optional third argument gives the ‹direction›
. This can be either right,
left, real or complex. The default is the real bidirectional limit unless
‹lim›
is plus or minus infinity.
The LinearAlgebra package¶
<‹a›,‹b›,‹...›>
creates a vector from the elements ‹a›
, ‹b›
... which
potentially can be vectors on their own.
Vector(‹n›, ‹list›)
creates a length‹n›
vector from the optional
‹list›
which can contain vectors.
‹vector›[‹n›]
retrieves the ‹n›
‘th element of the ‹vector›
.
‹vector›[‹n›..‹m›]
retrieves the subvector. Indexing is 1based.
ZeroVector(‹n›)
constructs a length ‹n›
zerovector.
<<‹a›,‹b›,‹...›><‹x›,‹y›,‹...›>‹...›>
creates a matrix from the elements‹a›
,‹b›
,‹x›
,‹y›
... which can be matrices on their own.
Matrix(‹n›, ‹m›, ‹list›)
specifies an ‹n›
times ‹m›
matrix with
elements given in the optional (nested) ‹list›
which can contain matrices.
Indexing is 1based.
IdentityMatrix(‹n›)
constructs an ‹n›
times ‹n›
identity matrix.
Array(‹start1›..‹end1›, ‹start2›..‹end2›)
yields an undefined matrix with
row indices ‹start1›
to ‹end1›
and column indices ‹start2›
to
‹end2›
. Array is a more general constructor for matrices than Matrix.
SwapRow(‹matrix›, ‹i›, ‹j›)``(``Swapcol(‹matrix›, ‹i›, ‹j›)
) returns a
matrix with swapped rows(columns) ‹i›
and ‹j›
.
Matrices and vectors can be added, subtracted, multiplied and taken to a power
using the symbols +
, 
, .
and ^
.
DotProduct(‹vector 1›, ‹vector 2›)
and CrossProduct(‹vector 1›,‹vector
2›)
evaluate the dot and crossproduct of ‹vector 1›
and ‹vector 2›
.
Transpose(‹matrix›)
, Determinant(‹matrix›)
, Trace(‹matrix›)
,
MatrixInverse(‹matrix›)
, Eigenvalues(‹matrix›)
,
Eigenvectors(‹matrix›)
do what their name says.
Graphics¶
Plots are shown on the worksheet and can be adjusted by clicking on them and working with the tools appearing in the menubar.
plot(‹expression(x)›,‹x›=‹start›..‹end›)
creates a 2D plot of the
‹expression(x)›
in the specified range.
To plot a ‹function›
the plot command looks like:
plot(‹function›(‹x›),‹x›=‹start›..‹end›)
The range on the yaxis can be given as a third argument ‹y›=‹start›..‹end›
.
The ‹x›
and ‹y›
determine the labels.
A list of data points is a list of twoelement sublists containing the x and y
coordinates of the points, e.g. ‹list› = [[‹x1›,‹y1›],[‹x2›,‹y2›]‹...›]
.
These points can be plotted by plot(‹list›)
.
plot()
can take further arguments in the style plot(‹...›,
‹attribute›=‹value› ‹,...›)
.
Plot attributes:
‹attribute› 
‹value› 
comment 

style 
line , point , patch 
general graph style 
color 
blue , red , black , ... 
many! See ?plot,colornames 
labels 
[‹xlabel›,‹ylabel›] 
the axes label 
linestyle 
‹integer› 
0: solid, 2: dots and dashes, 3: dashes 
symbol 
circle , point , box ,
cross , diamond 

Title 
‹string› 
the axes title 
Multiple plots on the same axis can be done by giving a list of expressions (or functions):
plot([‹expression1(x)›,‹expression2(x)›,‹...›], ‹x›=‹start›..‹end›)
Plotting attributes are set for each line by giving the ‹values›
in a list.
Plotting in 3D is similar to 2D:
plot3d(‹expression(x,y)›, ‹x›=‹x start›..‹x end›, ‹y›=‹y start›..‹y end›)
plot3d(‹function›(‹x›,‹y›), ‹x›=‹x start›..‹x end›, ‹y›=‹y start›..‹y end›)
plot3d([[‹x1›,‹y1›,‹z1›],[‹x2›,‹y2›,‹z2›]‹...›])
The plots package¶
Multiple plots can be done as follows:
‹name1› := plot(‹expression1(x)›, ‹x›=‹start›..‹end› ‹, attribute = value, ...›):
‹name2› := plot(‹expression2(x)›, ‹x›=‹start›..‹end› ‹, attribute = value, ...›):
display(‹name1›, ‹name2›)
The trailing :
is not essential but simply suppresses an echoing of the
defined names.
textplot([‹x›, ‹y›, ‹string›])
plots the ‹string›
(enclosed within
backticks `
) at the coordinates ‹x›/‹y›
. An additional argument
align=‹a›
can be given where ‹a›
is above
, below
, left
,
right
or a set thereof.
animate(‹expression(x,t)›, ‹x›=‹start›..‹end›, ‹t›=‹start›..‹end›)
with
possible attribute frames=‹number of frames›
creates an animation. There is
a similar animate3d
.
Java and Printing¶
Both Maple 12 and Maple 13 refused to show a printing dialog box on my 64bit
Linux. The culprit seems to be the java VM which ships with Maple. It is
however simple to advise Maple to use a different JVM. All you have to do is to
change two lines in the startup script ‹Maple root directory›/bin/maple
.
In my case I wanted to use the JVM provided by sun. I had to locate the case
"bin.X86_64_LINUX")
and changed the two lines:
MAPLE_JRE_BIN="$MAPLE/jre.X86_64_LINUX/bin/"
JRE_ROOT="$MAPLE/jre.X86_64_LINUX/lib"
to:
MAPLE_JRE_BIN="/usr/lib/jvm/java6sun/jre/bin/"
JRE_ROOT="/usr/lib/jvm/java6sun/jre/lib"
After this, printing worked.