# Operators

An operator is a special symbol or phrase that you use to check, change, or combine values. For example, the addition operator (+) adds two numbers, as in **var i = 1 + 2**, and the logical AND operator (&&) combines two Boolean values, as in **if (flag1 && flag2)**.

Gravity supports most standard C operators and improves several capabilities to eliminate common coding errors. The assignment operator (=) does not return a value, to prevent it from being mistakenly used when the equal to operator (==) is intended. Gravity also provides two range operators as a shortcut for expressing a range of values.

#### Arithmetic Operators

- Addition (+)
- Subtraction (-)
- Multiplication (*)
- Division (/)
- Remainder (%)

```
var n1 = 1 + 2 // equals 3
var n2 = 5 - 3 // equals 2
var n3 = 2 * 3 // equals 6
var n4 = 10.0 / 2.5 // equals 4.0
var n5 = 9 % 4 // equals 1
```

Special attention has been placed in the division operator. A Division between two Int usually result in a Float in order to not truncate any decimal.

#### Assignment Operator

The assignment operator = initialize or update a value:

```
var a = 50; // a = 50
var b = a; // b = 50
var c = a * b; // c = 50 * 50
```

Please note that contrary to many other programming languages, the assignment operator has no side effect, it means that it does not return any value.

#### Comparison Operators

The comparison operators return a Bool value to indicate whether or not the statement is true:

- Equal (==)
- Not equal (!=)
- Less than (<)
- Less than or equal (<=)
- Greater than (>)
- Greater than or equal (>=)
- Identical (===)
- Not identical (!==)
- Type check (is)
- Pattern match (~=)

```
1 == 1 // true because 1 is equal to 1
1 != 2 // true because 1 is not equal to 2
1 < 2 // true because 1 is less than 2
1 <= 1 // true because 1 is less than or equal to 1
1 > 2 // false because 1 is not greater than 2
1 >= 1 // true because 1 is greater than or equal to 1
1 === 1 // true because 1 is identical to 1 (same value and same class)
1 is Int // true because 1 is of class Int
```

Gravity performs some conversions at runtime, so 1 == "1" but not 1 === '1'.

#### Logical Operators

The comparison operators return a Bool value to indicate whether or not the statement is true:

- Logical NOT (!)
- Logical AND (&&)
- Logical OR (||)

```
!1 // false because 1 is true
1 && 0 // false because one of the two values is false
1 || 0 // true because one of the two values is true
```

In order to improve code readability the reserved keywords **not, and, or** has been introduces as an alisas to logical operators.

#### Bitwise Operators

- Bitwise shift left (<<)
- Bitwise shift right (>>)
- Bitwise AND (&)
- Bitwise OR (|)
- Bitwise XOR (^)
- Bitwise NOT or one's complement (~)

```
var n = 0B00110011;
var n1 = n << 2 // equals 11001100
var n2 = n >> 2 // equals 00001100
var n3 = n & 0B00001111 // equals 00000011
var n4 = n | 0B00001111 // equals 00111111
var n5 = n ^ 0B00001111 // equals 00111100
var n6 = ~n; // equals 11001100
```

#### Compound Assignment Operators

As a shortcut, assignment and operators can be combined together:

- Multiply and assign (*=)
- Divide and assign (/=)
- Remainder and assign (%=)
- Add and assign (+=)
- Subtract and assign (-=)
- Left bit shift and assign (<<=)
- Right bit shift and assign (>>=)
- Bitwise AND and assign (&=)
- Bitwise XOR and assign (^=)
- Bitwise OR and assign (|=)