The easiest way to create a list is to enclose a sequence of expressions in square brackets ([]). A sequence of expressions is a series of comma-separated expressions.

This creates a list that contains the elements of sequence in the specified order. In the case where sequence is empty, [] represents an empty list. Compare the results of these examples to those in the Sets section.

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

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

Many Maple functions return sequences. Thus, enclosing a call to one of those functions in square brackets [] creates a list. For example, the seq command generates sequences.

The op command can be used to extract the sequence of elements in a list.

Thus op can be used to create new lists based on existing lists. For example, you can create a new list with an additional element added to the start of the list.

A list with another element added to the end of the list can be created in a similar way.

Multiple lists can also be combined into a single list.

The selection operation, [], can be used to read an element from a list.

You can also specify a range in the selection operation to extract a sublist containing the elements that are indexed by that range.

While it is possible to make an assignment to a list index, this operation can be inefficient since it creates a new list. In fact, assignment to a large list is not permitted in Maple and will produce an error.  Assigning a list element is a common error, so if you find yourself wanting to do this, consider using a mutable data structure instead. For more information, see Mutable Data Structures.

L is now a new list with a different element at index 1. Thus, assigning to a single element of a list causes the entire list to be copied in the same way as using the subsop command. In fact, the previous example is equivalent to the following except in how the result is displayed.

If you attempt to assign to an index to a large list, an error will occur. Therefore, if you need to make a copy of a list with one changed element, it is recommended that you use the subsop command instead.

To test if an expression is contained in a list, use the member function.

You can also use the in operator.

To find the length of a list, use the numelems command.

This can be useful for many tasks, for example, using lists in a loop. For more information on selectremove,  see Filtering Data Structure Elements.

The sort command can create a new list with sorted elements from any given list. By default, sort arranges elements in ascending order.

The sort command can also accept a second argument that specifies the ordering to use when sorting the elements.

It is often useful to be able to apply a function to all the elements of a list. The map command performs this operation in Maple.

Maple provides other operations that can work with the members of a list, such as add and mul.

Finally, a for loop can be combined with the in operator to loop over the contents of a list.

The easiest way to create a set is to enclose a sequence of expressions in braces ({}).

When Maple creates the set, it performs automatic simplification. This process creates a set that contains the elements of sequence; however, during the automatic simplification process, any duplicate elements are removed and the remaining elements are reordered.

Compare the results of these examples to those in the Lists section.

Similar to lists, sets can be created using functions such as seq that return sequences.

Again, similar to lists, the op command can be used to extract the sequence of elements in a set.

However, unlike lists, Maple provides operations for set arithmetic, so for sets op is somewhat less important.

Maple provides operators for mathematical set manipulations: union, minus, intersect, and subset. These operators allow you to perform set arithmetic in Maple.

The selection operation, [], can be used to read an element from a set. However, unlike lists, the order in which the elements are specified when creating the set may not correspond to the order they are accessed by indexing.

Unlike lists, you cannot use the selection operation to create new sets.

You can specify a range in the selection operation to extract the elements indexed by the range.

To test if an element is contained in a set, use the member function.

You can also use the in operator.

To find the number of elements in a set, use the numelems command.

In this example, the features of sets are used to test Collatz's conjecture on the first million integers. Collatz's conjecture states that given any integer, i, if the following function is applied repeatedly, the result will eventually be 1.

Begin with a set S that consists of the integers from 1 to 1 million.  Under repeated application of collatz, as numbers converge to 1, the set automatically removes duplicate values, until eventually there is only 1 element left.  For more information on the use of map, see Applying a Function to the Contents of a Set.

As with lists, it can be useful to apply a function to all of the elements of a set. The map command works on sets, as it does with lists.

Notice that when applying a function to a set, the output is also a set, which means the elements are reordered and duplicate elements are removed.

Maple provides other operations that can work with the members of a list, such as add and mul.

Finally a for loop can be combined with the in operator to loop over the contents of a set.  Note that the set has been reordered.

A new table can be created by calling the table function.  

With no arguments, table creates a new empty table. To create a table that contains certain index/entry pairs, specify the pairs as a list of equations. The left-hand side of an equation is the index and the right-hand side is the entry.

If the given list contains one or more expressions that are not equations, the list is treated as a list of entries and the indices are the positions of the entries in the list (1, 2, 3, ...).

Note that c=d is treated as a entry and not an index/entry pair.

Tables are also created implicitly when you assign to an indexed name.

Table indexing is performed using the selection operation, []. To extract data from a table, specify an index in square brackets. The corresponding entry is returned.

If the table does not contain a entry associated with the index, an unevaluated table reference is returned.

The selection operation can also be used to add new index/entry pairs to the table.

The best way to remove an element from a table is to call the unassign function.

The selection operation can also be used to remove an index/entry pair from a table. By assigning the unevaluated table entry to its name, that element is removed from the table. This can be done by using unevaluation quotes ( ' ) or the evaln command.

The numelems function returns the number of elements stored in a table.

It is often useful to know if a particular index has a value in a table. Use the assigned function to check if a table index has an associated entry.

Tables, like procedures, use last name evaluation. If a name is assigned a table, the result of evaluating that name is the name and not the table assigned to the name. For more information about last name evaluation, refer to the last_name_eval help page.

To get the assigned value (the table), use the eval command.

Tables are often used as simple containers for data. Sometimes, it is useful to have a list of the indices used in the table. Maple provides the indices function for this purpose.

You may not expect to see that indices returns a sequence of lists, where each list contains the index. This is because Maple allows sequences to be used as indices in tables.

If the indices were not wrapped in a list, it would be impossible to determine if an index is a single expression or a sequence of expressions. Since using sequences as indices is uncommon, indices accepts a nolist option, for which indices returns a simple sequence and does not wrap each index in a list.

Note that, with the nolist option, indices that are sequences are not returned properly.

You can also use the entries function to get all the values stored in the table.

To extract the index/entry pairs as a sequence of equations, use the pairs option to either of the indices or entries commands.

If you assign a table to multiple names, all the names reference the same table. Thus, changes to the table using one name are visible from the other names.

If you want to create a copy of a table, use the copy function so that the tables can be modified independently.

The map function works with tables as it does with lists and sets.  When executing a map on a table, the mapped function is given the value associated with an index. In the returned table, the result is the entry associated with the index.

You can use the indices and entries functions to produce a list that can be mapped over or used in a for-in loop. You can also use this technique to modify the original table.

To create an Array in Maple, use the Array command and specify the ranges for the dimensions. This creates a new Array with each entry initialized to 0. For Arrays, the ranges do not need to start at 1.

When creating an Array, you can also specify a generator function to populate the Array with data. The generator function takes an index as an argument and returns a value for the corresponding entry.

You can also provide the data for the Array by specifying the data as a list or nested lists.

Arrays are implemented in Maple as a type of rtable, a structure also used for Matrices and Vectors. This means that Arrays have two different indexing mechanisms: mathematical indexing and programmer indexing. Mathematical indexing is intended for use when the Array is viewed as a mathematical object. Programmer indexing provides functionality that is more convenient when using Arrays as a programming tool.

The basic indexing operator, [], provides mathematical indexing. Programmer indexing is accessed by using round brackets, ().  For Arrays whose dimension ranges all start at 1, the two indices behave similarly.

You may notice that the assignment that uses programmer indexing is displayed differently than the assignment that uses mathematical indexing. This is because the result of an assignment to a programmer indexed Array is the entire array. This can be important when working with large sub-Arrays.

When the ranges do not start at 1, mathematical and programmer indexing are different. Mathematical indexing requires that the indices match the specified ranges, but programming indexing always normalizes the ranges to start at 1.

This means that programmer indexing can always take advantage of negative indexing, which normally only works when the ranges start at 1. Negative indexing counts backwards from the end of the range.

A sub-Array of an Array can be accessed by specifying a subrange in place of the indices.

Sub-Array indexing can also be used to assign to the specified sub-Array.

Note that the commands perform the same operation, but display the result differently. This is the consequence of an important difference in how the modification is performed. This can be important when working with large sub-Arrays. Compare the time to perform the assignment in the following examples:

The difference in running time of these copies is due to the difference in the result of an assignment to an Array index. For mathematical indexing, a new 3000 by 3000 Array must be created as the result. With programmer indexing, the result is the Array being assigned to in its entirety - an object that already exists.

One of the most important differences between mathematical and programmer indexing is automatic resizing. When reading from or writing to an entry using mathematical indexing, an index that is outside the bounds of the Array will raise an exception.

However, programmer indexing allows you to write to an entry that is outside the bounds of the current Array. Instead of raising an exception, the Array are automatically resized so that the element can be stored. Reading from an out-of-bounds index will still raise an exception.

There are more features of, and differences between, mathematical and programmer indexing. For more information on Array indexing, refer to the rtable_indexing help page.

The numelems function returns the number of elements defined by the bounds of an Array.

As Array bounds may not start at $1$, it is important that procedures that accept Arrays be aware of this possibility. The upperbound and lowerbound functions can be used to get the bounds on the ranges of an Array.

As with tables, having multiple variables referencing the same Array does not create new copies of the Array. You can use copy to copy the Array.

For Arrays, there are two notions of equality: do two references point to the same Array, or are they different Arrays that store the same values. To determine if two references refer to the same Array, use = and evalb. To test if two Arrays contain the same elements, use the EqualEntries command.

There are some other advanced notions of equality such as whether or not arrays with undefined entries should be treated as having equal entries, and whether a Matrix and Array with identical entries should be considered the same.  The IsEqual command in the ArrayTools package allows for different solutions for these two issues compared to EqualEntries.  The ArrayTools package contains a variety of functions for working with Arrays.  For more information, refer to the ArrayTools help page.

map can be used with an Array as you would expect

indices, entries, and the in operator work with Arrays, so you can use Arrays in add, mul, and for loops.  entries(A,pairs) can also be used to obtain a list of index/value pairs in the same way that it does for tables.

When creating an Array, you can specify a datatype for the Array elements. The given datatype can be either a Maple type or a hardware datatype specifier: integer[n], float[n], complex[n]. n refers to the number of bytes of data for each element. For integer[n], n can be 1, 2, 4, or 8.  For float[n] or complex[n], n can be 4 or 8. The datatype integer[4] uses 4-bytes, or 32-bits per integer, and integer[8] uses 8-bytes, or 64-bits.  The 64-bit version has a wider range of signed values, but uses more memory.