Steps

Results

Expression sequences (or simply sequences) are created using the comma operator.  

Example:

$s≔1\,2\,3\,a\,b\,c$ assigns the name $s$ to the sequence.

In Maple, sequences form the basis of many data types. In particular, they appear in function calls, lists, sets, and subscripts. $$

To select members of a sequence, use index notation: $s\left[i\right]$refers to the $i$th element of the sequence $s$.  

You can also use subscript notation, $s_i$, to refer to the $i$th element.  Use Ctrl + underscore (_) to enter the subscript.

Note:  Index and subscript notation are available when using the 2-D math editor. In places where Maple syntax is required, such as the start-up code region, index notation must be used.

$s≔1\,2\,3\,a\,b\,c$

$s\left[1\right]$

$s_2$

$s_4$

The seq Command

The seq command is used to construct a sequence of values.

The calling sequence used here is seq(f(i), i=1..n), which generates the sequence f(1), f(2), ..., f(n).  For more information, see seq.

$\mathrm{seq}\left(i\,i\=1..10\right)$

$\mathrm{seq}\left(k^2\,k\=1..5\right)$

Steps

Results

A set is an unordered sequence of distinct expressions enclosed in braces {}.

Note: Maple removes duplicate members from a set. The sequence can be empty, so {} represents an empty set.

Notice that when the set $\mathrm{S1}$$≔\left\{a\,b\,x\,y\,z\,a\right\}$ is evaluated, the duplicate $a$ is removed.

$\mathrm{S1}≔\left\{a\,b\,x\,y\,z\,a\right\}$

$\mathrm{S2}≔\left\{1\,2\,b\,c\right\}$

Set Arithmetic

To perform set arithmetic, use the symbols from the Common Symbols palette or use the operators $\mathbf{union}$, $\mathbf{intersect}$, and $\mathbf{minus}$.

Example:

Find the union, intersection and set difference of the sets $\mathrm{S1}$ and $\mathrm{S2}$.

Testing Set Membership

Example:

To test for set membership, use the command member.

Alternatively, use the set notation to form the statement $x \in \mathrm{S1}$ then use evalb (evaluate boolean) to evaluate the expression to get true or false. The keyword $\mathbf{in}$ can be used instead of the ∈ symbol.

$\mathrm{S1}\bigcup \mathrm{S2}$ = $\left\{1\,2\,a\,b\,c\,x\,y\,z\right\}$$$

$\mathrm{S1}\bigcap \mathrm{S2}$ = $\left\{b\right\}$$$

$\mathrm{S1}\setminus \mathrm{S2}$ = $\left\{a\,x\,y\,z\right\}$$$

$\mathrm{S1} \mathbf{union} \mathrm{S2}$ = $\left\{1\,2\,a\,b\,c\,x\,y\,z\right\}$$$

$\mathrm{S1} \mathbf{intersect} \mathrm{S2}$ = $\left\{b\right\}$$$

$\mathrm{S1} \mathbf{minus} \mathrm{S2}$ = $\left\{a\,x\,y\,z\right\}$$$

$\mathrm{member}\left(x\,\mathrm{S1}\right)$

$\mathrm{member}\left(1\,\mathrm{S1}\right)$

$\mathrm{evalb}\left(x\∈\mathrm{S1}\right)$

$\mathrm{evalb}\left(1 \mathbf{in} \mathrm{S1}\right)$

Selecting Elements

Use the same selection notation as for sequences: $s\left[i\right]$ and $s_i$ both represent the $i$th element in the set $s$.

Example:

Select the first and third elements of $\mathrm{S1}$

$\mathrm{S1}\left[1\right]$

${\mathrm{S1}}_3$

Maple has a type-checking function.

The commands whattype returns the Maple type.  The command type does type-checking.

Tip:  Type-checking is useful in programming Maple procedures.

$\mathrm{whattype}\left(\mathrm{S1}\right)$

$\mathrm{type}\left(\mathrm{S1}\,\mathrm{set}\right)$

Steps

Results

A list is an ordered sequence of expressions enclosed between square brackets [ ]. The ordering of the list is the same as the sequence ordering. Also unlike sets, duplicate members are retained in the list. In the case where a sequence is empty, [ ] represents an empty list.

Lists can be created by enclosing a defined sequence in square brackets.

Example:

Create a list from the sequence $s$.

The elements of a list can be any expressions, even other lists.  

Maple gives nested lists whose inner lists have the same number of elements a special name, listlist.

$\mathrm{L1}≔\left[x\,y\,z\,x\right]$

$s$

$\mathrm{L2}≔\left[s\right]$

$\mathrm{L3}≔\left[\mathrm{L1}\,\left[1\,2\right]\,3\,\mathrm{L2}\right]$

$M≔\left[\left[a\,b\right]\,\left[1\,2\right]\,\left[4\,5\right]\,\left[3\,7\right]\right]$

$\mathrm{whattype}\left(M\right)$

$\mathrm{type}\left(M\,\mathrm{listlist}\right)$

$\mathrm{type}\left(\mathrm{L3}\,\mathrm{listlist}\right)$

Selecting Elements

Use the same selection notation as for sequences and sets: $s\left[i\right]$ and $s_i$ both represent the $i$th element in the list $s\.$

Selection operations can be combined to select elements from nested lists.

Selecting partial lists

Select a range of elements from a list by using $i..j$ to specify a range of indices. Leaving off an end point means "from the beginning" or "until the end."

$\mathrm{L1}$

$\mathrm{L1}\left[3\right]$

$M\left[1\right]$

$M\left[1\right]\left[2\right]$

$\mathrm{L1}\left[2..3\right]$

$\mathrm{L1}\left[..3\right]$

$\mathrm{L1}\left[3..\right]$

Testing List Membership

Example:

To test for list membership, use the command member.

You can also determine the position of an element in a list. If member returns true and a third argument, for example 'i', is included in the calling sequence, the element's position in the list is assigned to i.

$\mathrm{member}\left(x\,\mathrm{L1}\right)$

$\mathrm{member}\left(y\,\mathrm{L1}\,\'i\'\right)$

$i$

The op and numelems Commands

The op command can be used to extract elements (or operands) from any Maple data structure, including lists. It is particularly useful when modifying existing lists.

The numelems command returns the number of elements.

Example:

Extract all the elements from the list L1.

Find the number of elements in L1.

Concatenating Lists

Use the op command to extract the expression sequence of elements from individual lists. Concatenate two lists by creating a new list from the expression sequences.

Adding Elements to a List

The same method is used to add an element to a list.

$\mathrm{L1}$

$\mathrm{op}\left(\mathrm{L1}\right)$

$\mathrm{numelems}\left(\mathrm{L1}\right)$

$\mathrm{op}\left(\mathrm{L1}\right)$

$\mathrm{op}\left(\mathrm{L2}\right)$

$\left[\mathrm{op}\left(\mathrm{L1}\right)\,\mathrm{op}\left(\mathrm{L2}\right)\right]$

$\left[X\,Y\,\mathrm{op}\left(\mathrm{L2}\right)\right]$

Replacing Elements in a List

Replace an element in a list by assigning a new value to that position.

If a list has duplicates and you want to replace all occurrences, use the eval command.

Example:

Replace "a" by "A" everywhere it appears in the list L4.

$\mathrm{L1}$

${\mathrm{L1}}_4≔\mathrm{\α}$

$\mathrm{L1}$

$\mathrm{L4}≔\left[a\,b\,a\,c\,d\,a\right]$

$\mathrm{eval}\left(\mathrm{L4}\,a\=A\right)$

Sorting a List

The sort command sorts the elements of a numerical list into ascending order.

$\mathrm{sort}\left(\left[1\,4.2\,2\,1\,-3.7\,8\,5 \right]\right)$

Steps

Result

A MultiSet is a data structure that can be used to manage unordered collections of data while accounting for multiple occurrences of particular members.

Example:

a collector of baseball cards might have 3 "Ty Cobb" cards, 1 "George Brett", and 2 "Nolan Ryan". This collection can be represented as a MultiSet:

$\mathrm{MyCards} ≔ \mathrm{MultiSet}\left( \left[''Ty\; Cobb''\, 3\right]\, \left[''George\; Brett''\, 1\right]\, \left[''Nolan\; Ryan''\, 2\right] \right)$

If the collector then obtains 2 more "Ty Cobb" cards and a "Reggie Jackson", these cards can be added to the collection with the  command to the right:

$\mathrm{MyCards} ≔ \mathrm{MyCards} \+\left\{\left[''Ty\; Cobb''\, 2\right]\, \left[''Reggie\; Jackson''\,1\right]\right\}$

For a standard MultiSet, the multiplicity of any element must be a non-negative integer (elements with multiplicity 0 are removed from the MultiSet).  A more general structure, allowing any real number to represent the "multiplicity" is available by attaching the index generalized to the MultiSet call:

$M ≔ \mathrm{MultiSet}\left[\mathrm{generalized}\right]\left( a\=\frac{1}{2}\, b\=-3.1415\, c\=2\right)$

This kind of MultiSet can be produced by the convert command when applied to a rational function:

$\mathrm{convert}\left(\frac{{\left(x^2\+1\right)}^3 {\left(x-2\right)}^2}{{\left(x^2\+3 x-1\right)}^4}\,\mathrm{MultiSet}\, \mathrm{generalized}\right)$

Steps

Result

To apply a function or procedure to the elements of a set or list, use the element-wise operator ~,  map, or zip.

Examples using element-wise operators:

To multiple all elements in S1 by 2, you can use element-wise multiplication.  The syntax is to use a tilde (~) after the multiplication operator. This distributes the multiplication operator over all the elements of the set.  For more about element-wise operators, see operators/elementwise.

Apply sin to all the elements in S1.

Example using map:

Square all the elements of S1.

To apply a function of two variables f(x,y) to the elements of two lists, use the zip command.  The syntax is zip(f, list1, list2).

Example:

Multiply the elements of A1 and A2 together.

Find the pairwise greatest common denominator of the elements of the lists A1 and A2.  Use igcd to find the greatest common denominator for the integers.

$\mathrm{S1}$

$2\cdot ~\mathrm{S1}$

$\sin ~\left(\mathrm{S1}\right)$

$\mathrm{map}\left(x\to x^2\,\mathrm{S1}\right)$

$\mathrm{A1}≔\left[2\,6\,9\right]\:$

$\mathrm{A2}≔\left[2\,7\,6\right]\:$

$\mathrm{zip}\left(\left(x\,y\right)\to x\cdot y\,\mathrm{A1}\,\mathrm{A2}\right)$

$\mathrm{zip}\left(\mathrm{igcd}\,\mathrm{A1}\,\mathrm{A2}\right)$

Using a for loop.

You can also use a conditional statement for ... do ... to perform an operation repeatedly, once for each element in the set.  The results are printed to the screen.

A for loop can be used to run through a sequence.

Note:  Maple's built-in commands such as map and zip (as well as the ~ operator) can be significantly faster than using a for loop.  For efficiency, whenever possible, you should use these commands instead.  For more information, see efficiency.

Tip: For more information and examples of conditional statements, see do or the Basic Programming chapter of Maple's User Manual.

$\mathrm{S1}$

$\mathbf{for} i \mathbf{in} \mathrm{S1} \mathbf{do} i^3\mathbf{end} \mathbf{do}$

$s$

$\mathbf{for} j \mathbf{in} s \mathbf{do} j^2\cdot \sin \left(\frac{j\cdot \mathrm{\π}}{3}\right) \mathbf{end} \mathbf{do}$

Steps

Results

Define an array.

Example:

Define an array with a list of entries.

Example:

Define a 3 x 3 array with values from 1 to 9.

The calling sequence used here is Array(rows, columns, entries), where the rows and columns are given as ranges and the entries are given as a nested list.

$\mathrm{A1}≔\mathrm{Array}\left(\left[1.1\, 1.2\, 1.3\, 1.4\right]\right)$

$\mathrm{A2}≔\mathrm{Array}\left(1..3\,1..3\,\left[\left[1\,2\,3\right]\,\left[4\,5\,6\right]\,\left[7\,8\,9\right]\right]\right)$

Indexing and Dynamically Growing Arrays

Extract entries

Example:

Extract a single entry from A1.

Extract the entry in the second row and first column of A2.

You can extract entries using either [] or () brackets.  

The first method of index selection you have seen used for other data structures, such as lists.  The second method, (), which only works on rtables, is called programmer indexing.  Programmer indexing allows for more flexible and powerful indexing.   For example, you can grow an array by assigning to an element outside the initial boundaries.

Dynamically Grow an Array

Example:

Grow an array with () brackets.

For more information on indexing, see rtable indexing.

$\mathrm{A1}\left[2\right]$

$\mathrm{A2}\left[2\,1\right]$

$\mathrm{A1}\left(2\right)$

$\mathrm{A1}\left(2..3\right)$

$\mathrm{A1}\left(5\right)≔1.5$

$\mathrm{A1}$

Creating an Array using an Initializer Function

You can define an array or matrix by giving a function to be used when filling in the entries.  

Example:

Define a 5 x 5 array using the function $\left(x\,y\right)\to 0.1\cdot \mathrm{x}\+\mathrm{y}$.

First, use the function template $f:=\left(a\,b\right)\to z$ from the Expression palette.  Replace each placeholder with the appropriate value, using [Tab] to move between placeholders.

Then, define the array by giving the row range, column range, and initializer function name.

$\mathrm{indexrule}≔\left(x\,y\right)\to 0.1\cdot x\+y\:$

$\mathrm{A3}≔\mathrm{Array}\left(1..5\,1..5\,\mathrm{indexrule}\right)$

Steps

Result

Define a table which associates the pairs:

$a\,\mathrm{\α}$

$b\, \mathrm{\β}$

$c\, \mathrm{\γ}$

The entries are indexed by a, b, and c.  

To see all the entries of the table, use entries.

Use the 'pairs' option to see the index=entry pairs.

$K≔\mathrm{table}\left(\left[a\=\mathrm{\α}\,b\=\mathrm{\β}\, c\=\mathrm{\γ}\right]\right)$

$K\left[a\right]$

$K\left[b\right]$

$K\left[c\right]$

$K$

$\mathrm{entries}\left(K\right)$

$\mathrm{entries}\left(K\,\'\mathrm{pairs}\'\right)$