Element-wise Operators - Maple Programming Help

Online Help

All Products    Maple    MapleSim


Home : Support : Online Help : Programming : Operations : Operators : operators/elementwise

Element-wise Operators

 

Description

Examples of Element-wise Operators

Description

• 

The element-wise operators in Maple are:

+~

addition or unary plus (prefix)

-~

subtraction or unary minus (prefix)

*~

multiplication

/~

division

^~

exponentiation

mod~

modulo

!~

factorial (unary postfix)

 

 

<~

less than

<=~

less than or equal

>~

greater than

>=~

greater than or equal

=~

equal

<>~

not equal

 

 

@~

composition

@@~

repeated composition

||~

concatenation operator

.~

non-commutative multiplication

::~

type operator

 

 

and~

logical and

or~

logical or

xor~

exclusive or

implies~

implication

not~

logical not (unary prefix)

 

 

union~

set union

subset~

subset

intersect~

set intersection

minus~

set difference

in~

set or list membership

 

 

&<name> ~

neutral operator

&name ~

neutral operator (unary prefix)

 

 

funct~

general element-wise operator (unary postfix)

 

 

• 

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>;

41018

(1)

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

sin1sin2sin3

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

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

falsetruetruefalse

(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;

149

(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: 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~([a1,a2],<b1,b2>,c);

fa1&comma;b1&comma;cfa2&comma;b2&comma;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 container.

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

1&comma;2&plus;2&comma;3&comma;4&plus;2

(6)
• 

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

  

 

Examples of Element-wise Operators

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

A:=123456789

(7)

B := LinearAlgebra:-IdentityMatrix(3);

B:=100010001

(8)

A . B;

123456789

(9)

A .~ B;

100050009

(10)

sin~(A);

sin1sin2sin3sin4sin5sin6sin7sin8sin9

(11)

-~ A;

123456789

(12)

A !~;

12624120720504040320362880

(13)

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

myproc~(A);

149162536496481

(14)

A mod~ 3;

120120120

(15)

A >~ 3;

3<13<23<33<43<53<63<73<83<9

(16)

evalb~(A >~ 3);

falsefalsefalsetruetruetruetruetruetrue

(17)

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

falsefalsefalsetruetruetruetruetruetrue

(18)

evalhf~(A >~ 3);

0.0.0.1.1.1.1.1.1.

(19)

A ::~ integer;

1::integer2::integer3::integer4::integer5::integer6::integer7::integer8::integer9::integer

(20)

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

truefalsefalsefalse

(21)

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

false&comma;true

(22)

A @~ b;

1&commat;b2&commat;b3&commat;b4&commat;b5&commat;b6&commat;b7&commat;b8&commat;b9&commat;b

(23)

b @~ A;

b&commat;1b&commat;2b&commat;3b&commat;4b&commat;5b&commat;6b&commat;7b&commat;8b&commat;9

(24)

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

L:=a&comma;b

(25)

L ||~ 1;

a1&comma;b1

(26)

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

fa&comma;b

(27)

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

fa&comma;fb

(28)

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;

1234

(29)

EC +~ 10;

11121314

(30)

See Also

Array

index/expression

LinearAlgebra[Zip]

list

map

Matrix

neutral

operators/binary

operators/precedence

operators/unary

set

table

Vector

zip

 


Download Help Document

Was this information helpful?



Please add your Comment (Optional)
E-mail Address (Optional)
What is ? This question helps us to combat spam