Glossary
The Maple procedures and operators used in this manual are listed, in alphabetical order. If appropriate, a brief description of syntax and output is also included. In all cases see the corresponding Maple Help page for more complete explanations.
@ Composition
operator for functions. Syntax: f@g is the composition of functions f and g.
(f@@5) is f composed with itself 5 times.
(D@@5)(f) is the fifth derivative of f.
a..b The
range of values from a to b.
> int( sin(x), x=1..2); output:
Add A procedure in the LinearAlgebra package for adding vectors or matrices. Syntax: Add(A,B)
add The
procedure to use when adding a few numbers, vectors, etc. Syntax: add( f(k),
k=1..n).
> add( k*(k+1), k=-1..3); output: 20
alias Used
to create an alias of a long Maple name.
Syntax: alias( H=Heaviside);
Output: H
animate A
plot procedure that animates plots. In the plot package.
Syntax: animate( plot command, [ Input for plot command ], param=a..b,
frames=n)
animatecurve A procedure that creates an
animation of the plotting of a 2-d graph. In the plots package.
Syntax: animatecurve( f(x), x=a..b, frames=n)
Also applies to parametrized curves and works in polar coordinates (funky).
anonymous function
A function with no name.
> (x->x^2)(3); Output: 9
args The
name of the sequence of inputs in a procedure.
> f:=proc() "Hello",args[1],"how are
you." end proc: f(world,x,z);
Output: "Hello",world,"how
are you."
arguments The inputs in a procedure are called its arguments. See args and nargs.
array A
Maple data structure like a list but more versatile because the index set can
include negative integers and zero. Multiple indices can also be used. Syntax: array(a..b,c..d, ...,
list).
> A := array(-3..1,[1,2,3,4,5]): A[-1],A[0]; output: 3,
4
arrow Creates
and plots arrows. In the plots package.
Syntax: arrow([a,b]) plots an arrow from [0,0] to [a,b]
arrow( [a,b], [c,d] ) plots an arrow at [a,b] with direction [c,d]
arrow( [a,b], [c,d], difference=true) plots an arrow from [a,b] to [c,d]
Optional equations control the shape and size of the arrow.
arrow definition of a function
A function f can be created using the syntax f := x -> expression in x. This
is referred to as an arrow definition.
> f := x -> sin(x)/x; f(0) := 1:
arrows The optional equation arrows=none in the DEplot procedure will suppress the arrows. Use arrows=line to draw line segments instead of the default harpoon arrows.
assign A
procedure that converts an equation, equations, or a set or a list of equations
into assignments. Syntax: assign(x=expression)
> assign(x=5); output: none, but henceforth x will be a
name for 5.
To free the x variable use either unassign('x')
or x := 'x'
:= The
assignment operator. Assigns a name to an expression. Syntax: name :=
expression
> y := sin(t): t = z: y + x; output: sin(t) + x
Note that the equation t = z does not assign the name t to the expression z.
assume The
optional equation assume=property in
the simplify procedure can be
used to tell Maple to make the simplification under the stated assumption.
> simplify( sqrt(a^2), assume=positive); Output: a
The entry
> assume(x::positive); tells Maple to assume x is positive in
all calculations.
assuming Place an assumption on x in a particular calculation
by adding assuming x::property.
> simplify( sqrt(a^2) ) assuming a::negative; Output: - a
backward quotes Use
backward quotes ` `
to make any list of symbols into a name.
> `A big number`:=10: `A big number`, `A big
number`^2; output: 10, 100
base Keyword
for convert. Converts an integer to a
different base.
> convert(114,base,3); Output: [0, 2, 0, 1, 1]
BesselJ MapleÕs symbol for the Bessel functions of the first kind. BesselY denotes the Bessel functions of the second kind.
binary function A function of two variables, (x,y) -> expression in x and y.
binomial The binomial coefficient function: binomial(m,n) = m!/n!/(m-n)!
boolean connectives
Maple supports the boolean connectives implies,
and, or, xor
(exclusive or) as well as the unary not.
> is( 2=5 or 2=2); output: true
> is( 2=5 and 2=2); output: false
boolean function A
function having the values true, false.
> f := t-> type(t,numeric): f(sin(2)); Output: false (sin(2) is of type constant.)
break An
execution control command. The entry break
tells Maple to immediately leave the current repetition statement (for..do..end
do) and continue execution with the next input. See next
and return.
> for k from 1 to 10 do if isprime(k) then break end if; end do; k^2;
Output: 4
by Used
to make a repetition statement.
> for k from 6 by -2 to 0 while not isprime(k) do k end do;
Output: The numbers on separate
output lines.
cat Concatenation
function: cat(a,b) concatenates symbols a and b. If a and b are strings the
output is a string. The symbol || serves as a concatenation operator. a||b and cat(a,b) have same output when
a and b are unassigned symbols.
> cat(a,b); a||b; Output: Line1, ab Line2, ab
> cat("Hello","World"); Output: "HelloWorld"
> cat(x,1..5); Output:
> cat(x,1..5,y);
Output:
collect A
procedure that collects like terms in an expression. Use it to make
polynomials.
> collect( x*(y+x*(w+x*t)), x); output:
:: (double
colon) The double colon is used by
Maple to assign a property to a name.
> simplify( abs(x) ) assuming x::negative; Output:
coeff Calculates
the coefficients in a polynomial. Syntax: coeff( polynom, x, 4) or coeff( polynom, x^4)
> coeff( x*y^6 + x^3 + 3*x,x,1); Output:
Column A
procedure in the LinearAlgebra package. Returns
a column of a matrix. Syntax: Column(A,k)
> Column(<<1,2,3>|<4,5,6>|<7,8,9>>,2);
output: The second column of the
matrix.
ColumnSpace A procedure in the LinearAlgebra package. Returns a list of basis vectors for
the column space of a matrix. Syntax: ColumnSpace(A)
> ColumnSpace(<<1,2,3>|<4,5,6>|<7,8,9>>);
output: A list containing <1,0,1> and <0,1,2>
combine The
opposite of expand. Use keywords to combine subexpressions.
> combine(exp(a)*exp(b)+sin(x)*sin(2*x)); Output: exp(a+b) + cos(x)/2 - cos(3x)/2
concatenation The
symbol || (two vertical bars) is
called the concatenation operator. Use
it to form names by combining two sub names. The use of this operator is
discouraged. Use cat instead.
> x||(1..4); output: x1, x2, x3, x4
> cat(x,1..4); output: x1, x2, x3, x4
confrac Keyword
for convert, converts real numbers and
rational polynomial expressions to continued fraction form.
> convert((t^2+1)/(t^3-t), confrac, t);
contourplot Plots 2-d contours of
the form F(x,y) = c. In the plots package.
Syntax? contourplot( F(x,y), x=a..b, y=c..d, contours=n)
Also accepts contours=[list of values]
convert A
procedure that converts expressions of one type into those of a similar type.
Does partial fractions via parfrac. Syntax:
convert( expression, type)
> convert( [[1,2],[3,4]], Matrix);
> convert( 1/t^2/(t-1)^2, parfrac, t);
coordplot Plots
2 dimensional coordinate lines. In the plots package.
Syntax: coordplot( polar )
coordplot3d plots 3 dimensional coordinate surfaces.
cylinderplot Plots in cylindrical coordinates.
In the plots package. Plots r as a function of theta and z.
Syntax: cylinderplot( r(theta,z), theta=a..b, z=c..d)
D The
derivative operator. Used to differentiate functions. Syntax: D(f)
> f := x->x*sin(x): D(f); output: x -> sin(x) + x
cos(x)
DEtools A package of procedures used to analyze differential equations or a system of differential equations. Load it using with(DEtools).
DEplot A
procedure in the DEtools package. Plots
numerical solutions to differential equations and systems. Can also generate
direction fields and vector fields.
Syntax: DEplot( DE, y(x), x=-2..2, y=-2..2) will plot the direction field for a
first order ode named DE if its independent variable is x and its dependent
variable is y(x).
Add a set of initial conditions of the form { [a,b], [c,d] , etc. } to generate
solution curves.
degree Calculates
the degree of a polynomial. Include the principal variable.
> degree( x*y^6 + x^3 + 3*x,x); Output: 3
Determinant Procedure in LinearAlgebra to compute the detenminant of a matrix: Determinant(A).
diff The
differentiation procedure used for the differentiation of expressions.
Syntax: diff( expression, variable). Also computes partial derivatives. Inert
form: Diff.
> diff( sin(x), x); output: cos(x)
For the second derivative put in the independent variable twice.
> diff( sin(x), x, x); output: - sin(x)
Dirac The
Dirac delta function. Dirac is the derivative of Heaviside. Dirac's derivative
is denoted Dirac(1,x), etc.
> diff(Dirac(x),x); output: Dirac(1,x)
dirgrid The optional equation dirgrid=[m,n] can be used to control the number of arrows drawn by the DEplot procedure.
discont An
optional equation for the plot procedure: discont=true
tells Maple not to connect the end
points at a jump discontinuity. The default is discont=false.
display A
procedure that displays several plots at one time. In the plots package. Call it using plots[display].
> P1 := plot(sin(x),x=0..Pi): P2 := plot(cos(t),t=Pi..2*Pi):
plots[display](P1,P2); output:
The two plots on the same set of axes.
divide Boolean
to determine if polynomial g divides polynomial f: divide(f,g); The entry
divide(f,g,'q') tells Maple to store the quotient with the name q.
> divide(x^3+x+2,x+1); Output: true
> divide(x^3+x+2,x+1,'q'); q; Output: Line1, true,
Line2, x^2 - x + 2
do..end do A do
statement. Used in Maple programming. Typically appears as part of a for statement.
> S := {}: for k from 1 to 10 do S := S union {k}: end do: S;
output: {1, 2, ... , 10}
dsolve A
procedure for solving differential equations, both symbolically and
numerically. Syntax: dsolve( DE ), dsolve( {DE, inits} ), dsolve( {DE, inits},
y(x), type=numeric) where DE is a differential equation and inits is a sequence
of initial values.
> dsolve( diff(y(t),t) = y(t) ); output: y(t) = _C1 e^t
Eigenvalues Procedure in LinearAlgebra packate. Eigenvalues(A) returns A's eigenvalues in a column vector.
Eigenvectors Procedure in LinearAlgebra packate. Eigenvectors(A) returns A's eigenvalues in a column vector and its eigenvectors as columns in a matrix.
elif Abbreviation
for "or else if". Used in if..then statements.
> a:=1: b:=2:
if a>b then OK elif a=b then
NOT else BIG end if;
Output: BIG
else Used in if..then statements. See the example above.
eval A
procedure used to evaluate an expression or the expression represented by a
symbol.
Syntax: eval( expression) or eval(expression, variable=value)
> eval( sin(2*x), x=Pi); output: 0
The entry eval(symbol,n) evaluates symbol to level n.
> x:=y: y:=z: z:=3: eval(x,2),eval(x,1),eval(x); Output: z, y, 3
evalf A
procedure used to evaluate a symbolic constant to floating point form.
> evalf( sin(Pi/4), 4); output: 0.7070
evaluation rules Maple applies the rule of full evaluation to most names that are defined in a worksheet. First level evaluation applies to all local variables in a procedure. Last name evaluation applies to symbols representing some objects (tables and arrays). Use eval or print to force full evaluation.
expand Applied
to an expression, expand multiplies
out, applies trig identities, expands exponential and log expressions, etc. to
break the input into smaller pieces (not necessarily simpler).
> expand( sin(x+y); Output:
sin(x) cos(y) + cos(x) sin(y)
expression Any group of symbols that makes sense to Maple. That is, Maple can process it and produce an output (which might be NULL).
expression tree Expression
tree refers to a graph constructed from the data structure of a Maple
expression. The procedures and the symbols in the expression appear as nodes.
An expression sequence does not have an expression tree.
factor Used
to factor polynomials, not integers. Use ifactor
to factor integers.
> factor( x^4-x); Output: x(x-1)(x^2+x+1)
factorset A
procedure in the numtheory package. Finds the prime factors of an integer.
> factorset(1234567890); output: {2, 3, 5, 3607, 3803}
fieldplot Plots
vectors in a 2-d vector field. In the plots package.
Syntax: fieldplot( [f(x,y),g(x,y)], x=a..b, y=c..d, arrows=slim,
dirgrid=[12,12])
Other arrow styles are available. Default, harpoon arrows.
first level evaluation
An evaluation rule. First level evaluation applies to local variables in a
Maple procedure.
> f:=proc() local x,y,z; x:=y; y:=z; z:=3; x; end
proc: f(); Output: y
floor A
function that returns the largest integer less than or equal to the input
number.
> floor(Pi), floor(-Pi); output: 3, -4
for Starts
a for statement, useful in Maple
programming. Often used in conjunction with a do statement. Syntax: for k from a to b by c (or, for k from a by c to b)
> S:=0: for k from -1 to 3 by 1/2 do S:=S+k: end do:
S,k; output: 7/2, 9
full evaluation An
evaluation rule. A name or symbol used in a Maple worksheet is generally given full
evaluation when called in subsequent
entries.
> x:=y: y:=z: z:=3: x; Output: 3
fsolve A
procedure for obtaining floating point (approximate) solutions to an equation
in one variable. Specify a search interval by adding a range a..b.
> fsolve( sin(x) = sqrt(x)*cos(x), x, 0..1); output:
.6948992874
function Can
refer to the classic function concept. To create such a function use the arrow
operator.
> f := x -> x*sin(x); output: f:= x -> x sin(x)
GAMMA The
Gamma function: GAMMA(x) = (x-1)! when x
is a positive integer.
> GAMMA(3), GAMMA(4), GAMMA(1/2);
output: 2, 6, sqrt(Pi)
gamma EulerÕs constant.
gcd Polynomial
greatest common divisor function.
> gcd(x^2+4*x+4,x^2+x-2); Output: x + 2
global A
variable used in a Maple procedure can be declared global. Such variables,
which are fully evaluated, will interact with variables used outside of the
procedure as if they were defined outside the procedure. See full evaluation. Maple discourages the use of global variables in a
procedure. Use a name declaration in the input instead. See name
declaration.
> f:=proc(y,x,der::name) der:=diff(y,x); end proc:
y:=sin(t^2): f(y,t): yprime;
Output: 2 cos(t^2) t
has Binary
boolean to determine if an expression has a certain sub-expression.
> has( x^2 + sin(x) - 2, sin); Output: true
Heaviside The unit step function. Heaviside(0) is undefined.
identify Attempts
to identify a floating point approximation as an exact number
> identify(3.14159); Output: Pi
Do not use it for "easy" numbers like 5.2.
> identify(5.2); Output:
5.
if..then if..then
statements are useful programming tools in Maple. Finish with end if.
> a:=1: b:=2: if (a+1<b-1) then a+b else a-b end if;
output: -1
ifactor Used
to factor integers. Use factor
to factor polynomials.
> ifactor(123456); Output: (2^6)(3)(643)
igcd Integer
greatest common divisor.
> igcd(123,456,789); Output: 3
ilcm Integer
least common multiple.
> ilcm(123,456,789); Output: 4917048
implicitplot Plots equations in two variables
(implicitly). In the plots package.
Syntax: implicitplot( x^2 + y^2 = 1, x=-2..2, y=-2..2)
Use grid=[m,n] to get smoother curves. Use implicitplot3d
for 3-d plots.
intersect Set
intersection. Syntax: A intersect B
> {1,2,3} intersect {2,3,4}; output: {2,3}.
inequal Plots
inequalities. In the plots package. Put the inequalities in a list.
Syntax: inequal( [ Inequalities ], x=a..b, y=c..d)
Use optional equations: optionsfeasible=(color=red),
optionsexcluded=(color=yellow) to color the regions.
infinity Used
to designate Òlarger than any positive numberÓ. Prints as the infinity symbol
(sideways 8)
> limit( sin(x)/x, x=infinity); output: 0
infolevel A Maple procedure that can be used to request more information about a particular Maple procedure. For example, the entry infolevel[dsolve] := 2 causes Maple to list the methods it applies when dsolve is used to solve a differential equation.
int The
integration procedure, both indefinite and definite. Syntax:
int(expression,variable). Inert form: Int.
> int( sin(x), x); output: - cos(x)
> int( sin(x), x=0..Pi); output: 2
interface Maple
procedure used to set interface variables (those Maple variables that effect
the interaction between Maple and the user).
> interface(verboseproc=2); Output: Current value for verboseproc
(default = 1).
Henceforth Maple will print more information about procedures.
iquo The
integer quotient function: iquo(a,b) is the greatest integer less than or equal
to a/b, (a, b integers). The entry iquo(a,b,'r') stores the remainder with the
name r.
> iquo(10,3); Output: 3
> iquo(10,3,'r'): r; Output: 1
irem The
integer remainder function: irem(a,b) is the remainder when a is divided by b
(a, b integers). The entry irem(a,b,'q') stores the quotient with the name q.
> irem(10,3); Output: 1
> irem(10,3,'q'): q; Output: 3
is A
procedure used to ask a question having an answer that is either true or false.
Syntax: is( expression, property or type)
> n:=1.5: m:=3/2: is(10*n,integer), is(10*m,integer);
output: false, true
Question: What happened here?
Answer: 10*n evaluates as the
floating point number 15.0 which Maple does not consider to be an integer. 10*m
evaluates as the integer 15.
isprime Boolean
function that determines if an integer is prime.
> isprime(1234567); Output: false
last name evaluation
An evaluation rule. Maple applies last name evaluation to symbols representing some types of data
(including tables and arrays). Use eval or print to force full evaluation.
> A := array(0..2,[1,2,3]): B := A: B; Output: A
> eval(B); Output:
ARRAY([0..2], [(0)=1, (1)=2,
(2)=3])
lcm Polynomial
least common multiple function.
> lcm(x^2+4*x+4,x^2+x-2); Output: (x+2)(x^2 + x - 2)
ldegree Calculates
the least degree of a polynomial. Include the principal variable.
> ldegree( x*y^6 + x^3 + 3*x,x); Output: 1
left Used
to make a left hand limit.
> limit( sin(x)/x^2, x=0, left); output: - infinity
lhs Left
hand side procedure. Outputs the left hand side of an equation.
> lhs( E = m*c^2); output:
length The
length function returns the length of an integer.
> length(123^321); Output: 671
limit The
limit procedure. Syntax: limit(expression,variable=value). Inert form: Limit.
> limit( sin(x)/x, x=0); output: 1
LinearAlgebra
A package of procedures to handle vectors and matrices. Load it using with(LinearAlgebra).
LinearSolve A procedure in the LinearAlgebra package for solving a matrix equation AX =
B. Syntax: LinearSolve(A,B)
> LinearSolve(<<1,2>|<3,4>>,<5,6>);
output: The column vector <-1,2>.
linestyle The
optional equation linestyle=2 in a plot procedure
draws curves using dotted lines. There are four linestyles. The default is linestyle=1. Use the following input to see all four
styles.
> plot([1,2,3,4],0..5,0..5,linestyle=[1,2,3,4],color=black);
list A sequence enclosed in square brackets. Syntax: [a, b, c, ... , d]
local A variable used in a Maple procedure can be declared local. Such variables, which are only evaluated to the first level, do not interact with variables used outside of the procedure. See first level evaluation.
map Used
to map functions into expressions.
> map(f,[x,y,z]); Output: [f(x), f(y), f(z)]
map2 Used
to map functions f(x,y) into expressions.
> map2(f,a,[x,y,z]); Output: [f(a,x), f(a,y), f(a,z)]
Matrix A
procedure used to create matrices. Use it whenever the matrix is to be
manipulated by procedures in the LinearAlgebra package.
Syntax: Matrix(m,n,[ [a,b,..,c],...,[d,e,..f]]) creates an m x n matrix with
rows [a,b,..,c], ... , [d,e,...,f]. The same matrix can be made by
entering <<a,b,..,c>|...|<d,e,...,f>>.
An entry of the form Matrix(m,n,(i,j)->f(i,j)) can also be used.
maximize A
procedure that returns the maximum value of an expression of one variable.
Syntax: maximize( expression, variable=a..b).
> maximize( sin(x), x=0..Pi); output: 1
minimize works in the same way.
Maximize A
numerical procedure in the Optimization package
(Maple 9.5).
Syntax: Maximize( expression, set of constraints).
> Maximize(sin(x),{x >= 0, x<=Pi}); output: [1.,x
= 1.57079632679504266].
Minimize works the same way.
member Binary
boolean function to determine membership (set, list).
> member(3, {1,2,3} ); Output: true
minus Set
subtraction. Syntax: A minus B
> {1,2,3} minus {2,3,4}; output: {1}.
Multiply A
procedure in the LinearAlgebra package for
multiplying matrices.
Syntax: Multiply(A,B). The syntax A.B
can also be used for matrix multiplication.
name declaration Maple
discourages the use of global variables in a procedure. Use a name declaration
in the input instead.
> f:=proc(y,x,der::name) der:=diff(y,x); end proc:
y:=sin(t^2): f(y,t): yprime;
Output: 2 cos(t^2) t
nargs The
number of inputs in a procedure. The inputs are called the arguments
of the procedure.
> f:=proc() "Hello you",nargs,"how are you." end
proc: f(world,x,z);
Output: "Hello you",3,"how are you."
next An
execution control command. The entry next
tells Maple to immediately increment the counter in a for..while do loop. See break and return.
> for k from 1 to 5 do if isprime(k) then next end if; k; end do;
Output: 1 and 4 on separate output
lines.
nextprime A
Maple procedure, nextprime(n) returns the next prime after the integer n.
> nextprime(11111111111111); Output: 11111111111123
numpoints An option in plot procedures. For example, the equation numpoints=200 tells Maple to plot at least 200 points when making a line graph.
numtheory The name of a package of special procedures to deal with questions in number theory. See factorset.
op, nops The
procedure op extracts the operands from an expression, nops counts them.
Syntax: op(expression) returns a sequence of all the operands in an expression,
op(k,expression) returns the kth operand,
op(0,expression) returns the top level type of the expression
nops(expression) returns the number of operands in an expression.
> op(a+b), nops(a+b), op(2,a+b), op(0,a+b); output: a,
b, 2, b, +
Optimization A package of numerical optimization procedures. New to Maple 9.5.
output=array Use the optional equation output=array(list) in the numeric dsolve
procedure
dsolve(..., type=numeric) to get an output consisting of
an array of approximate solution values.
parfrac Keyword
for convert, converts rational
polynomial expressions to partial fraction form.
> convert((t^2+1)/(t^3-t), parfrac, t); Output: 1/(t+1) - 1/t + 1/(t-1)
patchcontour One of several optional plot styles
for 3d graphs. This one draws contour lines on the surface.
Syntax: style=patchcontour. Other styles include patch, patchnogrid, contour,
wireframe.
% Percent
sign, also called the ditto operator.
Refers to the last Maple output, in time.
> sin(Pi/4): evalf(%); output:
.7071067810
Pi MapleÕs symbol for the famous mathematical constant.
piecewise A
procedure used to make piecewise defined expressions.
Syntax: piecewise( x<0, x, x<=2, x^2, sin(x)) makes the expression that
evaluates to x if x < 0, x^2 if x is not less than 0 but is less than or
equal to 2, and to sin(x) otherwise.
plot The
Maple procedure for making 2 dimensional plots. Use plot3d for 3 dimensional
plots.
> plot( sin(x), x=0..Pi); output: The graph of sin(x)
from x = 0 to x = Pi.
plots A
Maple package of specialized plot procedures. Load it using with(plots). To call a particular procedure use plots[procedure].
> plots[implicitplot]( x^2 = y^2 -1, x=-3..3, y=-3..3);
output: a 2d plot of the equation in the window Ð3
² x ² 3, -3 ² y ² 3.
pointplot Plots
points in 2-dimensions. In the plots package. Different symbols can be used
(circle, box, cross, diamond).
Syntax: pointplot( [ [a,b], [c,d], ... ], symbol=cross, symbolsize=18 )
polygonplot Plots 2-d convex
polygons. In the plots package. Put the vertices in a list.
Syntax: polygonplot( [ Vertices ] )
Use polygonplot3d for polygons in 3 dimensions.
polyhedraplot Plots 3 dimensional polyhedra. In the plots
package.
Syntax: polyhedraplot( [a,b,c], polytype=dodecahedron, polyscale=1)
Enter polyhedra_supported() to see a set of polyhedra that Maple can plot.
polynom Abbreviation
for polynomial. Used, for example, in the convert
procedure.
> convert( taylor(sin(x),x=0), polynom); output: x -
x^3/6 + x^5/120
prevprime A
Maple procedure, prevprime(n) returns the prime preceding the integer n.
> prevprime(11111111111111); Output: 11111111111053
print A
procedure used to make Maple print something. Text can be printed if enclosed
in backwards quotes as illustrated below.
> print(`My name is Joe.`,5+4,int(sin(x),x));
output: My nam is Joe., 9, - cos(x)
printlevel A Maple variable whose value determines how much information is included in a Maple output. Default value is printlevel := 1, printlevel := -1 tells Maple to suppress all output. See infolevel.
proc Makes
user-defined procedures.
> f := proc(x) x^2-x+sin(x) end proc: f(car); output:
car^2 - car + sin(car)
The same effect can be accomplished with the arrow notation.
> f := x -> x^2-x+sin(x); f(car);
output: line1:f:= x -> x^2 - x + sin(x), line 2: car^2 - car + sin(car)
quo Polynomial
quotient function: quo(f,g,x) is the quotient when polynomial f is divided by
polynomial g (rational coefficients). The entry quo(f,g,x,'r') computes the
quotient and stores the remainder with the name r. Inert form Quo, used in
conjunction with mod p (p a prime), tells Maple to calculate over the ring of
integers mod p.
> quo(x^4+x^3+x+1,x^2-1,x); Output: 1 + x + x^2
> quo(x^4+x^3+x+1,x^2-1,x,'r'): r; Output: 2 + 2x
> Quo(x^4+3*x^3+2*x^2+4,x^2-1,x) mod 3 Output: x
rationalize Rationalizes
expressions with fractional exponents.
> rationalize((x+x^(1/3))/(x^(3/2)+x^3));
rand A Maple procedure with no arguments. The entry rand() outputs a (pseudo) random 12 digit positive integer. An entry of the form rand(a..b)() outputs a random integer in the range a..b.
Rank A
procedure in the LinearAlgebra package. Returns
the rank of a matrix. Syntax: Rank(A)
> Rank(<<1,2,3>|<4,5,6>|<7,8,9>>);
output: 2
ReducedRowEchelonForm
A procedure in the LinearAlgebra package. Returns
the reduced row echelon form of a matrix.
Syntax: ReducedRowEchelonForm(A)
>
ReducedRowEchelonForm(<<1,2,3>|<4,5,6>|<7,8,9>>);
output: <<1,0,1,>|<0,1,0>|-1,2,0>>
rem Polynomial
remainder function: rem(f,g,x) is the remainder when polynomial f is divided by
polynomial g (rational coefficients). The entry rem(f,g,x,'q') computes the
remainder and stores the quotient with the name q. Inert form Rem, used in
conjunction with mod p (p a prime), tells Maple to calculate over the ring of
integers mod p.
> rem(x^4+x^3+x+1,x^2-1,x); Output: 2 + 2x
> rem(x^4+x^3+x+1,x^2-1,x,'q'): q; Output: 1 + x + x^2
> Rem(x^4+x^3+x+1,x^2-1,x) mod 2; Output: 0
remember An
option in a procedure. Tells Maple to remember values that it has calculated.
They are stored in a table and used if needed in a subsequent calculation.
remove Removes
elements from and expression based on a boolean function criterion.
Syntax: remove(boolean,expression).
> remove(t->is(degree(t,x)>3),[x^2+x,x-x^4,x,x^5+3]);
Output: [x^2 + x, x]
return An
execution control command used only in procedures. The entry return tells Maple to immediately leave the procedure and
output what follows the word return. See break and next.
> f:=proc(n) local k;
for k from n+1 do if isprime(k)
then return k end if; end do;
end proc;
> f(7);
Output: 11.
rhs Right
hand side procedure. Outputs the right hand side of an equation.
> rhs( E = m*c^2); output: m c^2
right Used
to make a right hand limit.
> limit( sin(x)/x^2, x=0, right); output: infinity
RootOf A
function that represents the roots (zeros) of an expression. Often appears in
the output of the solve procedure to represent an exact value.
> solve( tan(x) = x^2, x); output: RootOf(-tan(_Z) + _Z^2)
$ The
sequence operator. Used to make sequences. Syntax: f(k) $ k=a..b
> k/(k^2+1) $ k=-1..3; output: -1/2, 0, 1/2, 2/5, 3/10
select Selects
elements in and expression based on a boolean function criterion.
Syntax: select(boolean,expression).
> select(t->is(degree(t,x)>3),[x^2+x,x-x^4,x,x^5+3]);
Output: [x - x^4, x^5 + 3]
selectremove Selects and removes elements in and
expression based on a boolean function criterion.
Syntax: selectremove(boolean,expression).
> selectremove(t->is(degree(t,x)>3),[x^2+x,x-x^4,x,x^5+3]);
Output: [x - x^4, x^5 + 3], [x^2 + x, x]
seq The
sequence procedure. Used to make sequences. Syntax: seq( f(k), k=a..b)
> seq( k/(k^2+1), k=-1..3); output: -1/2, 0, 1/2, 2/5,
3/10
> seq( k/(k^2+1), k=[a,3,car]); output: a/(a^2+1),
3/10, car/(car^2+1)
sequence A family of expressions, separated by commas.
series Generates
a series representation of an expression. Syntax: series( expression,
variable=value). The default order of the representation is 6.
> series( BesselJ(0,x), x=0);
setoptions A procedure
in the plots package used to set global options for the plots in a worksheet.
Syntax: setoptions( color=black, font=[times,roman,10] )
simplify Applies
standard simplification rules to an expression. Use it as a first attempt at
simplifying a complicated expression.
> simplify( cos(x)*(x^2 + 2*x + 1)/(x+1) ); output: (x+1) cos(x)
sincos Keyword
for convert. Converts trig expressions
to sines and cosines.
> convert( tan(x)^2 + sec(x)^2, sincos);
single quotes Single
quotes ' ' are used in Maple to
postpone evaluation one time.
> 'int( sin(x), x=0..1)'; value(%);
output: line 1: unevaluated integral, line 2: - cos(1) + 1
Sketch A sketch pad can be inserted into a Maple worksheet. See the Insert menu.
solve A
procedure for finding exact solutions to an equation in one variable.
> solve( x^3 - x - 1 = 0, x); output: 0, 1/2 +
sqrt(5)/2, 1/2 - sqrt(5)/2
sort Sorts
a polynomial in decreasing order of degree. Sorts a list of strings
lexicographically. Add an optional binary boolean function to determine a sort
criterion for a list.
> sort(1+x^3-2*x^2); Output: x^3 - 2x^2 + 1
> sort( [1,2,x,1-x^2,1/x],(u,v)->is(degree(u)>degree(v)));
Output: [1-x^2, x, 2, 1, 1/x]
spacecurve Plots
parametrized curves in 3 dimensions. In the plots package.
Syntax: spacecurve( [f(t),g(t),h(t)], t=a..b)
Use plot3d for parametrized surfaces in 3 dimensions.
Spellcheck On the Tools menu. Use it.
sphereplot Plots in
spherical coordinates. In the plots package. Plots rho as a function of theta
and phi.
Syntax: sphereplot( rho(theta,phi), theta=a..b, phi=c..d)
Spreadsheet A spreadsheet can be inserted into a Maple worksheet. See the Insert menu.
stepsize Use the optional equation stepsize=h to control the step size for dsolve(type=numeric) and DEplot.
string Any
number of typed symbols enclosed in double quotation marks.
> "How are you? 123 cos(x)";
output: "How are you?
123 "
subs A
procedure used to make substitutions. Syntax: subs(equations,expression). See
algsubs and subsop.
> subs(x=3,y=2,x^2 + x*y); output: 15
sum The
procedure to use when adding an infinite number of numbers, functions, etc.
Inert form is Sum.
Syntax: sum( f(k), k=1..infinity). Also works for finite sums but is not
recommended.
> sum( 1/k/(k+1), k=1..infinity); output: 1
> sum( x^k/k!, k=0..infinity); output: exp(x)
table A data structure like an array but more flexible. The indices can be a number or a name. An entry of the form T[1,2] := expression tells Maple to set up a table with the name T and start to fill it with expression stored with index (1,2).
taylor A
procedure that generates the Taylor series representation of an expression.
Syntax: taylor( expression, variable=value). The default order of the
representation is 6.
> taylor( sin(x), x=0); output: x - x^3/6 + x^6/120 +
O(x^6)
textplot Creates
text that can be displayed using display. In the plots package.
Syntax: textplot([a,b,"text"]) or, for 3-d,
textplot([a,b,c,"text")
Accepts optional equations for font control and alignment. Default is
align=CENTER.
thickness The optional equation thickness=2 tells Maple to draw thicker lines in a 2 dimensional plot. The default thickness is 1. Thickness values can be 1, 2, 3, or 4.
tickmarks An optional equation for the plot procedure: tickmarks=[m,n] sets the minimum number of values for the horizontal and vertical axes. Maple may refuse if m or n is too large.
time A
procedure for timing a Maple calculation. Syntax: time( input ). The entry
time( ) returns the total computing time from the beginning of the current
session.
> time( plot(sin(1/x), x=0..1, numpoints=300) ); output: 0.580
> time();
output: 6.060
transparency The optional equation transparency=n where n is between 0 and 1 controls the transparency of a 3-d surface. Default: transparency=0.
Transpose A
procedure in the LinearAlgebra package.
Transposes a matrix. Syntax: Transpose(A)
> Transpose(<<1,2>|<3,4>>); output:
<<1,3>|<2,4>>
trace A
Maple debugging tool, trace(proc_name)
causes Maple to display the whole sequence of outputs when proc_name is invoked. Use untrace(proc_name) to stop tracing. See printlevel.
tubeplot Plots
tubular surfaces. In the plots package. Control the radius of the tube with
radius=r(t).
Syntax: tubeplot( [f(t),g(t),h(t)], t=a..b, radius=r(t),
type Used
to inquire about the data type of an expression. Output is true or false
(binary boolean)
Syntax: type( 3, integer); output:
true
unapply The
procedure to use to turn an expression into a function.
Syntax: unapply( expression, variables)
> g := unapply( x*sin(x*y), x, y); Output: g := (x,y) -> x sin(xy)
unassign A
procedure that is used to unassign values. Syntax: unassign( 'y' )
> y := sin(t): y = z; unassign('y'); y + x;
output: line 1: sin(t) = z, line
2: y + x
The assignment y := 'y' has the same effect as unassign('y').
union Set
union. Syntax: A union B.
> {1,2,3} union {2,3,4}; output: {1,2,3,4}.
value A
procedure used to ask Maple the value of an expression or a name. Note the
backward quotes in the second input.
> X := 'int( sin(x), x)': value(X); output: - cos(x)
> X := `int( sin(x), x)`: value(X); output: int(
sin(x), x)
Vector A
procedure that makes column vectors. Syntax: Vector([a,b,...,c]).
Such a vector can also be created by entering <a,b,...,c>.
To create a row vector use either Vector[row]([a,b,...,c])
or <a|b|...|c>.
verboseproc A Maple variable whose value determines the amount of information that Maple outputs when a procedure is evaluated via eval(procedure) or print(procedure). The default value is 1.
whattype A
procedure that is used to ask Maple the data type of an expression. Syntax:
whattype(expression)
> whattype(3), whattype(3.0), whattype([1,2]); output: integer,
float, list
Also whattype( eval(expression)).
while Used
to make a repetition statement.
> for k from -5 to 10 by 2 while not isprime(k) do k end do;
Output: The numbers on separate
output lines.
xtickmarks An optional equation for the plot procedure: xtickmarks=m tells Maple to put at least m numbers on the horizontal axis. If m is too large, Maple will refuse.
ytickmarks An optional equation for the plot procedure: ytickmarks=n tells Maple to put at least n numbers on the vertical axis. If n is too large, Maple will refuse.
zip Procedure
used to merge lists, vectors, matrices. The merge criterion is entered as a
binary function.
> zip((x,y)->x/(y+x),[1,2,3],[a,b,c]); Output: [1/(a+1), 2/(b+2),
3/(c+3)]