Array Operators
The following operators are defined on ILNumerics arrays. All operators work elementwise, are parallelized and may perform inplace on suitable arrays. Binary operators perform broadcasting according to the current setting of ILNumerics.Settings.ArrayStyle (see: Array Styles).
C# Operator  Element type T  returns 
Function equivalent 
Description 

Unary Operators  Array<T> A  
Negation:   all integer, double, float  same as input 
ILMath. negate() 
Negates the values of array elements. The result is the same as multiplying the values with 1. Some operators perform the negation with a larger data type than T. In this case the result is afterwards casted down to and stored as the datatype matching the input datatype. 
Bitwise negation: ~  All integer types  same as input 
ILMath. bitneg() 
Reverses the bits of the array elements. 
Explicit cast: (T)  T (all types)  System scalar    Gives the System value T of the only element of a scalar Array<T>. 
Implicit cast  T (all types)  Array<T>    Instances of T (System.ValueType) implicitly converts to scalar Array<T> when required. 
Indexing [ ]  T (all types)  Array<T>  A.GetRange() A.SetRange()  Indexing operator for subarray creation or assignment. See: indexing 
Unary Operators  Logical A  
NOT: !  bool  Logical 
ILMath. not() 
Inverses the values of a logical array. 
Explicit cast: (T)  bool  System scalar    Gives the System.Boolean of the only element of a scalar Logical. 
Implicit cast  bool  Logical    System.Boolean is implicitly converted to a scalar Logical array when required. 
Indexing [ ]  bool  Logical 
L.GetRange() L.SetRange() 
Indexing operator for subarray creation or assignment. See: indexing 
Binary Operators  Array<T> A, B  
Arithmetic: +, , *, /, %  All numeric T, complex, fcomplex  same as input 
ILMath. add() subtract() multiplyElem() divide() mod(); add_sat() subtract_sat() multiplyElem_sat() divide_sat() mod_sat()

Elementwise arithmetic operations: plus, minus, multiply, division, modulo. The computation may be internally performed in a higher precision / larger integer type than T. The result, however, is stored into T elements. Overflows: if a result exceeds the natural limits of an integer datatype T, the behavior depends on the current ArrayStyle setting. numpy: no checks are done, 'wrapping around' may occur. ILNumericsV4: the result 'saturates' the limits of T, i.e.: values are clamped to the value range of datatype T. Integer operations are performed as 'double' floating point operations and rounded to the nearest integer afterwards. See below for details. 
Comparison: ==, !=, <,>,<=,>= 
All numeric; complex, fcomplex where applicable 
Logical 
ILMath. eq() neq() lt() gt() le() ge() 
Elementwise comparison operators: equal to, unequal to, lower [or equal], greater [or equal]. The result of the comparison is returned at the corresponding element position in a Logical array. Special floating point values: comparisons of two NaN values gives false. (Use eqnan() for comparing arrays with expected NaN values.) 
Bitwise: &, , ^, <<, >> 
All integer  same as input 
ILMath. bitand() bitor() bitxor() lshift() rshift() 
Bitwise operators: and, or, xor. Bit shifting operators << and >> require an integer value as second operand. 
Binary Operators  Logical A,B  
Comparison: ==, != 
bool  Logical 
ILMath. eq() neq() 
Elementwise comparison operators: equal to, unequal to. 
Logical: &, , ^ 
bool  Logical 
ILMath. and() or() xor() 
Elementwise logical operators: logical and, logical or, logical xor. 
Broadcasting
All operations involving two arrays are performed with broadcasting: singleton dimensions of the one array are expanded by (virtual) replication to match the size of the corresponding dimension of the other array. If both arrays have different number of dimensions, the dimensions are aligned at the first dimension (Matlab array style) or the last dimension (numpy array style) and missing trailing / leading dimensions of the one array with fewer dimensions are (virtually) replaced by singleton dimensions.
Broadcasting is a performance feature, potentially saving many memory copies. It is available in ILNumerics since version 4.10, in Matlab and numpy.
Static Functions
For most operators corresponding static functions are provided on the ILMath class. Use the static function directly when using an operator is not supported in your language.
Integer Operations: Saturation, Rounding
Some operators may perform saturation (Matlab style on integer arrays). Internally, a corresponding saturating function is called depending on the current array style. The names of saturateandround functions end with "[name]_sat". Here, [name] is the name of the main static function: add(), add_sat(), subtract(), subtract_sat(),etc. Thus, by using the static functions directly, one can override the array style without having to switch between individual array style settings:
Operator Precedence
If multiple operators are combined in a single expression, operators take precedence according to the following list (starting with the highest precedence):
 [ ] indexing
 () casting
 , !, ~ unary negation
 *, /, %  multiplicative arithmetic
 +,  addition & subtraction
 <<, >> bit shifts
 <,>,<=,>= relational comparison
 ==, != equality comparison
 &, ^,   logical / bitwise and / xor / or (in this order)
Being a DSL, ILNumerics array operators rely on the operator precedence of the host language.