An element-wise operation allows you to distribute the operation over the elements of a list, set, table, Array, Matrix, or Vector. The syntax for this is to use a tilde (~) after the given operator or function name.

>

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

(1)

>

sin~(<1,2,3>);

(2)

•

Dimensioned container types: list, set, Array, Matrix, and Vector can be intermixed in a given operation as long as they are the same size. A table can only appear once in an argument list and can only be mixed with non-containers. For the purpose of element-wise operations, records are not considered container objects.

>

[true,true,false,false] xor~ <true,false,true,false>;

(3)

•

Non-containers are treated as single elements repeated sufficiently often to match the size of the other containers in the argument sequence.

>

<1,2,3> ^~ 2;

(4)

•

Unlike map and zip, which usually apply to the operands of their given arguments, element-wise operations treat non-container data types as single elements. For example, f~(a=b) evaluates to f(a=b), whereas map(f,a=b) breaks apart the equation applying f to each side of the equation resulting in f(x)=f(b).

•

It is never an error to use a single-element non-container in any part of an element-wise expression. If an error occurs it happens as a result of applying the base operator to one subset of the overall operation. In other words, when applying ^~, the only error that will ever be raised will come from ^, with the exception of mismatched container sizes.

•

The returned data structure will match the type of the given container. A call involving only lists will return a list. When mixed container types are present the return type will be determined according to the following precedence: rtable, list, set. A call involving rtables and arrays(deprecated) will result in an rtable. A call involving arrays and lists will result in an array.

>

f~([a1,a2],<b1,b2>,c);

(5)

•

Lists and sets are always considered to be 1-dimensional. That is, a list-of-lists is not inferred as a 2-D object.

>

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

(6)

•

Expression sequences are also treated as container types when they appear on either side of an element-wise operator. Due to the normal flattening rules expression sequences cannot normally be used with functional notation as they are interpreted as multiple arguments. The exception to this rule can be found when following the internal representation outlined for overloading element-wise operations. Element-wise operators can be overloaded by binding the ~ function. The ~ function gets called with the operation in square brackets as an index to the function name. In order to distinguish element-wise operator calls with an expression sequence on either side of the operator, the arguments are separated by a special fence token, $ (space-dollarsign). The statement, a +~ (b,c) is recast as ~[`+`](a,` $`, b, c). Similarly, f~(a,b,` $`,1,2) is interpreted as a element-wise function call with two expression sequence arguments, (a,b), and (1,2), resulting in the sequence f(a,1),f(b,2).

•

Because ~ is allowed at the beginning of a name in Maple, white-space is required in some situations to make the meaning of a statement unambiguous. Consider the expression (a*~b) -- this means (a *~ b), not a * (~b). Using parentheses or adding a space after the multiplication symbol is required to use the name ~b (tilde-b) in an expression like this.

•

The neutral operators &*~ and &+~ are currently valid, so use of element-wise &* and &+ requires a space between the neutral operator and the tilde (i.e., (a &* ~ b) is element-wise &*, and (a &*~ b) is a use of the neutral operator &*~. This distinction is not something that can be enforced by the parser -- be careful when using element-wise &* and &+.)

•

When a non-operator expression involving tilde is not part of a function call, a symbolic representation is returned. The underlying representation of f~ is `~`[f]. These expressions retain their element-wise properties while being passed into other functions. For example, consider the difference between map(f,[[a,b]]) and map(f~,[[a,b]). In the first case f is applied to the sublist, [a,b], and in the second case f is applied in an element-wise fashion to the same sublist.