# Ruby Operators¶

Ruby operators can be broadly categorized into the following :

• Arithmetic
• Shift or Append
• Comparison
• Booleans
• Ranges

## Arithmetic Operators¶

The arithmetic operators are :

• - - Subtraction
• * - Multiplication
• ** - Exponential
• / - Division
• % - Modulo

```> 1 + 1
=> 2
```

### Division¶

```> 5 / 2
=> 2
```

To get 2.5 as the answer you will need to use floating point numbers as follows :

```> 5.0 / 2.0
=> 2.5
```

### Modulo¶

Remainder division

```> 5 % 2
=> 1
```

You will get an exception if you try to divide by 0.

```> 2 /0
ZeroDivisionError: divided by 0
from (irb):9:in `/'
```

Floating point division with 0 will give `Infinity` as a result.

```> 2.0 / 0.0
=> Infinity
```

We can apply addition to arrays, the result in a concatenation of the two arrays as follows :

```> [1,2] + [3,4,5]
=> [1, 2, 3, 4, 5]
```

### Arithmetic Operators on Strings¶

We can also apply arithmetic operators on string objects as follows :

```> "Hello world " * 2
=> "Hello world Hello world "
```

Only the multiplication operator works, other arithmetic operators will produce an error.

### Exponential Operators¶

We use the ** for exponent as follows :

``` > 2 ** 2
=> 4
```

### Shift operators¶

We can use the two shift operators, << and >>. This allows us to manipulate the numbers in binary. E.g we can easily get a 4 by shifting the 2 in binary by 1 as follows.

```> 2 << 1
=> 4
```

Here is how it works. The number 2 in binary is represented as 10. When we shift by 1 we push an additional 0 at the end, so we now get the number 100, which is 4 in binary.

We can display the value of 2 in binary using the to_s(2) method as follows :

```> 2.to_s(2)
=> "10"
```

We can see that 2 in binary is 10.

If we change the operator and push to the right, we now remove the leading 0.

```> 2 >> 1
=> 1
```

We now get a 1 since we removed the leading 0 from 10.

We can shift with more bits if we prefer, e.g. to get the value 8 we can push 2 by 3 bits as follows :

```> 2 << 2
=> 8
```

### Append Operator¶

The same operator for left shifting, << is for appending on arrays.

```> nums = []
=> []
2.2.5 :029 > nums << 1
=> 
2.2.5 :030 > nums << 2
=> [1, 2]
```

We could also apply the append multiple times as follows :

``` > nums << 3 << 4
=> [1, 2, 3, 4]
```

### Output to Standard Output¶

The << operator is also used to output to Standard Output as follows :

``` > STDOUT << "Hello World"
Hello World => #<IO:<STDOUT>>
```

## Comparison Operators¶

• < - Less than operator
• <= - Less then or equal to operator
• Greater than operator
• = - Greater than operator

• <=> - Comparable operator
• != - Not equal to operator

### Comparable operator <=>¶

The other operators perform exactly as they are supposed to except the comparable operator. The comparable operator works as follows :

• Returns -1 if the left hand value is less than the right hand operand
• Returns 1 if the left hand operand is greater than the right hand operand
• Return 0 is they are equal
• Returns nil if they can not be compared
```> 2 <=> 2
=> 0
```
```> 1 <=> 2
=> -1
```
```> 2 <=> 1
=> 1
```

## Boolean Operators¶

• && - Logical AND operator
• || - Logical OR operator
• ! - NOT operator

### && operator¶

The operator returns tru if all the operands are true or false otherwise.

```> 10 > 0 && 10 < 9
=> false
```

### || operator¶

The logical OR operator returns true if any of the operands returns true. It returns false if both operands return false.

```> 10 > 0 || 10 == 10
=> true
```

### ! NOT Operator¶

Negates the operand.

```> !true
=> false
```
```> !false
=> true
```

### ||= OR Equal¶

This operator returns the current value if its initialized or initializes the new value.

```> b ||= 5 # b is not defined, so we get 5
=> 5
2.2.5 :049 > b = 10 # assign b to a new value of 10
=> 10
2.2.5 :050 > b ||= 5 # assign 5 if b does not have a value
=> 10 # b have a value so we get the value already assigned
```

Performing the same operation above only using the ||(logical OR) operator results in an error as follows :

``` > a || 5
NameError: undefined local variable or method `a' for main:Object
```

## Range Operators¶

Range operators are used to implement sequences, conditions and intervals.

### Range operator¶

We define the range with ..(inclusive) or ...(exclusive) operators.

### Inclusive range operator¶

```> (1..3).each {|i| p i}
1
2
3
=> 1..3
```

### Exclusive range operator¶

```> (1...3).each {|i| p i}
1
2
=> 1...3
```

Verify that the class is a range :

```> (1..2).class
=> Range
```

### Convert a range to array¶

We can convert the Range to an array using the `to_a` as follows :

```> (1..5).to_a
=> [1, 2, 3, 4, 5]
```

### Convert to an enum¶

We can also convert the range to an enumerable using `to_enum` as follows :

``` > n = (1..5).to_enum
=> #<Enumerator: 1..5:each>
2.2.5 :060 > n.next
=> 1
2.2.5 :061 > n.next
=> 2
```

We can also create and convert range of type character as follows :

```> alphabet = ('a'..'z').to_enum
=> #<Enumerator: "a".."z":each>
2.2.5 :065 > alphabet.next
=> "a"
2.2.5 :066 > alphabet.next
=> "b"
```