An element-wise operation allows you to distribute the operation over the elements of a data container.  The syntax for this is to use a tilde (~) after the given operator or function name.

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

$\left[\begin{array}{c}4\\ 10\\ 18\end{array}\right]$

An element-wise function allows you to apply a function to the elements of a data container.  As with any function call, you must use parentheses.

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

$\left[\begin{array}{c}\sin \left(1\right)\\ \sin \left(2\right)\\ \sin \left(3\right)\end{array}\right]$

f:=x->x^2:

f~(<a,b,c>);

$\left[\begin{array}{c}{a}^2\\ b^2\\ c^2\end{array}\right]$

The data container can be a list, set, table, Array, Matrix, or Vector. Details and other possibilities are discussed in the Details section below.

The element-wise operators in Maple are:

There is a function form of ~, which must be called with left single quotes around it: `~`(...).  When applied this way, the operators in the given expression will be interpreted as element-wise.  Thus, normal non-elementwise operators and functions can be used, and they will all be interpreted as being element-wise.   Specifically, + - * . / ^, abs, sqrt, log, ceil, floor, round, trunc, frac and all the trig and log functions will be applied as element-wise.

For example:

A := [5,9]:

B := [3,4]:

C := [5,6]:

G := [16,36]:

`~`(A*B/C^2*sqrt(G));

$\left[\frac{12}{5}\&comma;6\right]$

The function elementwise(...) is a synonym for the tilde function.

elementwise(A*B/C^2*sqrt(G));

$\left[\frac{12}{5}\&comma;6\right]$

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 containers.

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

$\left[\begin{array}{c}\mathrm{false}\\ \mathrm{true}\\ \mathrm{true}\\ \mathrm{false}\end{array}\right]$

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;

$\left[\begin{array}{c}1\\ 4\\ 9\end{array}\right]$

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: object, 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 := 'f';

$f≔f$

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

$\left[\begin{array}{c}f\left(\mathrm{a1}\&comma;\mathrm{b1}\&comma;c\right)\\ f\left(\mathrm{a2}\&comma;\mathrm{b2}\&comma;c\right)\end{array}\right]$

Lists and sets are always considered to be one-dimensional. That is, a list-of-lists is not inferred as a two-dimensional container.

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

$\left[\left[1\&comma;2\right]+2\&comma;\left[3\&comma;4\right]+2\right]$

An object will only be treated as a container if it exports both ?[] and upperbound.  If lowerbound is not exported then it will be assumed that the lower bounds for each dimension are 1.  If an object does not export these methods, it will be treated as a scalar.  An element-wise operation involving objects will proceed by using ?[] to extract the relevant elements into an Array, build up the result in said Array, and then attempt to call the first object's ModuleCopy constructor with the Array as an argument.  If ModuleCopy does not exist, or if it raises an error, then the result will be returned as an Array.  It is assumed that the ModuleCopy constructor uses the first argument to populate its data; if it ignores the data array, then the result will likely be incorrect.

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.

A := <1,2,3;4,5,6;7,8,9>;

$A≔\left[\begin{array}{ccc}1& 2& 3\\ 4& 5& 6\\ 7& 8& 9\end{array}\right]$

B := LinearAlgebra:-IdentityMatrix(3);

$B≔\left[\begin{array}{ccc}1& 0& 0\\ 0& 1& 0\\ 0& 0& 1\end{array}\right]$

A . B;

$\left[\begin{array}{ccc}1& 2& 3\\ 4& 5& 6\\ 7& 8& 9\end{array}\right]$

A .~ B;

$\left[\begin{array}{ccc}1& 0& 0\\ 0& 5& 0\\ 0& 0& 9\end{array}\right]$

sin~(A);

$\left[\begin{array}{ccc}\sin \left(1\right)& \sin \left(2\right)& \sin \left(3\right)\\ \sin \left(4\right)& \sin \left(5\right)& \sin \left(6\right)\\ \sin \left(7\right)& \sin \left(8\right)& \sin \left(9\right)\end{array}\right]$

-~ A;

$\left[\begin{array}{ccc}\mathrm{-1}& \mathrm{-2}& \mathrm{-3}\\ \mathrm{-4}& \mathrm{-5}& \mathrm{-6}\\ \mathrm{-7}& \mathrm{-8}& \mathrm{-9}\end{array}\right]$

A !~;

$\left[\begin{array}{ccc}1& 2& 6\\ 24& 120& 720\\ 5040& 40320& 362880\end{array}\right]$

myproc := proc(x) x^2; end:

myproc~(A);

$\left[\begin{array}{ccc}1& 4& 9\\ 16& 25& 36\\ 49& 64& 81\end{array}\right]$

A mod~ 3;

$\left[\begin{array}{ccc}1& 2& 0\\ 1& 2& 0\\ 1& 2& 0\end{array}\right]$

A >~ 3;

$\left[\begin{array}{ccc}3<1& 3<2& 3<3\\ 3<4& 3<5& 3<6\\ 3<7& 3<8& 3<9\end{array}\right]$

evalb~(A >~ 3);

$\left[\begin{array}{ccc}\mathrm{false}& \mathrm{false}& \mathrm{false}\\ \mathrm{true}& \mathrm{true}& \mathrm{true}\\ \mathrm{true}& \mathrm{true}& \mathrm{true}\end{array}\right]$

(evalb@`>`) ~ (A,3);

$\left[\begin{array}{ccc}\mathrm{false}& \mathrm{false}& \mathrm{false}\\ \mathrm{true}& \mathrm{true}& \mathrm{true}\\ \mathrm{true}& \mathrm{true}& \mathrm{true}\end{array}\right]$

evalhf~(A >~ 3);

$\left[\begin{array}{ccc}0.& 0.& 0.\\ 1.& 1.& 1.\\ 1.& 1.& 1.\end{array}\right]$

A ::~ integer;

$\left[\begin{array}{ccc}1::\mathbb{Z}& 2::\mathbb{Z}& 3::\mathbb{Z}\\ 4::\mathbb{Z}& 5::\mathbb{Z}& 6::\mathbb{Z}\\ 7::\mathbb{Z}& 8::\mathbb{Z}& 9::\mathbb{Z}\end{array}\right]$

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

$\left[\begin{array}{c}\mathrm{true}\\ \mathrm{false}\\ \mathrm{false}\\ \mathrm{false}\end{array}\right]$

[{1,2},{3,4}] subset~ [{1,3,4,5},{1,3,4,5}];

$\left[\mathrm{false}\&comma;\mathrm{true}\right]$

A @~ b;

$\left[\begin{array}{ccc}1@b& 2@b& 3@b\\ 4@b& 5@b& 6@b\\ 7@b& 8@b& 9@b\end{array}\right]$

b @~ A;

$\left[\begin{array}{ccc}b@1& b@2& b@3\\ b@4& b@5& b@6\\ b@7& b@8& b@9\end{array}\right]$

L := ["a","b"];

$L≔\left[''a''\&comma;''b''\right]$

L ||~ 1;

$\left[''a1''\&comma;''b1''\right]$

map(f, [[a,b]]);

$\left[f\left(\left[a\&comma;b\right]\right)\right]$

map(f~, [[a,b]]);

$\left[\left[f\left(a\right)\&comma;f\left(b\right)\right]\right]$

module EC() option object;
  local data := <1,2;3,4>;
  export `?[]`::static := proc(me,idx)
       me:-data[op(idx)];
  end;
  export upperbound::static := proc(me,dim:=NULL)
      :-upperbound(me:-data,dim);
  end;
  local ModulePrint::static := proc( me )
      [[me:-data]]
  end;
  export ModuleCopy := proc( me, proto, d::rtable := NULL )
      if d <> NULL then
          me:-data := d;
      else
          me:-data := <7,8;9,10>;
      fi;
  end;
  export getData::static := proc(me)
      me:-data;
  end;
  export setData::static := proc(me, v )
      me:-data := v;
  end;
end;

$\left[\left[\left[\begin{array}{cc}1& 2\\ 3& 4\end{array}\right]\right]\right]$

EC +~ 10;

$\left[\left[\left[\begin{array}{cc}11& 12\\ 13& 14\end{array}\right]\right]\right]$

The elementwise and `~` commands were introduced in Maple 2024.

For more information on Maple 2024 changes, see Updates in Maple 2024.