# Ruby Programming/Reference/Objects/Numeric

Numeric provides common behavior of numbers. Numeric is an abstract class, so it should not be instantiated.
Included Modules:

```Comparable
```

Instance Methods:
+ n

```    Returns n.
```

- n

```    Returns n negated.
```

n + num
n - num
n * num
n / num

```    Performs arithmetic operations: addition, subtraction, multiplication, and division.
```

n % num

```    Returns the modulus of n.
```

n ** num

```    Exponentiation.
```

n.abs

```    Returns the absolute value of n.
```

n.ceil

```    Returns the smallest integer greater than or equal to n.
```

n.coerce( num)

 Returns an array containing num and n both possibly converted to a type that allows them to be operated on mutually. Used in automatic type conversion in numeric operators.

n.divmod( num)

```    Returns an array containing the quotient and modulus from dividing n by num.
```

n.floor

 Returns the largest integer less than or equal to n.
```    1.2.floor            #=> 1
2.1.floor            #=> 2
(-1.2).floor         #=> -2
(-2.1).floor         #=> -3
```

n.integer?

```    Returns true if n is an integer.
```

n.modulo( num)

```    Returns the modulus obtained by dividing n by num and rounding the quotient with floor. Equivalent to n.divmod(num).
```

n.nonzero?

```    Returns n if it isn't zero, otherwise nil.
```

n.remainder( num)

 Returns the remainder obtained by dividing n by num and removing decimals from the quotient. The result and n always have same sign.
```    (13.modulo(4))         #=>  1
(13.modulo(-4))        #=> -3
((-13).modulo(4))      #=>  3
((-13).modulo(-4))     #=> -1
(13.remainder(4))      #=>  1
(13.remainder(-4))     #=>  1
((-13).remainder(4))   #=> -1
(-13).remainder(-4))   #=> -1
```

n.round

```   Returns n rounded to the nearest integer.
```
```    1.2.round              #=> 1
2.5.round              #=> 3
(-1.2).round           #=> -1
(-2.5).round           #=> -3
```

n.truncate

```   Returns n as an integer with decimals removed.
```
```    1.2.truncate           #=> 1
2.1.truncate           #=> 2
(-1.2).truncate        #=> -1
(-2.1).truncate        #=> -2
```

n.zero?

```    Returns zero if n is 0.
```