Contents Previous Next Index

3 Maple Expressions


This chapter introduces Maple expressions associated with scalar data structures.

3.1 In This Chapter


•

Introduction: automatic simplification and evaluation; syntax and constructors

•

Using names, strings, and numbers in expressions

•

Unevaluated expressions

•

Expression types: arithmetic, Boolean, relational, and settheoretic expressions; expressions for data structures; indexed expressions; function and member selection expressions

•

Classifying, examining, and manipulating expressions



3.2 Introduction



Expressions and Statements


Maple language elements can be classified as either expressions or statements. An expression is a firstclass data element in the Maple language. In other words, expressions can be stored in data structures, passed as arguments to procedures, and manipulated in various ways; they are often used to represent mathematical objects. Statements, on the other hand, are not firstclass data elements; they generally describe nonmathematical programming constructs and are used to affect the state of Maple.
This chapter describes expressions associated with scalar data structures. For information about nonscalar data structures, see Basic Data Structures.
For more information about Maple statements, see Maple Statements.


Automatic Simplification and Evaluation


Maple uses two processes to compute expressions: automatic simplification and evaluation. Automatic simplification is a process that Maple applies to the input immediately; this process cannot be controlled. Expression evaluation occurs after an initial round of automatic simplification; this process can be controlled in certain ways. For each kind of expression described in this chapter, the rules for both automatic simplification and expression evaluation are described.


Syntax and Constructors


You can create most expressions by entering the appropriate syntax. However, some expressions, such as expressions that include tables or a series, can only be created by calling a constructor. A constructor is a command that can be used as an alternative method of creating certain expressions.
For example, a sum that would normally be entered using the syntax for addition
${a}{+}{b}{+}{c}{+}{d}$
 (1) 
can also be entered using the constructor `+`.
${a}{+}{b}{+}{c}{+}{d}$
 (2) 
With some exceptions (for example, series, lists, sets, and procedures), the name of the constructor for an expression can be displayed by using the op command with its first argument equal to 0.
>

op( 0, a + b + c + d );

The example above shows that the constructor for the expression a + b + c + d is the command assigned to the name `+`.



3.3 Names


Names have several purposes in Maple. They can be used to reference algebraic indeterminates, symbols, and variables in your code.
Names provided a basic introduction to Maple names. The following section describes concepts related to names in more detail.
A Maple name can be either global or local, depending on its scope. In this chapter, only global names are used. A global name is created either by referring to it at the top level of your program or by declaring it to be global in either a procedure or module definition. For more information about scope, see Variables in Procedures.
Two names are the same if they have the same spelling and scope. Maple keeps only one copy of any name in memory, so in a large expression that includes an indeterminate x, only one copy of the name x is kept in memory. Each occurrence of x in the expression refers to the same name x.
The polynomial
${{x}}^{{3}}{}{3}{}{{x}}^{{2}}{+}{3}{}{x}{}{1}$
 (4) 
contains three occurrences of the name x, but all three point to the same location in memory.
Maple is unique in that names can represent themselves. As a result, you can use names as algebraic indeterminates, for example, to construct polynomials or other algebraic expressions.
Names can also be used to represent variables in your code. When a name is assigned a value, that name is associated with another expression and evaluating the name results in its assigned value being returned. When a name is unassigned, evaluating the name results in the name itself.
In this example, the name a is assigned to the value 2.
Before using a name on the left side of an assignment, the name has no assigned value.
When a value is assigned to a name, subsequent evaluation of the name results in its assigned value.
For more information about assigning values, see Assignments.

Creating Names: Lexical Conventions


When creating names in Maple, you must be aware of certain lexical conventions.

Environment Variables


Names beginning with an underscore character (_) are reserved for use by the Maple library. You should not create names that begin with an underscore.
As a special case, any name beginning with the four character sequence "_Env" is treated as an environment variable.
Environment variables are a special kind of variable in that an assignment to one within a procedure is automatically unassigned when the procedure has finished running. Therefore, environment variables only affect subprocedures called from that procedure, unless they are superseded locally.
The following predefined environment variables do not begin with _Env: Testzero, UseHardwareFloats, Rounding, %, %%, %%%, Digits, _ans, index/newtable, mod, Order, printlevel, Normalizer, NumericEventHandlers.

Environmental Variables Scope


Unlike a local variable, whose scope is restricted to the procedure containing the local variable itself, an environment variable can be referenced globally by all subprocedures called by or deeper than the current procedure, but the environment variable cannot be referenced by procedures above the current procedure.

For more information about environment variables, refer to the envvar help page. For more information about procedures, see Procedures or refer to the procedure help page.


Constants


In addition to keywords, as described in Reserved Words, Maple has several predefined constants.
You can display a sequence of all the names that represent symbolic constants in Maple by using the global variable constants.
${\mathrm{false}}{,}{\mathrm{\gamma}}{,}{\mathrm{\infty}}{,}{\mathrm{true}}{,}{\mathrm{Catalan}}{,}{\mathrm{FAIL}}{,}{\mathrm{\pi}}$
 (8) 
>

seq(i=evalf(i), i in constants);

${\mathrm{false}}{=}{\mathrm{false}}{,}{\mathrm{\gamma}}{=}{0.5772156649}{,}{\mathrm{\infty}}{=}{Float}{}\left({\mathrm{\infty}}\right){,}{\mathrm{true}}{=}{\mathrm{true}}{,}{\mathrm{Catalan}}{=}{0.9159655942}{,}{\mathrm{FAIL}}{=}{\mathrm{FAIL}}{,}{\mathrm{\pi}}{=}{3.141592654}$
 (9) 
Maple also has several other special constants. Table 3.1 lists some of them. For more information, refer to the initialconstants help page.
Table 3.1: Initially Known Names 
Name

Meaning

Name

Meaning

lasterror

the most recent error

constants

initially known symbolic constants

libname

path of the Maple libraries

Digits

number of digits in floatingpoint computations

NULL

empty expression sequence

FAIL

cannot determine value

Order

truncation order for series

printlevel

control display of information

I

complex number

undefined

undefined numeric quantity


For more information about constants in Maple, refer to the type/constant help page.


Protected Names


A protected name has a predefined meaning; you cannot directly assign a value to a protected name. For example, the names of builtin commands such as sin; utility operations such as degree; commands such as diff; and type names such as integer and list, are protected names. An error occurs if you attempt to assign a value to any of these names.
The Maple system prevents these names from reassignment. However, even though it is not recommended, it is possible to reassign values to these names by first unprotecting them as illustrated by the following statements.
Note: You can unassign values to Maple system names by entering a restart command or by ending your Maple session. In general, using the unprotect command to modify Maple system names is not recommended.
${\mathrm{sin}}{\u2254}{''a\; sin\; indeed''}$
 (10) 
As a result, Maple components that rely on the sine function may not work as expected.
>

plot( sin, 0..2*Pi, coords=polar );

To check whether a name is protected, use the type command.
To prevent values from being assigned to a name, use the protect command.
${\mathrm{mysqr}}{\u2254}{x}{\mapsto}{{x}}^{{2}}$
 (13) 
>

type(mysqr, protected);





3.4 Unevaluated Expressions


In general, Maple evaluates all expressions immediately. In some situations, it is necessary to delay the evaluation of an expression. An expression enclosed in right single quotes is called an unevaluated expression. It takes the general form
where expr is an arbitrary expression. All of the expressions contained within the right single quotes are not evaluated.
For example, the sin command normally performs the following computations.
To prevent the evaluation of these computations, you can enclose the expressions in right single quotes (also called unevaluation quotes) as follows.
${\mathrm{sin}}{}\left({0.5}\right)$
 (17) 
${\mathrm{sin}}{}\left(\frac{{\mathrm{\pi}}}{{2}}\right)$
 (18) 
You can enclose expressions of any length or complexity in unevaluation quotes.
>

'sin( 0.5 )^2 + cos( 0.5 )^2';

${{\mathrm{sin}}{}\left({0.5}\right)}^{{2}}{+}{{\mathrm{cos}}{}\left({0.5}\right)}^{{2}}$
 (19) 
Also, you can enclose subexpressions in unevaluation quotes to prevent certain parts of an expression from evaluating.
>

'sin( 0.5 )'^2 + cos( 0.5 )^2;

${{\mathrm{sin}}{}\left({0.5}\right)}^{{2}}{+}{0.7701511530}$
 (20) 
The sections below describe cases in which you may want to delay evaluation.

Protecting Names and Options


Unevaluation quotes can be used to prevent the evaluation of names.
${a}{\u2254}{{x}}^{{2}}{+}{x}{+}{1}$
 (21) 
${{x}}^{{2}}{+}{x}{+}{1}$
 (22) 
This is important when you want to use a variable as a name, regardless of whether it has an assigned value.
Also, unevaluation quotes can be used to protect options. Names are often used as options to control the behavior of a command. If the name of that option has been used as a variable, the command that has been called uses the value of the variable and not the option name as expected. Unevaluation quotes can be used around option names to protect against this.
${\mathrm{symbolic}}{\u2254}{4}$
 (24) 
>

sqrt( 9*x^2*y, 'symbolic' );

${3}{}{x}{}\sqrt{{}{y}}$
 (25) 
In the next example, an exception is raised because the name of a command option is not enclosed in unevaluation quotes.
>

CodeGeneration:C( x^2, output = string );

In this example, the best way to use the output option is to quote the name, thus preventing its evaluation in case the name output has an assigned value.
>

CodeGeneration:C( x^2, 'output' = 'string' );

${''cg\; =\; x\; *\; x;''}$
 (26) 
Tip: It is also recommended that you also use unevaluation quotes for the names of types and conversions. For more information, see Structured Types.
For more information on types and conversions, refer to the type and convert help pages.


Generic Expressions


Expressions sometimes describe the operation to take place in a generic sense. For example, B[i] can be used in certain contexts with unevaluation quotes to denote a generic index into B. If unevaluation quotes are not used, Maple will try to look up the specific ith element of B.
${B}{\u2254}\left[\right]$
 (27) 


Pass by Reference


Some commands accept a name as an argument, with the intent that it will be used to store a result. Unevaluation quotes ensure that the variable name (and not the value assigned to the variable) is used in the procedure.
>

remainder := irem(45,3,'quotient'); quotient;

${\mathrm{remainder}}{\u2254}{0}$
 
>

remainder := irem(44,3,'quotient'); quotient;

${\mathrm{remainder}}{\u2254}{2}$
 
If quotient is not enclosed in unevaluation quotes, the second call in the above example raises an exception because 15, the value of quotient, is not a valid third argument to the irem command.


Displaying the Original Command


For display purposes, it is sometimes useful to show the original command before a solution is computed.
>

v := 'int(x*y^2, [x=0..1, y=0..1] )';

${v}{\u2254}{{\int}}_{{0}}^{{1}}{{\int}}_{{0}}^{{1}}{x}{}{{y}}^{{2}}\phantom{\rule[0.0ex]{0.3em}{0.0ex}}{\ⅆ}{x}\phantom{\rule[0.0ex]{0.3em}{0.0ex}}{\ⅆ}{y}$
 (31) 


Unassigning Names


To reset the value of a name, assign the unevaluated name (its initial value) to the name. For example,
Now, the value of x is reset to x.


Evaluation and Automatic Simplification


It is important to note the differences between computations that occur during the evaluation process and those that occur during the automatic simplification process. Unevaluation quotes do not prevent automatic simplifications from occurring. For example, basic numeric arithmetic is one form of automatic simplification. In the following expression, the unevaluation quotes do not prevent the numeric addition from occurring.
In this example, Maple first simplifies the unevaluated sum '2 + 3' to the expression '5'. During the evaluation process, Maple "removes" the right single quotes and produces the numeric result 5.
All unevaluated expressions are of the type uneval. You can use the type command to check whether an expression is an unevaluated expression.
>

type( ''x'', 'uneval' );

In the example above, the first argument to the call to the type command is the name x, which is enclosed in two sets of unevaluation quotes. The result of evaluating the first argument is the unevaluated expression 'x' because the evaluation process removes one set of unevaluation quotes. The resulting expression is therefore of type uneval.
On the other hand, if you enclose the first argument to type in only one set of unevaluation quotes, the evaluation process removes the only set of unevaluation quotes, leaving the result as the name x, which is not an unevaluated expression.
In other words, the type command accesses the name x, rather than the unevaluated expression 'x', since the type command accesses the result of its arguments that have been evaluated.
In the example above quotes were also used around the type name uneval. This provides a measure of protection just in case the variable name, uneval has an assigned value (which is unlikely because uneval is protected). During normal function evaluation, each argument, x and uneval is evaluated. With quotes, 'x' becomes x, and 'uneval' becomes uneval as seen by the type procedure. Without quotes, x would become the value of x (which may be the symbol x itself), and uneval would become the value of uneval, which is usually the symbol uneval itself. Unevaluation quotes make the displayed call robust against cases where the variable you are using unexpectedly has a value. It is rarely necessary to use this level of caution in interactive use, but when you write programs, it is a good practice to include unevaluation quotes to make your code as robust as possible.
Another special case of unevaluation arises in function calls.
Suppose f is not assigned to anything. Since evaluating f does not call a procedure, Maple returns the unevaluated function call f(a).
${f}{}\left({{x}}^{{2}}{+}{x}{+}{1}\right)$
 (38) 
Similarly, using uneval quotes around a function evaluation will cause Maple to behave as if the named function had no value.
$'{\mathrm{sin}}'{}\left({\mathrm{\pi}}\right)$
 (39) 
${\mathrm{sin}}{}\left({\mathrm{\pi}}\right)$
 (40) 
You will find this facility useful when writing procedures that need to act on the whole original expression, not the evaluated result.
For more examples and information on unevaluated expressions, refer to the uneval help page.


Example: Defining a Procedure That Is Returned Unevaluated


You may need to use unevaluation quotes when you are defining a procedure that is returned unevaluated. This is necessary, for example, when you are defining a procedure that evaluates a numeric result for numeric inputs, but does not produce a numeric result otherwise. (The procedure may perform normalizations and apply symmetries, if appropriate.) It is important to write procedures using this method so that they can be plotted, optimized, or numerically integrated, for example.
Consider the following procedure.
>

f := proc( x )
if x > 2 then
x
else
2
end if
end proc:

Using the wrong calling sequence in a call to plot results in an error.
>

plot( f( x ), x = 10 .. 10 );

The correct calling sequence would be either plot( 'f'(x), x=10..10), which puts uneval quotes around f, or plot( f, 10..10), which avoids computing f(x) by omitting the variable altogether. Remember that arguments in a function call are evaluated first before the called procedure sees them.
Here, the precursor evaluation of f(x) tries to apply f to the unassigned symbol, x.
The procedure could be rewritten so that it returns unevaluated whenever it encounters arguments that cannot be processed. This trick causes f(x) to evaluate to itself when nonnumeric input is passed in.
>

f := proc( x )
if type( x, 'numeric' ) then
if x > 0 then
x
else
2
end if
else
'procname( _passed )'
end if
end proc:

The unevaluated expression 'procname( _passed )' returns the full calling sequence unevaluated.
${f}{}\left({x}\right)$
 (42) 
The expression procname( _passed ) must be enclosed in unevaluation quotes to prevent an infinite loop.



3.5 Numbers


Maple supports computation with exact numerical quantities, as well as approximate computation to arbitrarily high accuracy with floatingpoint numbers.

Integers


A natural integer is any sequence of one or more decimal digits.
The maximum number of digits is systemdependent. To determine the maximum number of digits, use the following command.
>

kernelopts( 'maxdigits' );

A signed integer is formed by appending + or  before any natural integer.
An integer is either a natural integer or a signed integer.
You can use the length command to determine the number of digits in an integer.


Fractions


A rational number (fraction) is the quotient of two integers, where the denominator is always positive.
Use the division operator (forward slash) / to enter a fraction.
For example,
You can enter a fraction in which the numerator and denominator have a common (integer) factor, but Maple automatically simplifies this to the lowest terms.
In addition, Maple automatically moves a negative sign to the numerator.
${}\frac{{2}}{{3}}$
 (51) 
Fractions are automatically simplified to an integer if the denominator is a divisor of the numerator.
You can use the numer and denom commands to extract the numerator and denominator, respectively, of a fraction.
Fractions can also be created by using the Fraction constructor with the numerator and denominator as arguments.


Floats


Maple supports computation with floatingpoint numbers to arbitrary precision.
A float can be input using a period for the decimal.
Or, using exponent form using a suffix containing the letter "e" or "E" followed by an integer with no spaces between.
${2.3}{\times}{{10}}^{{6}}$
 (61) 
Observe that spaces are significant. The first example is a difference rather than a float in exponent form.
Also, the following is invalid.
Floats represent numbers of the form s*10^e, where the number s is called the significand or mantissa of the float, and the number e is called the exponent. The significand is a Maple integer. Therefore, it is restricted to values that have, at most, the number of digits indicated by the kernelopts( 'maxdigits') command.
>

kernelopts( 'maxdigits' );

The maximum value of the exponent is a platformdependent quantity whose value may be queried by using the Maple_floats command.
>

Maple_floats( 'MAX_EXP' );

${9223372036854775806}$
 (67) 
Similarly, the minimum value of the exponent is given by the value
>

Maple_floats( 'MIN_EXP' );

${\mathrm{9223372036854775806}}$
 (68) 
returned by the Maple_floats command. For more information, refer to the Maple_floats help page.
You can also create software floats by using the constructor SFloat. This constructor accepts the significand and exponent as arguments, and has the general form
To extract the significand and exponent of a software float, use the SFloatMantissa and SFloatExponent commands.
The significand and exponent are also the operands of a software float.
${23}{,}{\mathrm{1}}$
 (72) 
Two software floats are equal if they represent the same number. However, equal floats by themselves do not need to be the same object in memory.
>

addressof( 2.3 ); addressof( 2.30 );

${36893628422603906236}$
 (74) 
Observe that the significands (and therefore, also, the exponents) differ in this example.
>

SFloatMantissa( 2.30 );

Note that equal floats with different significands inside of two otherwise identical objects will require something stronger than evalb for comparison. evalb is the implicit comparison used when evaluating conditionals in if statements.
>

evalb( 2.3 + x = 2.30 + x );

>

evalb(<2.3,4.5> = <2.30,4.50>);

Testing the difference of the two expressions, or calling a command to do a deeper comparison may be necessary.
>

evalb( (2.3 + x)  (2.30 + x) = 0 );

>

EqualEntries(<2.3,4.5>, <2.30,4.50>);

The names of the constructor SFloat and accessors SFloatMantissa and SFloatExponent all begin with the letter S. The S stands for "software" because these floatingpoint numbers are implemented in software. Maple also supports the floatingpoint numbers supported by the underlying hardware, called hardware floats or hfloats. You can create a hardware float by using the hardware float constructor HFloat.
${24.3750000000000}$
 (81) 
${h}{\u2254}{24.3750000000000}$
 (82) 
${243750000000000000}{,}{\mathrm{16}}$
 (83) 
Note, however, that hfloats are binary floatingpoint numbers, rather than decimal floatingpoint numbers. That means that unlike the example above, there is often roundoff error when decimal numbers are converted into hfloats. For more information, see Hardware FloatingPoint Numbers.
${229999999999999982}{,}{\mathrm{17}}$
 (84) 
The SFloatMantissa and SFloatExponent commands also accept hardware floats as input.
${243750000000000000}$
 (85) 
For more information on floatingpoint numbers, see FloatingPoint Numbers.


Complex Numbers


Maple supports arithmetic with complex numbers of the form $a\+\mathrm{bi}$, where $i\=\sqrt{1}$ is the imaginary unit. In Maple, the imaginary unit is normally denoted by I; that is, the uppercase letter "I" is used rather than the lowercase "i". Therefore, the complex number with the real part equal to $2$ and imaginary part equal to $3$ is entered, naturally, as follows.
${2}{+}{3}{}{\mathrm{I}}$
 (87) 
In general, a complex number has the form
where re and im are the real and imaginary parts of the complex number, respectively. If the expressions re and im are of type extended_numeric; the resulting complex number will be of type complex( extended_numeric ). (It is not necessary that re and im are reals; they may be arbitrary algebraic expressions. However, in this case, the result of the syntax above will generally be an algebraic expression that will not be a complex numeric constant.)
You can also create complex numbers using the Complex constructor. It can be called using either one or two arguments. The singleargument form has the following syntax.
If the argument expr is of type complex, the Complex constructor returns the value of expr. Otherwise, if expr is of type extended_numeric, the Complex constructor returns expr * I.
>

Complex( 2 ), Complex( 0 ), Complex( 0.0 );

${2}{}{\mathrm{I}}{,}{0}{,}{0.}{}{\mathrm{I}}$
 (88) 
>

Complex( 2 + 3*I ), Complex( infinity ), Complex( undefined );

${2}{+}{3}{}{\mathrm{I}}{,}{\mathrm{\infty}}{}{\mathrm{I}}{,}{\mathrm{undefined}}{}{\mathrm{I}}$
 (89) 
The twoargument form has the following syntax.
The first argument is interpreted as the real part and the second argument is interpreted as the imaginary part, of the complex number constructed.
>

Complex( 2, 3 ), Complex( 2.1, 3 ), Complex( 0, 0 );

${2}{+}{3}{}{\mathrm{I}}{,}{2.1}{+}{3.}{}{\mathrm{I}}{,}{0}$
 (90) 
Note that if either of the arguments is a float, the real and imaginary parts of the complex number created are both of type float.
A complex zero with floatingpoint real and imaginary components can have four sign combinations.
>

z1 := 0.0 + 0.0*I; z2 := 0.0  0.0*I;
z3 := 0.0  0.0*I; z4 := 0.0 + 0.0*I;

${\mathrm{z1}}{\u2254}{0.}{+}{0.}{}{\mathrm{I}}$
 
${\mathrm{z2}}{\u2254}{0.}{}{0.}{}{\mathrm{I}}$
 
${\mathrm{z3}}{\u2254}{\mathrm{0.}}{}{0.}{}{\mathrm{I}}$
 
${\mathrm{z4}}{\u2254}{\mathrm{0.}}{+}{0.}{}{\mathrm{I}}$
 (91) 
Similar to 0.0 = 0.0, numerically, these four complex zeros are numerically equivalent.
>

evalb( z1 = z2 and z2 = z3 and z3 = z4 );

If the arguments re and im are not of type extended_numeric, the Complex constructor is returned unevaluated.
${\mathrm{Complex}}{}\left({u}{\,}{v}\right)$
 (93) 
Except if one of the arguments is complex, in which case, an exception is raised.
It is important to understand that there is a single complex infinity, which is a point on the Riemann sphere. It can be denoted in different ways:
>

inf1 := infinity + infinity * I; inf2 := infinity  infinity * I;
inf3 := infinity  infinity * I; inf4 := infinity + infinity * I;

${\mathrm{inf1}}{\u2254}{\mathrm{\infty}}{+}{\mathrm{\infty}}{}{\mathrm{I}}$
 
${\mathrm{inf2}}{\u2254}{\mathrm{\infty}}{}{\mathrm{\infty}}{}{\mathrm{I}}$
 
${\mathrm{inf3}}{\u2254}{}{\mathrm{\infty}}{}{\mathrm{\infty}}{}{\mathrm{I}}$
 
${\mathrm{inf4}}{\u2254}{}{\mathrm{\infty}}{+}{\mathrm{\infty}}{}{\mathrm{I}}$
 (94) 
However, all of these forms are numerically equivalent.
>

evalb( inf1 = inf2 and inf2 = inf3 and inf3 = inf4 );

They are all treated as distinct from the positive and negative real infinities.
To select the real or imaginary part of a complex number, use the Re and Im commands, respectively.
Note that, for a symbolic expression of the form a + b*I, it is not assumed that a is the real part and b is the imaginary part. Therefore, the Re and Im commands are not unevaluated on such input.
${\mathrm{\Re}}{}\left({a}\right){}{\mathrm{\Im}}{}\left({b}\right)$
 (98) 
${\mathrm{\Im}}{}\left({a}\right){+}{\mathrm{\Re}}{}\left({b}\right)$
 (99) 
However, the evalc command uses special rules for processing complex expressions, in which any unknown symbol is assumed to be real. Therefore, when the evalc is used, these expressions are returned as follows.
>

evalc( Re( a + b*I ) );

>

evalc( Im( a + b*I ) );

For more information, refer to the evalc help page.
You can change the default name used to input and display the imaginary unit by using the interface command.
>

interface( 'imaginaryunit' = i );

(The previous value is returned.) After calling the command above, the name i is used to represent the imaginary unit.
${2}{+}{3}{}{\mathrm{i}}$
 (103) 
When this command is used, the name i can no longer be used as a program variable. As an example, the following statements display error messages.
>

add( i^2, i = 1 .. 5 );

To restore the default imaginary unit, use the following command.
>

interface( 'imaginaryunit' = I );




3.6 Indexed Expressions


Indexed expressions represent selection operations. The general form of an indexed expression is
where expr is an arbitrary expression and index represents a sequence of expressions. The following are examples of indexed expressions.
${{2}}_{{3}{,}{4}}$
 (105) 
${{a}}_{{b}{,}{c}}$
 (109) 
${{\mathrm{map}}}_{{2}}$
 (110) 
>

[ 1, 2, 3 ][ 2 ..3 ][ 1 ];

Note that the last example above contains a nested (or iterated) indexed expression.
The constructor for indexed expressions is the name ?[].
>

`?[]`( S, [ a, b, c ] );

${{S}}_{{a}{,}{b}{,}{c}}$
 (112) 
Note that the indices must be enclosed with square brackets in a list.
All or some of the elements of an index sequence can be extracted by using the op command. The nops command will tell you how many elements are in the index sequence.
>

op( 2..3, a[ b, c, d ] );

Indexed expressions are often used to perform selection operations. The behavior of a selection operation depends on the type of expression, expr, and the index sequence given.
If expr is itself a sequence of expressions, the index sequence must evaluate to a positive integer, an integral range, or the empty sequence. The following are all examples of valid ways to index a sequence.
${\mathrm{expr}}{\u2254}{1}{,}{2}{,}{3}{,}{4}$
 (117) 
${1}{,}{2}{,}{3}{,}{4}$
 (120) 
The result of evaluating an indexed sequence is a selection of the components of the sequence. The indexing sequence must represent a valid index or range of indices. Attempting to select an entry beyond the length of the sequence and will raise an error.
Similarly, components of lists, sets, arrays, matrices, and vectors can be selected
${L}{\u2254}\left[{1}{\,}{2}{\,}{3}{\,}{4}\right]$
 (121) 
$\left[{1}{\,}{2}{\,}{3}\right]$
 (123) 
${1}{,}{2}{,}{3}{,}{4}$
 (124) 
${M}{\u2254}\left[\right]$
 (125) 
>

S := { red, blue, green, orange };

${S}{\u2254}\left\{{\mathrm{blue}}{\,}{\mathrm{green}}{\,}{\mathrm{orange}}{\,}{\mathrm{red}}\right\}$
 (128) 
${\mathrm{orange}}$
 (129) 
Note that, because sets are sorted data structures, the order at construction time may not match the order stored internally. It is not predictable what color will be returned by the index used to specify the third entry above. (It may not be green.)
A negative number may be used as an index, which selects elements starting from the end of the list. Positive and negative indices mixed in a range return an empty selection.
$\left[{2}{\,}{3}\right]$
 (131) 
Lists can be used as an index to pick out specific entries, such as the first and third entries of a list, or the four corners of a matrix.
$\left[{1}{\,}{3}\right]$
 (133) 
Indexing on arrays, matrices and vectors is very flexible. In the case of these data structures, roundbrackets can also be used to index in a way that is useful to programming. For example, where M[1] will return the first row of the matrix, M(1) will return the first entry (regardless of the number of dimensions).
This class of data structures are known as rectangular tables, or "rtables" for short. For more information on what ways they can be indexed, refer to the rtable_indexing help page.
If expr is a name with no assigned value, the result of evaluating the indexed expression is an indexed name. In this case, the index can be any sequence of expressions, and if desired, it is up to your program to define the meaning of the expression.
>

aName[ x^2  3*x, "a string", anotherName[ 2, b ] ];

${{\mathrm{aName}}}_{{{x}}^{{2}}{}{3}{}{x}{,}{''a\; string''}{,}{{\mathrm{anotherName}}}_{{2}{,}{b}}}$
 (137) 
A string may be indexed by a positive integer, a positive integral range, or a general sequence. The indexed string expression evaluates to itself, unless the indexing sequence is an integer or integral range, in which case, the result is a substring of the indexed string.
>

"abcde"[ u, v^2  s*t ];

${{''abcde''}}_{{u}{,}{}{s}{}{t}{+}{{v}}^{{2}}}$
 (140) 
${''abcde''}\left[\right]$
 (141) 
If expr evaluates to a table, and if the index given is found in the table the expression evaluates to the corresponding entry. Otherwise, the indexed expression evaluates to itself.
>

t := table( [ a = 1, b = 2, (c,d) = 3 ] );

${t}{\u2254}{table}{}\left(\left[\left({c}{\,}{d}\right){=}{3}{\,}{a}{=}{1}{\,}{b}{=}{2}\right]\right)$
 (142) 
${{t}}_{{u}{,}{v}}$
 (145) 
If expr evaluates to a module, the index must evaluate to the name of an export of the module, and then the entire indexed expression evaluates to the value of expr:index.
>

m := module() export e, f := 2; end module:

For more information about modules, see Programming with Modules.


3.7 Member Selection


The member selection operator : is used to select exports of a module, and also to designate a symbol as a global symbol. Member selection expressions have one of the following general forms.
modexpr : expname

: name



The first form above is used to select a member of a module.
>

m := module() export e, f:= 2; end module:

The first operand, modexpr, must evaluate to a module. The second operand, expname, must be a literal name; it is not evaluated. If expname is not a name, or is not the name of an export of the module modexpr, an exception is raised. The syntax m:e is similar to m[e], in that they both evaluate module m's export e. The difference is that the index selection form will evaluate e before resolving the export.
In the second form, the operand name must be a literal name. The expression :name then evaluates to the global instance of the name name.
The following example defines, and then immediately calls, a procedure which declares a local variable t. Since this local variable is never assigned, it evaluates to itself. The call to the evalb command then compares, on the lefthand side of the equation, the local name t to the global name t resulting from applying the member selection operator to t. The result is false because the global name t and the name t local to the procedure are different expressions.
>

proc() local t; evalb( t = :t ) end proc();

For more information on modules and member selection, see Programming with Modules.


3.8 Functions


A function expression is a Maple expression of the form
that contains zero or more expressions in the sequence within the parentheses. It represents a function call.
${F}{}\left(\right)$
 (153) 
${F}{}\left({x}\right)$
 (154) 
${F}{}\left({x}{\,}{y}\right)$
 (155) 
${\mathrm{sin}}{}\left({x}{+}{y}\right)$
 (156) 
Typically, expr is the name of a procedure or mathematical function. It can be a general expression.
The zeroth operand of a function expression is expr.
The other operands are the arguments,
and the number of operands is the number of arguments.
Maple supports an algebra of operators, so that complicated expressions such as
${{f}{}\left({x}\right)}^{{2}}{+}{g}{}\left({h}{}\left({x}\right)\right){}{2}$
 (161) 
can be formed. Note that Maple applies such "operator expressions" to the arguments. @ is the composition operator. For more information on composition of functions, see Composition.
It is important to know that Maple computes numeric quantities as applicable operators with constant values. Therefore, for example, the expression
is computed as an application of the constant operator 2 to the argument x, which evaluates to 2. In fact, numeric "operators" can accept any number of arguments.
Note that an expression such as
${2}{}\left({3}\right)$
 (164) 
(in which unevaluation quotes are used to delay the evaluation process) appears to be a product. However, this expression is, in fact, a function expression. When permitted to evaluate fully, the result is the constant value of the operator.

Calls to Procedures


The most important kind of function expression to understand is the case in which the zeroth operands is a procedure or, more commonly, an expression (typically, as a name) that evaluates to a procedure.
p( arg1, arg2, ..., argN )



In this case, p is a procedure or an expression, such as a name, that evaluates to a procedure, and arg1, arg2, ..., argN are zero or more argument expressions.
For example, the name sin evaluates to a procedure that computes the mathematical sin function. A function expression of the form
computes the sin of its argument expr. This is performed as follows: Maple evaluates the name sin and finds that it is assigned a procedure. The argument expr is evaluated to produce a result. That result is then passed to the procedure assigned to the name sin and the result computed by that procedure for the specific input is returned as the overall value of the function call sin( expr ).
For information on defining functions and procedures, see Functional Operators and Procedures.



3.9 Arithmetic Expressions



Arithmetic Operators


The arithmetic operators in Maple include + (addition),  (subtraction), * (multiplication), / (division), and ^ (exponentiation). These operators are used to create rational expressions, such as polynomials.
${{x}}^{{2}}{}{3}{}{x}{+}{1}$
 (166) 

Addition and Subtraction


The addition operator `+` and the subtraction operator `` are typically used as binary infix operators, but may also be used as unary prefix operators to indicate a signed expression.
A sum resulting from the evaluation of either an addition or subtraction operation is an expression of type `+`.
The expression uv has the operands u and v; that is, it is a sum of the summands u and v.
Note that subtraction is not an associative operator.
>

( 1  2 )  3 <> 1  ( 2  3 );

${\mathrm{4}}{\ne}{2}$
 (173) 
However, addition is both associative and commutative:
${b}{+}{a}{+}{c}{=}{b}{+}{a}{+}{c}$
 (174) 
Although sums are formed by using the binary operator `+`, they are actually expressions of arbitrarily large arity (greater than unity). Since addition is associative, Maple "flattens" all sums of more than two summands during the automatic simplification process. Therefore, an expression of type `+` can have many operands.
>

nops( a + b + c + d + e );

You can use the name `+` as a constructor to form a sum.
Since Maple performs automatic simplification, the number of operands of a sum may not be apparent from the input.
>

nops( a + 2 + b + 3 + c + 4 );

In this example, Maple combines the integer terms in the sum.
${a}{+}{9}{+}{b}{+}{c}$
 (178) 
To see that this occurs during the automatic simplification process, enclose the input in unevaluation quotes to delay evaluation.
>

'a + 2 + b + 3 + c + 4';

${a}{+}{9}{+}{b}{+}{c}$
 (179) 
In a sum such as
the addition is performed, as indicated, during the automatic simplification process. The same sum can be computed in another way:
In this example, the arithmetic is not performed because the value of the variable u does not replace the name u during the automatic simplification process. If the unevaluation quotes are removed to allow the full evaluation of the expression, numeric addition is performed.
Since addition is commutative, the order of summands in an expression of type `+` is arbitrary. It is fixed within a Maple session, but may vary from one session to another. Therefore, you must not rely on the operands of a sum occurring in any specific order.
Operands of a sum are automatically simplified, recursively.
>

'2/3 + sin( 5*Pi/6  2*Pi/3 )';

$\frac{{2}}{{3}}{+}{\mathrm{sin}}{}\left(\frac{{\mathrm{\pi}}}{{6}}\right)$
 (183) 
Since procedures are not called during the automatic simplification process, the example above does not fully simplify to the result
>

2/3 + sin( 5*Pi/6  2*Pi/3 );

during the automatic simplification process. However, the argument to the sin command is computed to the simpler form $\frac{1}{6}\mathrm{\pi}$, just as it would if it had been entered by itself.
$\frac{{\mathrm{\pi}}}{{6}}$
 (185) 
If any numeric literal in a sum is a float, all the numeric operands are converted to floats and their sum is computed as a float. For more information, see FloatingPoint Contagion.
>

'a + 2 + b + 3.7 + c + Pi';

${a}{+}{8.841592654}{+}{b}{+}{c}$
 (186) 
Arithmetic computed during the automatic simplification process includes arithmetic with values of infinity, undefined values, and signed (floatingpoint) zeroes.
${Float}{}\left({\mathrm{undefined}}\right)$
 (187) 
${Float}{}\left({\mathrm{\infty}}\right)$
 (188) 
${\mathrm{undefined}}$
 (190) 
>

'infinity  Float(infinity)';

${Float}{}\left({\mathrm{undefined}}\right)$
 (191) 
Sums of nonalgebraic summands can be formed. A sum of lists of the same length returns the corresponding list of sums. This occurs during the automatic simplification process.
>

'[ a, b, c ] + [ x, y, z ]';

$\left[{x}{+}{a}{\,}{y}{+}{b}{\,}{z}{+}{c}\right]$
 (192) 
Sums of arrays, matrices, and vectors occur during the regular evaluation process.
Attempting to add lists or matrices of different sizes results in an error.
>

[ 1, 2 ] + [ 1, 2, 3 ];

Since the addition of sets (which are not ordered) is not welldefined, a sum formed with a set is returned unevaluated.
>

{ 1, 2 } + { 3, 4 };
{ 1, 2 } + [ 3, 4 ];

$\left\{{1}{\,}{2}\right\}{+}\left\{{3}{\,}{4}\right\}$
 
$\left\{{1}{\,}{2}\right\}{+}\left[{3}{\,}{4}\right]$
 (194) 


Multiplication and Division


Products are formed by using the `*` and `/` operators. The result of evaluating either a multiplication or division operation is an expression of type `*`.
>

type( a * b, '`*`' );
type( a / b, '`*`' );

You can use the dismantle command to print a representation of the internal structure of any Maple expression.
PROD(5)
NAME(4): a
INTPOS(2): 1
NAME(4): b
INTNEG(2): 1
 
The output shows that the quotient is actually stored as a product of two factors: one consisting of the expression a with a power of $1$ and the other consisting of the expression b with a power of $1$: ${a}^{\left(1\right)}{b}^{\left(1\right)}$.
Similar to sums, products are commutative and associative. Also, products are flattened due to associativity, even though the `*` operator is binary. Automatic simplification is applied to products, so as with sums, numeric factors are automatically combined.
Also like sums, the order of factors in an expression of type `*` is arbitrary, and may vary between Maple sessions.
The number of operands reflects the number of factors remaining after automatic simplification has taken place.
The name `*` can be used as a constructor to form products.
If any numeric constant in a product is a float, the result of gathering all of the constants into a single factor is a float.
$\frac{{6.200000000}{}{a}}{{b}}$
 (201) 
>

'2.3 * ( 5*Pi/6  2*Pi/3 )';

This effect does not extend into function calls.
>

'2.3 * sin( 5*Pi/6  2*Pi/3 )';

${2.3}{}{\mathrm{sin}}{}\left(\frac{{\mathrm{\pi}}}{{6}}\right)$
 (203) 
You can multiply a list by a number and the product is applied to all of the list elements during the automatic simplification process.
$\left[{4}{\,}{6}\right]$
 (204) 
Matrix multiplication is done with the `.` operator rather than `*`. Division is not defined for matrices.
>

<1,2;3,4> . LinearAlgebra:MatrixInverse( <5,6;7,8>);

Multiplying or dividing two arrays of the same size will perform paired elementwise operations on the individual entries. The elementwise operators *~ and /~ can be used on both arrays and matrices to achieve the same result.
>

Array([[1,2],[3,4]]) * Array([[5,6],[7,8]]);

>

Array([[1,2],[3,4]]) / Array([[5,6],[7,8]]);

>

<1,2;3,4> /~ <5,6;7,8>;

>

<1,2;3,4> *~ <5,6;7,8>;

For more information on elementwise operators, see ProgrammingLanguage Operators.


Exponentiation


Powers are formed by using the `^` operator.
It is strictly a binary operator; nested powers must be written with parentheses.
${\left({{a}}^{{b}}\right)}^{{c}}$
 (212) 
${{a}}^{{{b}}^{{c}}}$
 (213) 
The following input results in a syntax error.
Rational number powers are used to represent roots. Exact roots are left uncomputed, while floatingpoint roots are computed during the automatic simplification process.
Expressions to a power of 0 are reduced to unity during the automatic simplification process. The type of the resulting 1 depends on the type of the zero power, unless the base of the expression is a float, in which case the result is a float.
There are some exceptions when infinity and undefined values are raised to a float zero power.
>

'Float( undefined ) ^ 0.0';

${Float}{}\left({\mathrm{undefined}}\right)$
 (219) 
>

'Float( infinity ) ^ 0.0';

${Float}{}\left({\mathrm{undefined}}\right)$
 (220) 
>

'Float( infinity ) ^ (0.0)';

${Float}{}\left({\mathrm{undefined}}\right)$
 (221) 
Note the distinction between Float( infinity ) ^ (0.0) and Float( infinity ) ^ (0.0): the latter is first automatically simplified to  Float(undefined) and then to Float(undefined).
In Maple, the indeterminate form 0^0 with an exact base is interpreted as $1$.
${Float}{}\left({\mathrm{undefined}}\right)$
 (224) 
Although a complex floatingpoint zero does not automatically simplify to a real zero, expressions raised to a complex zero are simplified automatically to an exact or floatingpoint unity.
Powering of matrices is done in the mathematical sense achieving repeated matrix products. Powering of arrays is done elementwise.
>

Array([[1,2],[3,4]]) ^3;



Rational Expressions


Using sums and products, more complicated expressions can be formed.
>

expr := ( a + a*b ) / ( a*b  b );

${\mathrm{expr}}{\u2254}\frac{{a}{}{b}{+}{a}}{{a}{}{b}{}{b}}$
 (228) 
Conceptually, Maple creates the following structure.

Figure 3.1: expr DAG



Here, expr is a product of two operands
${a}{}{b}{+}{a}{,}\frac{{1}}{{a}{}{b}{}{b}}$
 (230) 
and each operand is itself an expression with two operands.
${\mathrm{e1}}{,}{\mathrm{e2}}{\u2254}{a}{}{b}{+}{a}{,}\frac{{1}}{{a}{}{b}{}{b}}$
 (231) 
>

nops( e1 ); nops( e2 );

Maple does not automatically simplify the following expression. To perform such simplifications, use the normal command.
>

expr := (x  1)/(x^2  1);

${\mathrm{expr}}{\u2254}\frac{{x}{}{1}}{{{x}}^{{2}}{}{1}}$
 (233) 
$\frac{{1}}{{x}{+}{1}}$
 (234) 
The normal command only performs normalization of rational expressions with rational coefficients.
>

expr := ( (sin(t)^2 + cos(t)^2)*(x  1)/(x^2  1));

${\mathrm{expr}}{\u2254}\frac{\left({{\mathrm{sin}}{}\left({t}\right)}^{{2}}{+}{{\mathrm{cos}}{}\left({t}\right)}^{{2}}\right){}\left({x}{}{1}\right)}{{{x}}^{{2}}{}{1}}$
 (235) 
$\frac{{{\mathrm{sin}}{}\left({t}\right)}^{{2}}{+}{{\mathrm{cos}}{}\left({t}\right)}^{{2}}}{{x}{+}{1}}$
 (236) 
Note: Use the simplify command to apply more powerful simplifications.
Maple also does not automatically expand the products of sums.
$\left({a}{+}{b}\right){}\left({c}{+}{d}\right)$
 (237) 
Use the expand command (or the normal command, with the expanded option) to perform such expansions.
>

expr := (a + b) * (c + d);

${\mathrm{expr}}{\u2254}\left({a}{+}{b}\right){}\left({c}{+}{d}\right)$
 (238) 
${a}{}{c}{+}{a}{}{d}{+}{b}{}{c}{+}{b}{}{d}$
 (239) 
>

normal( expr, 'expanded' );

${a}{}{c}{+}{a}{}{d}{+}{b}{}{c}{+}{b}{}{d}$
 (240) 
Similarly, you must use the normal command to simplify the following rational expression.
>

expr2 := expand( expr ) / (a + b);

${\mathrm{expr2}}{\u2254}\frac{{a}{}{c}{+}{a}{}{d}{+}{b}{}{c}{+}{b}{}{d}}{{a}{+}{b}}$
 (241) 



Noncommutative Multiplication


Noncommutative multiplication is represented by the dot operator (.), which is used mainly in linear algebra computations for multiplication of matrices and vectors. It may also be used to represent the noncommutative product of other types of mathematical expressions.
If A and B are of type constant, then A . B = A * B during the evaluation process (but not during the automatic simplification process). However, if one of A and B is a Matrix or a Vector, and the other is a Matrix, Vector, or constant, the product is interpreted as a matrix or vector product. If A or B is an Array (and the other is not a Matrix or Vector), then A . B is interpreted as elementwise multiplication. For arguments that are not of type Matrix, Vector, or constant, A . B remains unevaluated, but more importantly, it is not automatically simplified to or interpreted as being equal to B . A.
${A}{\xb7}{B}{\ne}{B}{\xb7}{A}$
 (245) 
>

M:=<<1,0,2><0,1,2><0,0,2>>;

${M}{\u2254}\left[\right]$
 (246) 
${V}{\u2254}\left[\right]$
 (247) 
${\mathrm{\lambda}}{\xb7}\left[\right]$
 (249) 
>

A := Array([[1,2],[3,4]]);

${A}{\u2254}\left[\right]$
 (250) 
>

B := Array([[a,b,c],[d,e,f]]);

${B}{\u2254}\left[\right]$
 (251) 
The dot character has three meanings in Maple:
–

as a decimal point in a floatingpoint number (for example, 2.3),

–

as part of a range (for example, x..y), or

–

as the noncommutative multiplication operator. To distinguish between these three cases, Maple uses the following rule: any dot with spaces before and/or after it that is not part of a number is interpreted as the noncommutative multiplication operator.

For example, 2.3 is a number, 2 . 3 and 2 .3 return 6, and 2. 3 displays an error.
${2.3}{,}{6}{,}{6}$
 (254) 


Factorials


The unary, postfix factorial operator ! is used to represent the mathematical factorial operation.
Maple can compute large factorials quickly.
If the argument of the ! operator is symbolic, it is returned unevaluated.
$\left({a}{+}{b}\right){!}$
 (258) 
The argument of the ! operator is subject to automatic simplification, but factorials are not computed during the automatic simplification process.
If the argument of the ! operator is a float, the expression is computed using the GAMMA function.
${2.683437382}{=}{2.683437382}$
 (260) 
If the argument is a nonnegative integer, Maple computes the factorial. If the argument is a negative integer, a numeric event is triggered.
However, if the argument is a negative integer float, the complex number Float(infinity)  Float(infinity)*I is returned.
${Float}{}\left({}{\mathrm{\infty}}\right){}{Float}{}\left({\mathrm{\infty}}\right){}{\mathrm{I}}$
 (261) 
For other arguments, the factorial operator is returned unevaluated after first evaluating its argument.
$\left(\frac{{1}}{{2}}\right){!}$
 (262) 
The command factorial is the same as the ! operator.


Forming Sums and Products


Since creating structures within loops may be inefficient, Maple provides commands for creating sums and products efficiently.
add( expression, i=m .. n);

mul( expression, i=m .. n);



where i is a name, m and n are numeric values, and expression is an expression that depends on i.
The add command is semantically equivalent to the following loop:
>

S := 0;
old := i;
for i from m to n do
S := S+expression;
end do;
i := old;
S; # the result

The add command is more efficient since it does not build each of the many intermediate sums. The semantics of mul are similar with the exception that if $n<m$, the result is 1, rather than 0.
$\left({a}{+}{1}\right){}\left({a}{+}{2}\right){}\left({a}{+}{3}\right){}\left({a}{+}{4}\right)$
 (264) 
${\mathrm{a0}}{+}{\mathrm{a1}}{+}{\mathrm{a2}}{+}{\mathrm{a3}}$
 (265) 
In the loop example shown above, each of the expressions $\mathrm{a0}$, $\mathrm{a0}\+\mathrm{a1}$, and $\mathrm{a0}\+\mathrm{a1}\+\mathrm{a2}$ are constructed, stored in memory, and then removed by the garbage collector. That overhead is part of what makes the loop less efficient than the add command in this case.
For more information on the add and mul commands, refer to the add help page. For more information on the concatenation operator, , see The Concatenation Operator.
Note: The add and mul commands differ from sum and product in that the former are straightforward construction commands while the latter are commands for computing closed forms for symbolic sums and products.



3.10 Boolean and Relational Expressions



Boolean Constants


The Boolean constants in Maple are the names true, false and FAIL. These are otherwise ordinary names, but have a special meaning in a Boolean context.
When you call the Boolean evaluator evalb, the expression passed as its argument is interpreted as a Booleanvalued expression if possible, and evaluated as such.
FAIL is used to mean an unknown or undetermined value. For more information on the constant FAIL, refer to the FAIL help page.


Boolean Operators


Maple supports several operators for the Boolean combination of expressions: not, and, or, xor, and implies.

The not Operator


The not operator represents logical negation. It has the following general syntax.
When applied to a Booleanvalued expression, it returns a value according to the following table.
expr

not expr

true

false

false

true

FAIL

FAIL



For example,


The and Operator


The and operator represents logical conjunction. It is a binary operator of the form
If both operands evaluate to a truth value, the entire expression is evaluated according to the following truth table.
expr1

expr2

expr1 and expr2

true

true

true

true

false

false

true

FAIL

FAIL

false

true

false

false

false

false

false

FAIL

false

FAIL

true

FAIL

FAIL

false

false

FAIL

FAIL

FAIL



If a truth value cannot be determined, the expression is returned unevaluated.
${x}\phantom{\rule[0.0ex]{0.3em}{0.0ex}}{\textstyle {\mathbf{and}}}\phantom{\rule[0.0ex]{0.3em}{0.0ex}}{y}$
 (269) 
However, some automatic simplifications are applied to and expressions.


The or Operator


The or operator represents logical disjunction. It is a binary operator of the form
If both operands evaluate to a truth value, the entire expression is evaluated according to the following truth table.
expr1

expr2

expr1 or expr2

true

true

true

true

false

true

true

FAIL

true

false

true

true

false

false

false

false

FAIL

FAIL

FAIL

true

true

FAIL

false

FAIL

FAIL

FAIL

FAIL



If a truth value cannot be determined, the expression is returned unevaluated.
${x}\phantom{\rule[0.0ex]{0.3em}{0.0ex}}{\textstyle {\mathbf{or}}}\phantom{\rule[0.0ex]{0.3em}{0.0ex}}{y}$
 (271) 
However, some automatic simplifications are applied to or expressions.


The xor Operator


The xor operator represents logical exclusive disjunction. It is a binary operator of the form
If both of its operands evaluate to truth values, the entire expression is evaluated according to the following truth table.
expr1

expr2

expr1 xor expr2

true

true

false

true

false

true

true

FAIL

FAIL

false

true

true

false

false

false

false

FAIL

FAIL

FAIL

true

FAIL

FAIL

false

FAIL

FAIL

FAIL

FAIL





The implies Operator


The implies operator represents logical implication. It is a binary operator of the form
If both of its operands evaluate to truth values, the entire expression is evaluated according to the following truth table.
expr1

expr2

expr1 implies expr2

true

true

true

true

false

false

true

FAIL

FAIL

false

true

true

false

false

true

false

FAIL

true

FAIL

true

true

FAIL

false

FAIL

FAIL

FAIL

FAIL



If a truth value cannot be determined, the expression is returned unevaluated.
${x}{\Rightarrow}{y}$
 (273) 
Some automatic simplifications are applied to implies expressions.



Relational Operators


Relational operators are used to form comparisons to be evaluated in a Boolean context. The relational operators in Maple are =, <>, <, <=, and in. Each is a binary operator that accepts two operands. When evaluated in a Boolean context, each of these operators determines whether its two operands have a certain relationship.
An equation is formed by using the = operator.
This has the general form
It represents an equation with expr1 as the lefthand side and expr2 as the righthand side. When evaluated in a Boolean context, it returns a value of true if its operands are equal, and returns a value of false otherwise.
Note that comparing distinct unassigned names returns a value of false.
The names x and y are distinct and unequal names in Maple and, when they are unassigned, they are considered different expressions in a Boolean comparison. If the names x and y have assigned values, those values are first substituted into the comparison, and the equality computation is performed on the assigned values, rather than the names themselves.
In general, expressions are compared for equality according to their memory address. That is, two expressions are considered equal in a Boolean context if they have the same address in memory. However, for certain expressions, a more mathematical test for equality is used. For example, the floatingpoint numbers 2.0000 and 2.0 are considered numerically equal, even though they are distinct objects in memory.
${36893628422603897532}$
 (281) 
${36893628422603897564}$
 (282) 
In fact, when the floatingpoint number 2.0 is compared to the integer 2, they are considered equal.
Determining whether two procedures are semantically equivalent is an undecidable problem in Computer Science. However, procedures which are detectably equivalent by simple transformations are considered to be equal. For example, it is clear that the name of a procedure parameter is not normally important, so the following two simple procedures are considered equal, although they are distinct expressions in memory.
>

evalb( proc(x) 2*x end proc = proc(y) 2*y end proc );

An inequation can be formed by using the <> operator. The general form is
This expression represents nonequality and returns a value of true if its operands are unequal, and false if its operands are equal.
Testing for inequality is performed similarly to testing for equality. Comparing two distinct unassigned names using the <> operator computes the equality of the names. The expression
returns a value of true because the names x and y are distinct as names.
A strict inequality is created by using the < operator. This has the general form
and can also be constructed using the form
For example,
You can also use the > operator.
Maple automatically converts this to the same expression as results from the first form.
When evaluated in a Boolean context, Maple performs the indicated mathematical comparison, or returns the inequality as unevaluated if the operands do not evaluate to comparable expressions. If the operands are comparable, the inequality evaluates to the value true if the first operand is less than, but not equal to, the second operand, and evaluates to false otherwise. If the operands are not comparable, the inequality evaluates to itself.
A nonstrict inequality is formed using the <= operator. This has the general form
It can also be constructed using the form
For example,
When evaluated in a Boolean context, and when the operands are comparable, it returns a value of either true or false according to whether the first operand is less than, or equal to, the second operand.
Membership is represented by the in operator. It is used in the general form
When evaluated in a Boolean context, it evaluates to the value true if its first operand expr1 is a member of its second operand expr2. If expr1 does not belong to expr2, the expression evaluates to false. Maple can determine a truth value if the second operand expr2 is a container object; that is, either a set or list, or an unevaluated function call of the form SetOf( T ), where T is a Maple type. An expression of the form
where T is a Maple type is equivalent to the expression type( expr, T ).
>

evalb( 1 in { 1, 2, 3 } );

>

evalb( 5 in { 1, 2, 3 } );

>

evalb( 2 in SetOf( integer ) );

>

evalb( 2/3 in SetOf( integer ) );

Note the simplification applied to the statement with the evalb command in the following example.
${x}{\in}{A}{\cup}{B}$
 (297) 
>

evalb( x in A union B );

${x}{\in}{A}\phantom{\rule[0.0ex]{0.3em}{0.0ex}}{\textstyle {\mathbf{or}}}\phantom{\rule[0.0ex]{0.3em}{0.0ex}}{x}{\in}{B}$
 (298) 
If the second operand is not an explicit container object, the expression remains an unevaluated in expression. However, some automatic simplifications may be applied.


Efficient Boolean Iteration


In the same way the commands add and mul can be used to efficiently form + and * expressions, conjunctions and disjunctions can be evaluated efficiently using the andmap and ormap commands, which are similar to the map command described in Maple Statements.
andmap( procedure, expression, ... )

ormap( procedure, expression, ... )



The following example considers type(element,name) for each element of the list. ormap determines whether this statement is true for at least one element of the list. andmap determines whether this statement is true for all the elements of the list.
>

ormap(type, [1, "a", `a`, a()], name);

>

andmap(type, [1, "a", `a`, a()], name);

The main difference between these commands and map is that andmap and ormap have shortcircuit ("McCarthy") semantics, which means that an answer is returned as soon as it can be determined.
>

andmap(proc(x) print(x); x<2 end proc, [1,2,3,4]);




3.11 Expressions for Data Structures


This section describes basic concepts related to data structure expressions. For more information on programming with data structures, see Basic Data Structures.

Sequences


The most basic aggregate expression type in Maple is the sequence. Sequences are formed by using the `,` (comma) operator.
${a}{,}\frac{{2}}{{3}}{,}{\mathrm{sin}}{}\left({x}\right){,}{5.1}$
 (302) 
A sequence consists of zero or more other expressions, called elements or members. A sequence with exactly one member is automatically simplified to its unique member. The empty sequence, containing zero members, is the value of the name NULL, and may be written as ().
Sequences occur in many other data structures as a (principal) component, within which they acquire additional semantics. Some examples include lists, sets, and function calls.
Automatic simplification of sequences is affected by recursively simplifying the component expressions.
>

'2 + 3, 1  7, 0^0, sin( Pi / 6 )';

${5}{,}{\mathrm{6}}{,}{1}{,}{\mathrm{sin}}{}\left(\frac{{\mathrm{\pi}}}{{6}}\right)$
 (304) 
Nested sequences are also flattened during the automatic simplification process.
>

'( 1, 2 ), 3, ( 4, 5 )';

${1}{,}{2}{,}{3}{,}{4}{,}{5}$
 (305) 
Because sequences are used to pass multiple arguments to procedures, it is not normally possible to operate on a sequence as such (the list type described below is designed for exactly for that reason). For example, you cannot pass a (nontrivial) sequence to the type command to check its type. Therefore, there is no Maple type for sequences. However, the whattype command returns the name exprseq when it is passed either zero or more than one argument.
${\mathrm{exprseq}}$
 (306) 
${\mathrm{exprseq}}$
 (307) 
Note that the name exprseq is not the name of any valid type in Maple.
Similarly, you cannot query the zeroth operand of a sequence. For example, the following results in an error.
This is because the sequence 0, ( 1, 2, 3 ) is flattened to the sequence 0, 1, 2, 3 during automatic simplification of the function call before the op command is actually called. Therefore, the op command is passed four arguments instead of only the two that are apparently intended.
There is no constructor for sequences, but there is a builtin command for creating sequences, called seq. The basic syntax of seq is below. It accepts many other types of arguments as well.
seq(expression, i = integer1..integer2)



>

seq( i^2, i = 1 .. 5 );

${1}{,}{4}{,}{9}{,}{16}{,}{25}$
 (308) 
${2}{,}{3}{,}{4}{,}{5}{,}{6}{,}{7}{,}{8}{,}{9}{,}{10}{,}{11}{,}{12}{,}{13}{,}{14}$
 (309) 
>

seq( i, i = 0.4 .. 1.1, 0.3 );

${0.4}{,}{0.7}{,}{1.0}$
 (310) 
For more information on the seq command, refer to the seq help page.
Another way to create sequences is to use the dollar sign ($) operator.
expression $ i = integer1 .. integer2



${1}{,}{4}{,}{9}{,}{16}{,}{25}$
 (311) 
The dollar sign operator is a binary operator that performs a similar function to the seq command, but behaves slightly differently: the $ operator evaluates the expression argument once before any substitutions, while the command does not evaluate until after each substitution of i.
${\mathrm{ax}}{,}{\mathrm{ax}}$
 (312) 
>

seq(cat(a,x), x= 1..2);

${\mathrm{a1}}{,}{\mathrm{a2}}$
 (313) 
In general, it is recommended that you use the seq command instead of the dollar sign operator.


Lists


Lists are created by enclosing a sequence of expressions between square brackets. Lists are essentially sequences, which are designated as a single unit for other operations.
$\left[{1}{\,}{2}{\,}{3}\right]$
 (314) 
Unlike sequences, lists can form properly nested structures.
$\left[{1}{\,}{2}{\,}\left[{3}{\,}{4}\right]\right]$
 (315) 
Use the numelems command to determine the number of members in the enclosed sequence. Note that lists can contain sublists. These are still counted as a single entry.
>

numelems( [ 1, 2, 3 ] );

>

numelems( [ 1, 2, [ 3, 4 ] ] );

To access the $i$th operand of a list, use an index to the list expression.
${L}{\u2254}\left[{a}{\,}{b}{\,}{c}{\,}{d}\right]$
 (318) 
To access the sequence of all elements in a list, use the op command. Converting back and forth between lists and sequences can be a common operation, and is very efficient.
${\mathrm{Lseq}}{\u2254}{a}{,}{b}{,}{c}{,}{d}$
 (320) 
>

L2 := [ op(L), op(L) ];

${\mathrm{L2}}{\u2254}\left[{a}{\,}{b}{\,}{c}{\,}{d}{\,}{a}{\,}{b}{\,}{c}{\,}{d}\right]$
 (321) 
It is common to create a list by using the seq command to create the enclosed sequence.
>

[ seq( i^2, i = 1 .. 5 ) ];

$\left[{1}{\,}{4}{\,}{9}{\,}{16}{\,}{25}\right]$
 (322) 
Lists are ordered; two lists with the same members in a different order are distinct.
>

evalb( [ 1, 2, 3 ] = [ 2, 1, 3 ] );

Lists are immutable; you cannot change the elements of a list once it has been created. You can, however, create a new list using members of an existing list or lists.
In the next example, we create a new list with second entry d.
${L}{\u2254}\left[{a}{\,}{b}{\,}{c}\right]$
 (324) 
>

L2 := [ L[ 1 ], d, L[ 3 ] ];

${\mathrm{L2}}{\u2254}\left[{a}{\,}{d}{\,}{c}\right]$
 (325) 
You can also use the subsop command for this purpose.
>

L3 := subsop( 2 = d, L );

${\mathrm{L3}}{\u2254}\left[{a}{\,}{d}{\,}{c}\right]$
 (326) 
The example above creates a new list using the original list L by substituting its second operand for the expression d. If you need to change elements frequently it is usually better to use an array. Arrays can be changed inplace avoiding the need for a copy. For more information on the subsop command, refer to the subsop help page.
For more information about lists, see Lists.


Sets


Sets, similar to lists, are created from a sequence of expressions. However, sets use braces ({}) to enclose the sequence.
$\left\{{1}{\,}{2}{\,}{3}\right\}$
 (328) 
In addition to the syntactical differences, sets differ from lists in that they are unordered and do not have duplicate entries. These two properties are enforced during the automatic simplification process.
$\left\{{\mathrm{1}}{\,}{0}{\,}{3}\right\}$
 (329) 
   