A peculiarity of the integers is that any one of them possesses a *predecessor* and a *successor*. Although it is very easy to compute them (subtract or add one to an integer), *Ruby* has methods coined *pred* and *succ* to handle them!

# How to get an integer in RubyEdit

## From a stringEdit

This script

a=7 puts(a)

yields exactly the same result than

a="7" puts(a)

at least at first sight. But if one tries to add 2,

a=7 puts(a+2)

yields 9 as expected, but

a="7" puts(a+2)

yields an error message, as one can not add a number with a string.

So a string representing an integer number has to be converted into a number with the *to_i* method (*to integer*). Thus

a="7" b=a.to_i puts(b+2)

yields 9 this time.

An other way to get an integer number from a string is to count its letters. Which is made with its *length* property:

t="Supercalifragilisticexpialidocious" n=t.length puts(n)

## From a real numberEdit

A real number too has a *to_i* method which converts it to an integer. This is sometimes useful because for *Ruby* is not considered as an integer number:

a=Math.sqrt(100) puts(a.integer?)

*Ruby* answers *false* because the number has been computed as *10.0* and not *10*. So

a=Math.sqrt(100).to_i puts(a.integer?)

yields the expected *true*. But

a=3.9999999 b=a.to_i puts(b)

may not have the expected result: *to_i* uses a truncature instead of an approximation. Actually, *floor* has the same effect:

a=3.9999999 b=a.floor puts(b)

On the converse, a real number has also a *ceil* method:

a=3.9999999 b=a.ceil puts(b)

But now an other problem arouses:

a=3.0000001 b=a.ceil puts(b)

Maybe 4 was not the expected answer!

Finally the best method to get an integer approximation is *round*:

a=3.9999999 b=a.round puts(b)

## From an other integerEdit

So, to get the successor of an integer, one asks to it to tell its successor, with its method *succ*:

puts(7.succ)

tells that 7+1=8 (you bet!), whereas

puts(7.pred)

shows that 7-1=6. But contrary to Peano's axiom number 7, zero *has* a predecessor (which is -1) because for *Ruby* the integers are rational integers and not only natural ones. Then, any integer has an additive inverse, which one can obtain by just preceding its name by a *minus* sign:

a=-5 puts(-a)

This yields 5 because the additive inverse of -5 is 5.

## PrimalityEdit

To know if an integer is prime requires an other module called *mathn*, which offers a primality test *prime?* (a boolean):

require 'mathn' a=2**32+1 puts(a.prime?)

This shows at a glance that 4 294 967 297 is *not* prime , shame on Fermat (he has excuses, he didnt't own a *Ruby* console!)!

# OperationsEdit

## Addition, subtraction and multiplicationEdit

For *Ruby*, the arithmetic operations are denoted by *+*, *-* et *** without surprise. These operations work also on negative integers:

a=5 b=-8 puts(a+b) puts(a-b) puts(a*b)

## DivisionEdit

### QuotientEdit

Unless otherwise specified, the division denoted by the *slash* operator is the integer one. To *specify otherwise* one needs to write one of the operands as a *float*, with a period:

num=3 den=2 q=num/den puts(q)

yields 1 instead of 1.5 because the integer quotient is 1 (with a remainder), while any if the following variants yields 1.5:

puts(3.0/2) puts(3/2.0) puts(3.0/2.0) puts(3.to_f/2)

To compute the exact value of a non integer quotient, one needs to use fractions.

### RemainderEdit

Sometimes (often?) the quotient is not as important as the remainder (RSA kryptography for example, or even the hours, that are counted modulo 12). The remainder is given by the modulo operator denoted as *%*:

a=13 b=8 r=a%b puts(r)

It is then quite possible to compute in modular arithmetic with *Ruby*.

### DivisorsEdit

In *Ruby*, the gcd is an infix operation:

a=13572468 b=12345678 g=a.gcd(b) puts(g)

Of course, *a.gcd(b)* and *b.gcd(a)* yield the same result.

Likewise, the lcm of two integers *a* and *b* can be computed as *a.lcm(b)*.

An integer which has no divisor (except 1 and itself) is a prime number. *Ruby* can test the primality of an (not to big) integer:

require 'prime' n=2012 puts(n.prime?) puts(n.prime_division)

The above example shows that *Ruby* can even find the prime divisors of an integer!

## ExponentiationEdit

In *Ruby*, the exponentiation operator is denoted with the same asterisk than the multiplication, but written twice:

a=4 b=2 puts(a**b) puts(b**a)

This shows that .

Remarks:

- If the exponent is negative, the result of the exponentiation is a fraction.
- If the exponent is a
*float*, the result is a float even if it is actually an integer (like in*256**0.25*).

### PriorityEdit

In *Ruby* like in algebra, the computings are made in this order:

- First, the parentheses;
- then the functions (like the exponentiation for example);

" then only the multiplications and divisions;

- At last, the additions and subtractions.

Thus

puts(2+3*5)

displays 17 and not 25, because in this case the operations are not computed from left to right, but the multiplication first.