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.
	  
See Mathworld for more information.
a^b
             Exponentiation, raises a to the bth power.
           
a.^b
	     Element by element exponentiation.  Raise each element of a matrix
	     a to the bth 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+bAddition. 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-bSubtraction. Subtract two numbers, matrices or functions.
a*bMultiplication. 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.\bElement by element back division.
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 „Modulare Auswertung“.
	     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
	     (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
	     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 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.
           
-aNegation operator. Returns the negative of a number or a matrix (works element-wise on a matrix).
&aVariable referencing (to pass a reference to a variable). See „Referenzen“.
*aVariable dereferencing (to access a referenced variable). See „Referenzen“.
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,:)Gleiches wie oben.
a@(,c)
	     Get column of a matrix (or columns if c is a
	     vector).
           
a@(:,c)Gleiches wie oben.
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
`aQuote 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.
           
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.
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)
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.