Division

On commence par définir la division « avec reste » entre nombres entiers naturels. Cette division peut s'approcher de manière intuitive par la notion de « partage, distribution équitable », et donne une procédure de calcul.

Cette notion permet déjà de mettre en évidence le problème de la division par zéro : comment partager une quantité en 0 part ? Cela n'a pas de sens, il faut au moins une part.

Puis, on définit la notion de nombre décimal, et l'on étend la procédure de calcul en l'appliquant de manière récursive au reste, voir la section ci-dessous Division non abrégée. Cela permet de définir la notion de nombre rationnel.

La notion de partage convient encore mais est plus difficile à appréhender. On peut imaginer des portions de part, donc diviser par des nombres fractionnaires : diviser une quantité par 0,1 (1/10), c'est dire que la quantité initiale représente 1/10 part, et donc trouver la taille d'une part complète. Diviser une quantité par un nombre négatif, cela revient à calculer la taille d'une part que l'on enlève.

Les nombres réels sont construits à partir des rationnels. Un nombre irrationnel ne peut pas se concevoir comme une quantité ; par contre, il peut se voir comme une proportion : le rapport entre la diagonale d'un carré et son côté, le rapport entre le périmètre d'un cercle et son diamètre. Dès lors, la division ne peut plus être définie comme un partage, mais comme la réciproque de la multiplication.

Avec cette définition, on ne peut toujours pas diviser par 0 : puisque 0×a = 0 pour tout nombre, il existe une infinité de réciproques. On peut aussi — puisque diviser par un nombre revient à multiplier par son inverse — voir ce problème comme celui de la limite en 0 de la fonction inverse ƒ(x) = 1/x : elle a deux limites, –∞ à gauche et +∞ à droite.

Le fait « d'étendre » les nombres réels en incluant des « pseudo-nombres infinis », +∞ et –∞ (droite réelle achevée), ne règle pas le problème, puisque reste le problème du signe.

La notion de division est donc fondamentale en algèbre et en analyse.

Étant donné un anneau intègre (A, +, ×), la division sur A est la loi de composition : ${\displaystyle \mathrm {A} \times \mathrm {A} \to \mathrm {A} }$, notée par exemple « ÷ », telle que ${\displaystyle \forall (a,b,c)\in \mathrm {A} \times \mathrm {A} \times \mathrm {A} }$,

a ÷ b = c si et seulement si b × c = a.

L'intégrité de l'anneau assure que la division a bien un résultat unique. Par contre, elle n'est définie que sur ${\displaystyle \mathrm {A} \times (\mathrm {A} -\{0\})}$ si et seulement si A est un corps commutatif, et en aucun cas définie pour b = 0.

Si la division n'est pas définie partout, on peut étendre conjointement la division et l'ensemble A : dans le cas commutatif, on définit sur ${\displaystyle \mathrm {A} \times \mathrm {A} }$ une relation d'équivalence ${\displaystyle \sim }$ par

${\displaystyle (a,b)\sim (a',b')\iff a\times b'=a'\times b}$

et on écrit

a ÷ b la classe de ${\displaystyle (a,b)}$ dans l'anneau quotient.

Cet anneau quotient est un corps dont le neutre est la classe 1 ÷ 1. C'est ainsi que l'on construit ${\displaystyle \mathbb {Q} }$ en symétrisant ${\displaystyle \mathbb {Z} }$ pour la multiplication (ou ${\displaystyle \mathbb {Z} }$ à partir de ${\displaystyle \mathbb {N} }$ en symétrisant l'addition).

Cette définition ne recouvre pas celle de division euclidienne, qui se pose de manière analogue mais dont le sens est radicalement différent.

Dans l'idée, elle sert aussi à inverser la multiplication (dans a, combien de fois b).

Le problème de définition ne se pose plus, puisque ${\displaystyle \forall (a,b)\in \mathbb {N} \times (\mathbb {N} -\{0\})}$, ${\displaystyle \{n\in \mathbb {N} \ |\ b\times n\leqslant a\}}$ est une partie de ${\displaystyle \mathbb {N} }$ non vide et majorée, qui admet donc un plus grand élément.

Cette division, fondamentale en arithmétique, introduit la notion de reste. Néanmoins, comme pour toutes les divisions, le b de la définition ne peut être zéro.

Division non abrégée de 23 par 6.

L'algorithme de division non abrégée, encore appelé division longue, sert à déterminer une écriture décimale du quotient de deux nombres entiers. C'est une extension de la division euclidienne (voir Poser une division > Généralisation en arithmétique). D'un point de vue pratique, il consiste à continuer la procédure, en « descendant des zéros », les nouveaux chiffres calculés s'ajoutant après la virgule. Cela se justifie par

${\displaystyle {\frac {a}{b}}\times 10^{n}={\frac {a\times 10^{n}}{b}}\Longrightarrow {\frac {a}{b}}={\frac {a\times 10^{n}}{b}}\div 10^{n}}$

où n est le nombre de décimales que l'on veut. Ainsi, on ajoute n zéros à droite du numérateur, on effectue une division euclidienne classique, puis sur le quotient obtenu, les n derniers chiffres sont après la virgule.

Notons que l'on a intérêt à calculer la n + 1^e décimale pour savoir dans quel sens faire l'arrondi.

Par exemple, pour calculer 23÷6 avec deux décimales, la procédure revient à calculer 2 300÷6 ( = 383, reste 2) puis à diviser le résultat par 100 (ce qui donne 3,83).

Cette procédure se généralise au quotient de deux nombres décimaux ; cela se justifie par :

${\displaystyle {\frac {a}{b}}={\frac {a\times 10^{n}}{b\times 10^{n}}}}$

où n est un entier positif tel que a×10ⁿ et b×10ⁿ soient des entiers ; on peut par exemple prendre le plus grand nombre de décimales dans les nombres a et b.

Deux situations peuvent se présenter :

• on finit par avoir un reste nul : on obtient donc un nombre décimal ;
• on finit par retomber par un reste qui est déjà apparu auparavant : la division « ne se termine pas », elle boucle à l'infini ; dans ce cas, le quotient est un rationnel non décimal, et on peut prouver que son développement décimal admet une période, dont la longueur est strictement inférieure au diviseur.

Dans une division non exacte a÷b, (a et b étant deux nombres entiers, b non nul), si on note ${\displaystyle q_{p}}$ et ${\displaystyle r_{p}}$ respectivement le quotient et le reste obtenus en poussant les itérations jusqu'à obtenir p chiffres après la virgule du quotient, on obtient un encadrement ou une égalité :

${\displaystyle {\dfrac {a}{b}}\approx q_{p}}$ à ${\displaystyle 10^{-p}}$ près ou ${\displaystyle q_{p}<{\dfrac {a}{b}}<q_{p}+10^{-p}}$

et

${\displaystyle {\dfrac {a}{b}}=q_{p}+{\dfrac {r_{p}\cdot 10^{-p}}{b}}}$

Un nombre irrationnel (réel, sans être rationnel) ne peut s'écrire sous forme de fraction, par définition. C'est par contre la limite d'une suite de nombres rationnels (voir Construction des nombres réels).

La division en système binaire est une opération fondamentale pour l'informatique.

On considère dans un premier temps des entiers naturels (positifs). La division se fait de la même manière que la division euclidienne.

Soient deux nombres a et b de n bits. La notation a(i) désigne le i-ième bit (en partant de la droite, notés de 0 à n - 1), a(i:j) désigne les bits situés entre les positions i et j. La fonction suivante calcule le quotient Q et le reste R, en pseudo-code :

fonction [Q, R] = diviser(a, b)
si b == 0 alors
génère l'exception "division par zéro" ;
fin
Q := 0 ; R := a ; // initialisation
pour i = n-1 → 0
si a(n:i) >= b alors
Q(i) = 1 ; // i-ème bit du quotient
R = a(n:i) - b ; // reste
fin
fin
retourne [Q, R] ;
fin

On cherche une portion de « bits forts » (chiffres de gauche) de a qui est supérieure à b ; si l'on n'en trouve pas, alors le quotient garde la valeur 0, et le reste R prend la valeur a (puisqu'au final il est constitué de tous les chiffres de a). Si à un certain rang i on a a(n:i) ≥ b, alors du fait du système binaire, la réponse à

en a(n:i) combien de fois b

est nécessairement « une fois » : en base 10, la réponse est entre 1 et 9 = 10 - 1 ; ici, elle est entre 1 et 1 = 2 - 1. On a donc le i-ème bit du quotient qui vaut 1 ; le reste R à cette étape est la différence.

Ce pseudo-programme n'est pas optimisé pour des raisons de clarté ; une version plus efficace serait :

fonction [Q, R] = diviser(a, b)
si b == 0 alors
génère l'exception "division par zéro" ;
fin
Q := 0 ; R := 0 ; // initialisation
pour i = n-1 → 0
R = décalage_à_gauche_de_bits(R, 1) ; // équivaut à rajouter un 0 à droite
R(1) = a(i) ; // le bit de poids faible de R est le i-ème bit du numérateur
si R >= b alors
Q(i) = 1 ; // i-ème bit du quotient
R = R - b ; // reste
fin
fin
retourne [Q, R] ;
fin

Cet algorithme marche également avec les nombres décimaux codés en virgule fixe.

Pour les nombres décimaux codés en virgule flottante, il suffit de voir que :

${\displaystyle {\frac {a\cdot 2^{m}}{b\cdot 2^{n}}}={\frac {a}{b}}\cdot 2^{m-n}}$

donc on fait la division des mantisses (qui sont des décimaux codés en virgule fixe) d'un côté, et la différence des exposants (qui sont des entiers).

On voit que l'on ne fait appel qu'à des fonctions élémentaires — comparaison, décalage, assignation, soustraction — ce qui permet de le mettre en œuvre de manière simple dans un microprocesseur.

Dans la division euclidienne de a par b, pour des nombres représentés en base B (B = 2 en binaire), à l'étape i :

• on considère le reste de l'étape précédente, R_{i - 1} ;
• on détermine le i-ème chiffre du quotient en partant de la gauche, donc le chiffre j = n - i en partant de la droite : Q_{n - i} ;
• le nouveau reste vaut

R_i = B×R_{i - 1} - Q_{n - i}×b.

Cette construction par récurrence constitue la base des méthodes dites lentes.

Connaissant R_{i - 1}, on suppose que Q_{n - i} = 1, on a alors

R_i = 2×R_{i - 1} - b.

Si la valeur trouvée est négative, c'est que Q_{n - i} = 0. Par rapport à la procédure euclidienne, plutôt que de prendre les chiffres de gauche du numérateur, on ajout des 0 à droite du dénominateur. À la première étape, on en ajoute autant que le nombre de bits n servant à coder les nombres (il faut donc un espace mémoire double), puis on multiplie le numérateur par 2 jusqu'à vérifier la condition. Cela donne en pseudo-code (on omet le test de division par zéro) :

fonction [Q, R] = diviser(a, b)
R := a // valeur initiale du reste
b := décalage_à_gauche_de_bits(b, n)
pour i = n-1 → 0
R := décalage_à_gauche_de_bits(b, 1)
si R >= b alors
Q(i) := 1 // le i-ème bit de i est 1
R = R - b
sinon
Q(i) := 0 // le i-ème bit de i est 0
fin
fin
fin

Lorsque l'on optimise l'algorithme pour réduire le nombre d'opérations, on obtient le pseudo-code suivant.

fonction [Q, R] = diviser(a, b)
R := a // valeur initiale du reste
b := décalage_à_gauche_de_bits(b, n)
pour i = n-1 → 0
R := 2*R - b // le reste décalé est-il supérieur à b ?
si R >= 0 alors
Q(i) := 1 // le i-ème bit de i est 1
sinon
Q(i) := 0 // le i-ème bit de i est 0
R := R + b // on restaure la valeur du reste en gardant le décalage
fin
fin
retourner[Q, R]
fin

Du fait de la dernière instruction de la boucle, on qualifie cette méthode de « division avec restauration ».

La méthode peut être améliorée en générant un quotient utilisant les nombres +1 et -1. Par exemple, le nombre codé par les bits

11101010

correspond en fait au nombre

11111111

c'est-à- dire à 11101010 -00010101 --------- 11010101 La méthode est dite « sans restauration » et son pseudo-code est :

fonction [Q, R] = diviser(a, b)
R[0] := a
i := 0
tant que i < n
si R[i] >= 0 alors
Q[n-(i+1)] := 1
R[i+1] := 2*R[i] - b
sinon
Q[n-(i+1)] := -1
R[i+1] := 2*R[i] + b
fin
i := i + 1
fin
Q = transforme(Q)
retourner[Q, R]
fin

La méthode de division SRT — du nom de ses inventeurs, Sweeney, Robertson, et Tocher —, est une méthode sans restauration, mais la détermination des bits du quotient se fait en utilisant une table de correspondance ayant pour entrées a et b. C'est un algorithme utilisé dans de nombreux microprocesseurs. Alors que la méthode sans restauration classique ne permet de générer qu'un bit par cycle d'horloge, la méthode SRT permet de générer deux bits par cycle[1].

L'erreur de division du Pentium était due à une erreur dans l'établissement de la table de correspondance[2].

Les méthodes rapides consistent à évaluer x = 1/b, puis à calculer Q = a×x.

La méthode de Newton-Raphson consiste à déterminer 1/b par la méthode de Newton.

La méthode de Newton permet de trouver le zéro d'une fonction en connaissant sa valeur et la valeur de sa dérivée en chaque point. Il faut donc trouver une fonction ƒ_b(x) qui vérifie

${\displaystyle f_{b}(x)=0\Longleftrightarrow x=1/b}$

et telle que l'on puisse effectuer l'itération

${\displaystyle x_{i}=x_{i-1}-{\frac {f_{b}(x_{i-1})}{f'_{b}(x_{i-1})}}}$

sans avoir à connaître 1/b. On peut par exemple utiliser

ƒ_b(x) = 1/x - b

ce qui donne

x_i = x_{i - 1}(2 - b·x_{i - 1})

Pour des raisons d'économie de calcul, il vaut toutefois mieux utiliser l'écriture

x_i = x_{i - 1} + x_{i - 1}(1 - b·x_{i - 1})

Pour initialiser la procédure, il faut trouver une approximation de 1/b. Pour cela, on normalise a et b par des décalages de bits afin d'avoir b compris dans [0,5 ; 1]. On peut ensuite prendre une valeur arbitraire dans cet intervalle — par exemple b ≈ 0,75 donc 1/b ≈ 1,33…, ou encore 1 ≤ 1/b ≤ 2 donc 1/b ≈ 1,5 —, ou bien faire le développement limité de 1/x en un point — par exemple en 0,75 (1/b ≈ 2,66… - 1,77…×b) ou en 1/1,5 (1/b ≈ 3 - 2,25×b). On retient souvent l'approximation affine

${\displaystyle x_{0}={\frac {48}{17}}-{\frac {32}{17}}b\ (\simeq 2,82-1,88b)}$

les valeurs de 48/17 et de 32/17 étant précalculées (stockées « en dur »).

Cette méthode converge de manière quadratique. Pour une précision sur p bits, il faut donc un nombre d'étapes s :

${\displaystyle s=\log _{2}\left({\frac {p+1}{\log _{2}17}}\right)}$

(arrondi au supérieur), soit trois étapes pour un codage en simple précision et quatre étapes en double précision et double précision étendue (selon la norme IEEE 754).

Voici le pseudo-code de l'algorithme.

fonction [Q] = diviser(a, b)
e := exposant(b) // b = M*2^e (représentation en virgule flottante)
b' := b/2^{e + 1} // normalisation ; peut se faire par un décalage de e+1 bits à droite
a' := a/2^{e + 1} // 0.5 <= b <= 1 ; a'/b' = a/b
X := 48/17 - 32/17*b' // initialisation de la méthode de Newton
pour i = 1 → s // s précalculé en fonction du nombre p de bits de la mantisse
X := X + X*(1 - b*X)
fin
Q := a'*X
retourne[Q]
fin

La méthode de Goldschmidt[3] est fondée, elle, sur la considération suivante :

${\displaystyle {\frac {\mathrm {Q} }{1}}={\frac {a}{b}}}$

donc, il existe un facteur F tel que b×F = 1, et ainsi a×F = Q. Notons que F = 1/b.

Le facteur F est évalué par une suite (F_k) :

F_k = f_k×f_{k - 1}×…×f₁ = ∏(f_i)

telle que la suite (b_k) = F_k×b converge vers 1. Pour cela, on normalise la fraction pour que b se trouve dans ]0 ; 1], et l'on définit

f_{i + 1} = 2 - b_i.

Le quotient final vaut

Q = F_k×a.

Notons que l'on a

F_{i + 1} = f_{i + 1}×F_i ;

b_{i + 1} = f_{i + 1}×b_i.

Cette méthode est notamment utilisée sur les microprocesseurs AMD Athlon et suivants[4]^,[5].

La méthode binomiale est similaire à la méthode de Goldschmidt, mais consiste à prendre pour suite de facteurs f_i = 1 + x²ⁱ avec x = 1 - b. En effet, on a :

${\displaystyle \mathrm {Q} ={\frac {a}{1-x}}={\frac {a(1+x)}{(1-x)(1+x)}}={\frac {a(1+x)}{1-x^{2}}}}$

${\displaystyle \mathrm {Q} ={\frac {a(1+x)(1+x^{2})}{1-x^{4}}}={\frac {a(1+x)(1+x^{2})(1+x^{4})}{1-x^{8}}}=\cdots }$

suivant la formule du binôme de Newton.

Si l'on normalise b pour qu'il soit dans [0,5 ; 1], alors x est dans [0 ; 0,5] et à l'étape n, le dénominateur 1 - x²ⁿ est égal à 1 avec une erreur de inférieure à 2^-n, ce qui garantit 2ⁿ chiffres significatifs.

Cette méthode est parfois désignée comme « méthode IBM »[6].

Commençons par la notation polaire. Soient deux nombres complexes z₁ = r₁e^iθ₁, z₂ = r₂e^iθ₂. La division complexe

x = z₁/z₂

est donc définie par

x×z₂ = z₁

Si on note x = re^iθ, alors l'équation devient

re^iθ×r₂e^iθ₂ = r₁e^iθ₁

soit

rr₂e^{i(θ + θ₂)} = r₁e^iθ₁

donc

${\displaystyle \left\{{\begin{aligned}rr_{2}=\ &r_{1}\\\theta +\theta _{2}=\ &\theta _{1}\end{aligned}}\right.\Longrightarrow \left\{{\begin{aligned}r=\ &{\frac {r_{1}}{r_{2}}}\\\theta =\ &\theta _{1}-\theta _{2}\end{aligned}}\right.}$

Ceci n'est défini que si r₂ ≠ 0 c'est-à-dire z₂ ≠ 0

On peut donc écrire

${\displaystyle {\frac {r_{1}\mathrm {e} ^{\mathrm {i} \theta _{1}}}{r_{2}\mathrm {e} ^{\mathrm {i} \theta _{2}}}}={\frac {r_{1}}{r_{2}}}\mathrm {e} ^{\mathrm {i} (\theta _{1}-\theta _{2})}}$

Voyons maintenant la notation cartésienne. On a z₁ = a + b×i et z₂ = c + d×i, et x = e + f×i. L'équation de définition

x×z₂ = z₁

devient

(e + f×i)×(c + d×i) = a + b×i

ec - fd + (de + cf)i = a + b×i

soit

${\displaystyle \left\{{\begin{aligned}ec-fd=\ &a\\de+cf=\ &b\end{aligned}}\right.\Longrightarrow \left\{{\begin{aligned}e=\ &{\frac {ac+bd}{c^{2}+d^{2}}}\\f=\ &{\frac {bc-ad}{c^{2}+d^{2}}}\end{aligned}}\right.}$

qui est défini si c² + d² ≠ 0, c'est-à-dire si |z₂| ≠ 0, ce qui équivaut à dire que z₂ est non-nul.

On peut donc écrire

${\displaystyle {\frac {a+b\times \mathrm {i} }{c+d\times \mathrm {i} }}={\frac {ac+bd}{c^{2}+d^{2}}}+{\frac {bc-ad}{c^{2}+d^{2}}}\mathrm {i} }$

Une mise en informatique « brute » de la méthode de calcul peut mener à des résultats problématiques.

Dans un ordinateur, la précision des nombres est limitée par le mode de représentation. Si l'on utilise la double précision selon la norme IEEE 754, la valeur absolue des nombres est limitée à environ [10^-307 ; 10³⁰⁸]. Si le calcul génère une valeur absolue supérieure à 10³⁰⁸, le résultat est considéré comme « infini » (Inf, erreur de dépassement) ; et si la valeur absolue est inférieure à 10^-307, le résultat est considéré comme nul (soupassement).

Or, la formule ci-dessus faisant intervenir des produits et des carrés, on peut avoir un intermédiaire de calcul dépassant les capacités de représentation alors que le résultat final (les nombres e et f) peuvent être représentés. Notons que dans la norme IEEE 754, 1/0 donne Inf (+∞) et -1/0 donne -Inf (-∞), mais en mettant un drapeau indiquant l'erreur « division par zéro » ; le calcul de 1/Inf donne 0.

Si par exemple l'on met en œuvre cette formule pour calculer[7]

(1 + i)/(1 + 10^-307i), on obtient 0 alors que le résultat est environ 10^-307 - 10^-307i (ce qui est représentable) ;

(1 + i)/(10^-307 + 10^-307i), on obtient NaN (résultat d'une opération 0/0), alors que le résultat est 10³⁰⁷ (représentable) ;

Ces erreurs sont dues au calcul de (10³⁰⁷)² et de (10^-307)².

Pour limiter ces erreurs, on peut utiliser la méthode de Smith[8], qui consiste à factoriser de manière pertinente :

${\displaystyle {\frac {a+b\times \mathrm {i} }{c+d\times \mathrm {i} }}=\left\{{\begin{aligned}{\text{si }}|d|\ll |c|{\text{$ : }}&{\frac {a+b(d/c)}{c+d(d/c)}}+{\frac {b-a(d/c)}{c+d(d/c)}}\mathrm {i} \\{\text{si }}|d|\gg |c|{\text{ : }}&{\frac {a(c/d)+b}{c(c/d)+d}}+{\frac {b(c/d)-a}{c(c/d)+d}}\mathrm {i} \\\end{aligned}}\right.}

En effet, dans le premier cas, |d/c| < 1 donc |x(d/c)| < x (x = a, b, d), donc la méthode est moins sensible aux dépassements.

La multiplication matricielle n'étant pas commutative, on définit deux divisions matricielles.

Soit A une matrice de dimension m×n et B une matrice de dimension n×p, alors on appelle « division à droite de A par B » et on note

X = A/B

la matrice de dimension m×p vérifiant l'équation :

XB = A

Soit A une matrice de dimension m×n et B une matrice de dimension m×p, alors on appelle « division à gauche de A par B » et on note

X = A\B

la matrice de dimension n×p vérifiant l'équation :

AX = B

Si la matrice A n'est pas de rang maximal, la solution n'est pas unique. La matrice A⁺B, où A⁺ désigne la matrice pseudo-inverse, est la solution de norme minimale.

On a par ailleurs :

B/A = ^t(^tA\^tB).

On peut défnir la division de polynômes à la manière de la division euclidienne :

${\displaystyle \mathrm {A} =\mathrm {B} \times \mathrm {Q} +\mathrm {R} }$

deg(R) < deg(B)

où Q et R sont des polynômes ; Q est le quotient et R est le reste.

On peut également appliquer la méthode de construction des nombres rationnels aux polynômes, ce qui permet de définir de manière formelle une fraction de polynômes. Mais il ne s'agit pas là d'un « calcul » de division, il s'agit de définir un nouvel objet mathématique, un nouvel outil.

• Divisibilité
• Division par deux
• Fraction
• Congruence sur les entiers
• Multiplication

• Arithmétique et théorie des nombres