## List of GEL Operators

Everything in GEL is really just an expression. Expressions are stringed together with different operators. As we have seen, even the separator is simply a binary operator in GEL. Here is a list of the operators in GEL.

`a;b`

The separator, just evaluates both `a` and `b`, but returns only the result of `b`.

`a=b`

The assignment operator. This assigns `b` to `a` (`a` must be a valid lvalue) (note however that this operator may be translated to `==` if used in a place where boolean expression is expected)

`a:=b`

The assignment operator. Assigns `b` to `a` (`a` must be a valid lvalue). This is different from `=` because it never gets translated to a `==`.

`|a|`

Absolute value. In case the expression is a complex number the result will be the modulus (distance from the origin). For example: `|3 * e^(1i*pi)|` returns 3.

`a^b`

Exponentiation, raises `a` to the `b`th power.

`a.^b`

Element by element exponentiation. Raise each element of a matrix `a` to the `b`th power. Or if `b` is a matrix of the same size as `a`, then do the operation element by element. If `a` is a number and `b` is a matrix then it creates matrix of the same size as `b` with `a` raised to all the different powers in `b`.

`a+b`

Addition. Adds two numbers, matrices, functions or strings. If you add a string to anything the result will just be a string. If one is a square matrix and the other a number, then the number is multiplied by the identity matrix.

`a-b`

Subtraction. Subtract two numbers, matrices or functions.

`a*b`

Multiplication. This is the normal matrix multiplication.

`a.*b`

Element by element multiplication if `a` and `b` are matrices.

`a/b`

Division. When `a` and `b` are just numbers this is the normal division. When they are matrices, then this is equivalent to `a*b^-1`.

`a./b`

Element by element division. Same as `a/b` for numbers, but operates element by element on matrices.

`a\b`

Back division. That is this is the same as `b/a`.

`a.\b`

Element by element back division.

`a%b`

The mod operator. This does not turn on the modular mode, but just returns the remainder of `a/b`.

`a.%b`

Element by element the mod operator. Returns the remainder after element by element integer `a./b`.

`a mod b`

Modular evaluation operator. The expression `a` is evaluated modulo `b`. See the section called “Modular Evaluation”. Some functions and operators behave differently modulo an integer.

`a!`

Factorial operator. This is like `1*...*(n-2)*(n-1)*n`.

`a!!`

Double factorial operator. This is like `1*...*(n-4)*(n-2)*n`.

`a==b`

Equality operator. Returns `true` or `false` depending on `a` and `b` being equal or not.

`a!=b`

Inequality operator, returns `true` if `a` does not equal `b` else returns `false`.

`a<>b`

Alternative inequality operator, returns `true` if `a` does not equal `b` else returns `false`.

`a<=b`

Less than or equal operator, returns `true` if `a` is less than or equal to `b` else returns `false`. These can be chained as in `a <= b <= c` (can also be combined with the less than operator).

`a>=b`

Greater than or equal operator, returns `true` if `a` is greater than or equal to `b` else returns `false`. These can be chained as in `a >= b >= c` (can also be combine with the greater than operator).

`a<b`

Less than operator, returns `true` if `a` is less than `b` else returns `false`. These can be chained as in `a < b < c` (can also be combine with the less than or equal to operator).

`a>b`

Greater than operator, returns `true` if `a` is greater than `b` else returns `false`. These can be chained as in `a > b > c` (can also be combine with the greater than or equal to operator).

`a<=>b`

Comparison operator. If `a` is equal to `b` it returns 0, if `a` is less than `b` it returns -1 and if `a` is greater than `b` it returns 1.

`a and b`

Logical and. Returns true if both `a` and `b` are true, else returns false. If given numbers, nonzero numbers are treated as true.

`a or b`

Logical or. Returns true if either `a` or `b` is true, else returns false. If given numbers, nonzero numbers are treated as true.

`a xor b`

Logical xor. Returns true exactly one of `a` or `b` is true, else returns false. If given numbers, nonzero numbers are treated as true.

`not a`

Logical not. Returns the logical negation of `a`

`-a`

Negation operator. Returns the negative of a number or a matrix (works element-wise on a matrix).

`&a`

Variable referencing (to pass a reference to a variable). See the section called “References”.

`*a`

Variable dereferencing (to access a referenced variable). See the section called “References”.

`a'`

Matrix conjugate transpose. That is, rows and columns get swapped and we take complex conjugate of all entries. That is if the i,j element of `a` is x+iy, then the j,i element of `a'` is x-iy.

`a.'`

Matrix transpose, does not conjugate the entries. That is, the i,j element of `a` becomes the j,i element of `a.'`.

`a@(b,c)`

Get element of a matrix in row `b` and column `c`. If `b`, `c` are vectors, then this gets the corresponding rows columns or submatrices.

`a@(b,)`

Get row of a matrix (or multiple rows if `b` is a vector).

`a@(b,:)`

Same as above.

`a@(,c)`

Get column of a matrix (or columns if `c` is a vector).

`a@(:,c)`

Same as above.

`a@(b)`

Get an element from a matrix treating it as a vector. This will traverse the matrix row-wise.

`a:b`

Build a vector from `a` to `b` (or specify a row, column region for the `@` operator). For example to get rows 2 to 4 of matrix `A` we could do

```A@(2:4,)
```

as `2:4` will return a vector `[2,3,4]`.

`a:b:c`

Build a vector from `a` to `c` with `b` as a step. That is for example

```genius> 1:2:9
=
`[1, 3, 5, 7, 9]
```

When the numbers involved are floating point numbers, for example `1.0:0.4:3.0`, the output is what is expected even though adding 0.4 to 1.0 five times is actually just slightly more than 3.0 due to the way that floating point numbers are stored in base 2 (there is no 0.4, the actual number stored is just ever so slightly bigger). The way this is handled is the same as in the for, sum, and prod loops. If the end is within `2^-20` times the step size of the endpoint, the endpoint is used and we assume there were roundoff errors. This is not perfect, but it handles the majority of the cases. This check is done only from version 1.0.18 onwards, so execution of your code may differ on older versions. If you want to avoid dealing with this issue, use actual rational numbers, possibly using the `float` if you wish to get floating point numbers in the end. For example `1:2/5:3` does the right thing and `float(1:2/5:3)` even gives you floating point numbers and is ever so slightly more precise than `1.0:0.4:3.0`.

`(a)i`

Make a imaginary number (multiply `a` by the imaginary). Note that normally the number `i` is written as `1i`. So the above is equal to

```(a)*1i
```

``a`

Quote an identifier so that it doesn't get evaluated. Or quote a matrix so that it doesn't get expanded.

`a swapwith b`

Swap value of `a` with the value of `b`. Currently does not operate on ranges of matrix elements. It returns `null`. Available from version 1.0.13.

`increment a`

Increment the variable `a` by 1. If `a` is a matrix, then increment each element. This is equivalent to `a=a+1`, but it is somewhat faster. It returns `null`. Available from version 1.0.13.

`increment a by b`

Increment the variable `a` by `b`. If `a` is a matrix, then increment each element. This is equivalent to `a=a+b`, but it is somewhat faster. It returns `null`. Available from version 1.0.13.

### Note

The @() operator makes the : operator most useful. With this you can specify regions of a matrix. So that a@(2:4,6) is the rows 2,3,4 of the column 6. Or a@(,1:2) will get you the first two columns of a matrix. You can also assign to the @() operator, as long as the right value is a matrix that matches the region in size, or if it is any other type of value.

### Note

The comparison operators (except for the <=> operator, which behaves normally), are not strictly binary operators, they can in fact be grouped in the normal mathematical way, e.g.: (1<x<=y<5) is a legal boolean expression and means just what it should, that is (1<x and x≤y and y<5)

### Note

The unitary minus operates in a different fashion depending on where it appears. If it appears before a number it binds very closely, if it appears in front of an expression it binds less than the power and factorial operators. So for example `-1^k` is really `(-1)^k`, but `-foo(1)^k` is really `-(foo(1)^k)`. So be careful how you use it and if in doubt, add parentheses.