# 1.6 About Constants and Operators

In an expression like `(9 - 7) * (5 + 6)` the constants 5, 6, 7, and 9 are being composed by the operators `+`, `*` and `-` to result in a new value.

There are three kinds of operators in GAP, arithmetical operators, comparison operators, and logical operators. You have already seen that it is possible to form the sum, the difference, and the product of two integer values. There are some more operators applicable to integers in GAP. Of course integers may be divided by each other, possibly resulting in noninteger rational values.

```    gap> 12345/25;
2469/5 ```

Note that the numerator and denominator are divided by their greatest common divisor and that the result is uniquely represented as a division instruction.

We haven't met negative numbers yet. So consider the following self--explanatory examples.

```    gap> -3; 17 - 23;
-3
-6 ```

The exponentiation operator is written as `^`. This operation in particular might lead to very large numbers. This is no problem for GAP as it can handle numbers of (almost) arbitrary size.

```    gap> 3^132;
955004950796825236893190701774414011919935138974343129836853841 ```

The `mod` operator allows you to compute one value modulo another.

```    gap> 17 mod 3;
2 ```

Note that there must be whitespace around the keyword `mod` in this example since `17mod3` or `17mod` would be interpreted as identifiers.

GAP knows a precedence between operators that may be overridden by parentheses.

```    gap> (9 - 7) * 5 = 9 - 7  * 5;
false ```

Besides these arithmetical operators there are comparison operators in GAP. A comparison results in a boolean value which is another kind of constant. Every two objects within GAP are comparable via `=`, `<>`, `<`, `<=`, `>` and `>=`, that is the tests for equality, inequality, less than, less than or equal, greater than and greater than or equal. There is an ordering defined on the set of all GAP objects that respects orders on subsets that one might expect. For example the integers are ordered in the usual way.

```    gap> 10^5 < 10^4;
false ```

The boolean values `true` and `false` can be manipulated via logical operators, i.~e., the unary operator `not` and the binary operators `and` and `or`. Of course boolean values can be compared, too.

```    gap> not true; true and false; true or false;
false
false
true
gap> 10 > 0 and 10 < 100;
true ```

Another important type of constants in GAP are permutations. They are written in cycle notation and they can be multiplied.

```    gap> (1,2,3);
(1,2,3)
gap> (1,2,3) * (1,2);
(2,3) ```

The inverse of the permutation `(1,2,3)` is denoted by `(1,2,3)^-1`. Moreover the caret operator `^` is used to determine the image of a point under a permutation and to conjugate one permutation by another.

```    gap> (1,2,3)^-1;
(1,3,2)
gap> 2^(1,2,3);
3
gap> (1,2,3)^(1,2);
(1,3,2) ```

The last type of constants we want to introduce here are the characters, which are simply objects in GAP that represent arbitrary characters from the character set of the operating system. Character literals can be entered in GAP by enclosing the character in singlequotes `'`.

```    gap> 'a';
'a'
gap> '*';
'*' ```

There are no operators defined for characters except that characters can be compared.

In this section you have seen that values may be preceded by unary operators and combined by binary operators placed between the operands. There are rules for precedence which may be overridden by parentheses. It is possible to compare any two objects. A comparison results in a boolean value. Boolean values are combined via logical operators. Moreover you have seen that GAP handles numbers of arbitrary size. Numbers and boolean values are constants. There are other types of constants in GAP like permutations. You are now in a position to use GAP as a simple desktop calculator.

Operators are explained in more detail in Comparisons and Operations. Moreover there are sections about operators and comparisons for special types of objects in almost every chapter of this manual. You will find Boolean Lists. Permutations are described in chapter Permutations and characters are described in chapter Strings and Characters.

GAP 3.4.4
April 1997