# Ruby Programming/Reference/Objects/Numeric/Integer

Integer provides common behavior of integers (Fixnum and Bignum). Integer is an abstract class, so you should not instantiate this class.

Inherited Class: Numeric Included Module: Precision

Class Methods:

Integer::induced_from(numeric)

```   Returns the result of converting numeric into an integer.
```

Instance Methods:

Bitwise operations: AND, OR, XOR, and inversion.

``` ~i i & int i | int i ^ int i << int i >> int ```

```   Bitwise left shift and right shift.
```

i[n]

```   Returns the value of the nth bit from the least significant bit, which is i.
```
```   5      # => 1
5      # => 0
5      # => 1
```

i.chr

```   Returns a string containing the character for the character code i.
```
```   65.chr    # => "A"
?a.chr    # => "a"
```

i.downto( min) {| i| ...}

```   Invokes the block, decrementing each time from i to min.
```
```   3.downto(1) {|i|
puts i
}
```
```   # prints:
#  3
#  2
#  1
```

i.next
i.succ

```   Returns the next integer following i. Equivalent to i + 1.
```

i.size

```   Returns the number of bytes in the machine representation of i.
```

i.step( upto, step) {| i| ...}

```   Iterates the block from i to upto, incrementing by step each time.
```
```   10.step(5, -2) {|i|
puts i
}
# prints:
#  10
#  8
#  6
```

i.succ

```   See i.next
```

i.times {| i| ...}

```   Iterates the block i times.
```
```   3.times {|i|
puts i
}
# prints:
#  0
#  1
#  2
```

i.to_f

```   Converts i into a floating point number. Float conversion may lose precision information.
```
```   1234567891234567.to_f   # => 1.234567891e+15
```

i.to_int

```   Returns i itself. Every object that has to_int method is treated as if it's an integer.
```

i.upto( max) {| i| ...}

```   Invokes the block, incrementing each time from i to max.
```
```   1.upto(3) {|i|
puts i
}
# prints:
#  1
#  2
#  3
```