Список операторов GEL
Prev | Chapter 5. Основы GEL | Next

## Список операторов GEL

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`

  Разделитель, просто вычисляющий как `a`, так и `b`, но возвращающий только результат `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.

  Смотрите Mathworld для дополнительной информации.

`a^b`

  Возводит переменную `a` в степень `b`.

`a.^b`

  Поэлементное возведение в степень. Возводит каждый элемент матрицы `a` в степень `b`. Или, если `b` — матрица той же размерности, что и `a`, выполняет операцию поэлементно. Если `a` — число, а `b` — матрица, то создаёт матрицу той же размерности, что и `b` со значением `a`, возведённым во все степени, содержащиеся в `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`

  Вычитание. Вычитает два числа, матрицы или функции.

`a*b`

  Умножение. Это обычное умножение матриц.

`a.*b`

  Поэлементное умножение, если `a` и `b` являются матрицами.

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

  Обратное деление. Это то же самое, что `b/a`.

`a.\b`

  Поэлементное обратное деление.

`a%b`

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

`a.%b`

  Element by element mod operator. Returns the remainder after element by element integer division `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!`

  Факториал: `1*...*(n-2)*(n-1)*n`.

`a!!`

  Двойной факториал: `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`

  Оператор неравенства, возвращает `true`, если `a` не равно `b`, в противном случае возвращает `false`.

`a<>b`

  Альтернативный оператор неравенства, возвращает `true`, если `a` не равно `b`, иначе возвращает `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` (and they can also be combined 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` (they can also be combined 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` (they can also be combined with the greater than or equal to operator).

`a<=>b`

  Оператор сравнения. Если `a` равно `b`, возвращает 0; если `a` меньше `b`, возвращает -1; если `a` больше `b`, возвращает 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 if 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,:)`

  То же, что и выше.

`a@(,c)`

  Возвращает столбец матрицы (или столбцы, если `c` является вектором).

`a@(:,c)`

  То же, что и выше.

`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` into an imaginary number (multiply `a` by the imaginary). Normally the imaginary 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`

  Меняет местами значение `a` со значением `b`. В настоящее время не работает с диапазонами элементов матрицы. Возвращает `null`. Доступен, начиная с версии 1.0.13.

`increment a`

  Инкремент переменной `a` на 1. Если `a` — матрица, то инкрементирует каждый элемент. Это эквивалентно `a=a+1`, но немного быстрее. Возвращает `null`. Доступен с версии 1.0.13.

`increment a by b`

  Инкремент переменной `a` на величину `b`. Если `a` — матрица, то инкрементирует каждый элемент. Это эквивалентно `a=a+b`, но немного быстрее. Возвращает `null`. Доступен с версии 1.0.13.

### Note

Оператор @() делает использование оператора : наиболее полезным. С его помощью можно указывать области матрицы. Таким образом, a@(2:4,6) — это строки 2,3,4 столбца 6. Или a@(,1:2) возвращает два первых столбца матрицы. Можно также присваивать значения оператору @(), если правое значение — это матрица, совпадающая по размеру с данной областью, или если это любой другой тип значений.

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

Prev | Up | Next
Modular Evaluation | Home | Chapter 6. Программирование в GEL