Voir la source de Mathématiques avec Python et Ruby/Nombres entiers en Ruby

<noinclude>{{Mathématiques avec Python et Ruby}}</noinclude>

La particularité des nombres entiers, c'est que chacun possède un successeur et un prédécesseur. Et bien ''Ruby'' sait les calculer (certes ce n'est pas très difficile, il suffit d'additionner ou soustraire 1 à un nombre entier pour avoir le suivant ou le précédent).

[[Fichier:Sheep_herding,_Arkansas.jpg|400px|right]]

==Obtention d'un nombre entier==

===Avec une chaîne de caractères===

Si on entre le script suivant:

<syntaxhighlight lang="ruby">
a=7
puts(a)
</syntaxhighlight>

on a exactement le même effet que si on entre

<syntaxhighlight lang="ruby">
a="7"
puts(a)
</syntaxhighlight>

du moins en apparence. Parce que si on essaye d'additionner 2, avec 

<syntaxhighlight lang="ruby">
a=7
puts(a+2)
</syntaxhighlight>

on a 9, alors qu'avec

<syntaxhighlight lang="ruby">
a="7"
puts(a+2)
</syntaxhighlight>

on a un message d'erreur: On ne peut pas additionner un nombre et une chaîne de caractères !

Pour convertir une chaîne de caractères en entier, on utilise la méthode ''to_i'' de celle-ci. Ainsi

<syntaxhighlight lang="ruby">
a="7"
b=a.to_i
puts(b+2)
</syntaxhighlight>

donne bien 9.


Un autre moyen d'obtenir un entier (naturel) avec une chaîne de caractères, c'est de compter le nombre de lettres de celle-ci. Ce qui se fait avec sa propriété ''length'':

<syntaxhighlight lang="ruby">
t="abracadabrantesque"
n=t.length
puts(n)
</syntaxhighlight>

===Avec un réel===

La méthode ''to_i'' permet aussi de convertir un réel en entier. Ce qui est parfois nécessaire parce que pour ''Ruby'', <math>\sqrt{100}</math> n'est pas un entier:

<syntaxhighlight lang="ruby">
a=Math.sqrt(100)
puts(a.integer?)
</syntaxhighlight>

Affiche ''false'' parce que pour ''Ruby'', le nombre calculé est 10.0 (considéré comme réel et non comme entier) et sa méthode ''to_i'' change son type, en le transformant en un entier:

<syntaxhighlight lang="ruby">
a=Math.sqrt(100).to_i
puts(a.integer?)
</syntaxhighlight>

affiche bien ''true''.

<syntaxhighlight lang="ruby">
a=3.9999999
b=a.to_i
puts(b)
</syntaxhighlight>

n'a peut-être pas l'effet escompté, puisque ''a'' a été choisi proche de 4, et qu'on obtient 3. C'est que la conversion en entier se fait par une [[w:troncature|troncature]] et pas par un [[w:arrondi|arrondi]]. En fait ''to_i'' a le même effet que ''floor'':

<syntaxhighlight lang="ruby">
a=3.9999999
b=a.floor
puts(b)
</syntaxhighlight>

Si on veut arrondir au-dessus, on utilise la méthode ''ceil'' d'un réel:

<syntaxhighlight lang="ruby">
a=3.9999999
b=a.ceil
puts(b)
</syntaxhighlight>


mais là on tombe dans le problème inverse:

<syntaxhighlight lang="ruby">
a=3.0000001
b=a.ceil
puts(b)
</syntaxhighlight>

donne aussi 4 !

Pour arrondir au mieux, on utilise la méthode ''round'':

<syntaxhighlight lang="ruby">
a=3.9999999
b=a.round
puts(b)
</syntaxhighlight>

===Avec un entier===

Pour avoir le successeur d'un entier, on utilise la méthode ''succ'':

<syntaxhighlight lang="ruby">
puts(7.succ)
</syntaxhighlight>

nous apprend que 7+1=8 (on s'en doutait un peu...), alors que 

<syntaxhighlight lang="ruby">
puts(7.pred)
</syntaxhighlight>

montre que 7-1=6. Mais contrairement au premier des [[w:axiomes de Peano|axiomes de Peano]], 0 possède un prédécesseur (-1) parce que pour ''Ruby'', les entiers sont [[w:entier relatif|relatifs]] et pas seulement [[w:entier naturel|naturels]].

Pour avoir l'opposé d'un entier, on le précède d'un signe "moins". Ainsi, 

<syntaxhighlight lang="ruby">
a=-5
puts(-a)
</syntaxhighlight>

Donne 5, car l'opposé de -5 est 5.

===tests sur les entiers===

Pour savoir si 2 est entier (on ne sait jamais), on peut le vérifier par 

<syntaxhighlight lang="ruby">
puts(2.integer?)
</syntaxhighlight>

Ce test a été utilisé ci-dessus pour vérifier que 10 est entier, et on a eu raison de se méfier !

On peut aussi vérifier si un entier est premier, avec ''mathn'':

<syntaxhighlight lang="ruby">
require 'mathn'
a=2**32+1
puts(a.prime?)
</syntaxhighlight>

nous apprend que 4 294 967 297 n'est pas premier, contrairement à ce qu'avait conjecturé [[w:Fermat|Fermat]].

==Opérations==

===Addition, soustraction et multiplication===

Dans ''Ruby'', les opérations arithmétiques sont notées ''+'', ''-'' et ''*'' sans grande surprise. Ces opérations peuvent porter sur des entiers négatifs:

<syntaxhighlight lang="ruby">
a=5
b=-8
puts(a+b)
puts(a-b)
puts(a*b)
</syntaxhighlight>

===Division===

Par défaut, la division des entiers est la [[w:division euclidienne|division euclidienne]]. Son quotient est donc un entier (et n'est pas le quotient exact)

====Quotient====

le script suivant:

<syntaxhighlight lang="ruby">
num=3
den=2
q=num/den
puts(q)
</syntaxhighlight>

affiche 1 et pas 1,5 parce que le quotient euclidien de 3 par 2 est 1 (avec un reste de 1) et pas 1,5...

Si on veut le quotient exact, on doit remplacer l'un des entiers par un réel avec un point décimal. Pour avoir 1,5, on peut essayer l'une des possibilités suivantes

<syntaxhighlight lang="ruby">
puts(3.0/2)
puts(3/2.0)
puts(3.0/2.0)
puts(3.to_f/2)
</syntaxhighlight>

Mais dans ce cas, on travaille sur des valeurs approchés. Pour avoir les valeurs exactes, il faut utiliser des fractions (voir à [[Mathématiques avec Python et Ruby/Fractions en Ruby]]). Et bien entendu, toute tentative de division par 0 donne un message d'erreur.

====Reste====

Lorsqu'on divise euclidiennement 13 par 8, le quotient est donc égal à 1. Mais il reste 5. Pour calculer directement ce reste en ''Ruby'', on peut utiliser le symbole ''%'':

<syntaxhighlight lang="ruby">
a=13
b=8
r=a%b
puts(r)
</syntaxhighlight>

Cette opération permet de travailler sur les [[w:congruence|congruences]]. Remarque: Si b=0, on a le même message d'erreur que lorsqu'on divise par 0.

====Primalité====

En ''Ruby'', l'opération [[w:pgcd|pgcd]] est [[w:Notations_infixée,_préfixée,_polonaise_et_postfixée|infixée]]. Pour chercher le plus grand entier qui divise à la fois 13572468 et 12345678, on entre 

<syntaxhighlight lang="ruby">
a=13572468
b=12345678
g=a.gcd(b)
puts(g)
</syntaxhighlight>

Bien entendu, ''a.gcd(b)'' et ''b.gcd(a)'' donnent le même résultat.

De même, le [[w:ppcm|ppcm]] se calcule de façon analogue avec ''a.lcm(b)''.

Lorsqu'un entier n'a pas de diviseurs non triviaux, il est dit ''premier'', et on a vu ci-dessus qu'avec ''mathn'' on peut tester si un nombre est premier. Avec ''prime'' aussi:

<syntaxhighlight lang="ruby">
require 'prime'
n=2010
puts(n.prime?)
puts(n.prime_division)
</syntaxhighlight>

Et en bonus, la décomposition en facteurs premiers!

===Puissances===

L'opérateur d'élévation à la puissance se note avec l'[[w:astérisque|astérisque]] de la multiplication, mais dédoublée:

<syntaxhighlight lang="ruby">
a=4
b=2
puts(a**b)
puts(b**a)
</syntaxhighlight>

pour vérifier que <math>4^2=2^4</math> (Exercice: Quelles sont les autres solutions de l'équation <math>a^b=b^a</math>?)

'''Remarques''': 

#Si l'exposant est négatif, le résultat est une fraction;
#Si l'exposant est réel, le résultat est réel aussi.

====Priorités opératoires====

En ''Ruby'' comme en algèbre, on effectue dans l'ordre

#Les parenthèses
#Les fonctions (comme l'élévation à une puissance)
#Les multiplications et divisions
#Les additions et soustractions.

Ainsi 

<syntaxhighlight lang="ruby">
puts(2+3*5)
</syntaxhighlight>
affiche 17 et non 25: Les opérations ne sont pas effectuées de gauche à droite, mais en suivant les priorités opératoires.

==Entiers et itération==

===Itérateur===

La méthode la plus utile d'un nombre entier est sans conteste le bouclage, qui permet de répéter quelque chose de répétitif. Il suffit de dire à ''Ruby'' ce qu'il doit répéter (entre ''do'' et ''end'') et combien de fois il doit le répéter: Un entier! 

====Bis repetita====

Pour écrire un message très enthousiaste, on peut écrire

<syntaxhighlight lang="ruby">
oui=10
oui.times do puts("Yes!") end
</syntaxhighlight>

====Avec un indice====

Pour additionner les entiers successifs, on peut le faire avec

<syntaxhighlight lang="ruby">
somme=0
n=10
n.times do |indice| somme+=indice end
puts(somme)
</syntaxhighlight>

Le fait de mettre la variable entre traits verticaux lui donne automatiquement les valeurs entières successives. Mais la somme est affichée égale à 45 alors que 1+2+3+4+5+6+7+8+9+10=55...

Pour savoir d'où vient cette erreur de comptage, on peut essayer

<syntaxhighlight lang="ruby">
n=10
n.times do |indice| puts(indice) end
</syntaxhighlight>

Bingo! Les 10 premiers entiers naturels vont de 0 à 9, pas de 1 à 10.

Pour éviter de commencer par 0, on peut explicitement commencer par 1:

<syntaxhighlight lang="ruby">
(1..10).inject {|somme, indice| somme+indice}
</syntaxhighlight>

Mais cette fois-ci, on ne travaille plus avec un entier mais avec une liste d'entiers. Pour un tel objet, ''inject'' est une méthode typique de ''Ruby'' qui permet d'injecter à la liste un bloc d'instructions. Le bloc comprend deux variables locales, la première des deux (''somme'') étant destinée à se faire injecter des doses successives du médicament, la seconde (''indice'') représentant les doses de médicament à injecter l'une après l'autre.

===Boucles===

''Ruby'' permet aussi de faire de la programmation impérative avec des boucles:

====à nombre prédéterminé d'exécutions====

Pour additionner les entiers de 1 à 10, on peut aussi faire comme ceci:

<syntaxhighlight lang="ruby">
somme=0
for indice in 1..10 do
    somme+=indice
end
puts(somme)
</syntaxhighlight>

Cette fois-ci on a bien 55.

====à condition de sortie====

La même somme peut aussi être calculée avec cette boucle:

<syntaxhighlight lang="ruby">
somme,indice=0,0
while indice<=10 do
    somme+=indice
    indice=indice.succ
end
puts(somme)
</syntaxhighlight>



[[Catégorie:Programmation Ruby (livre)|Nombres en Ruby|Nombres entiers en Ruby]]