Sommation et produit scalaire compensés

function [x, y, z] = ThreeFMA(a, b, c) x = FMA(a, b, c) [u₁, u₂] = TwoProdFMA(a, b) [α1, z] = TwoSum(c, u2) [β1, β2] = TwoSum(u1, α1) y = (β₁ x) ⊕ β₂

L'algorithme ThreeFMA nécessite 17 opérations ottantes. Ses propriétés numériques sont résumées par le théorème 3.16 ci-dessous.

Théorème 3.16 ([12]). Soient a, b, c ∈ F et x, y, z ∈ F vériant [x, y, z] = ThreeFMA(a, b, c) (algorithme 3.15). Alors, en absence d'underow,

a × b + c = x + y + z, x = FMA(a, b, c), |y + z| ≤ u|x|, |y + z| ≤ u|a × b + c| (3.8) et

y = 0 ou |y| > |z|. (3.9)

3.3 Sommation et produit scalaire compensés

À titre d'exemples d'application des transformations exactes pour les opérations élé-mentaires, et parce qu'ils seront utilisés dans les chapitres 8 et 9, nous reproduisons dans cette section quelques résultats présents dans [70] à propos de la sommation et du produit scalaire compensés.

Précisons que les méthodes de sommations compensées sont depuis longtemps étudiées dans la littérature. Parmi les références antérieures à [70], citons les algorithmes de Ka-han (1965) [45], Møller (1965) [65, 64], Pichat (1972) [78] et de Neumaier (1974) [67].

De nombreuses autres références existent pour des méthodes de sommation en arith-métique ottante [59, 60, 48, 37, 26, 23, 24, 62], et sur les algorithmes de sommation compensée en particulier [82, 2, 91, 90].

3.3.1 Sommation compensée

On considère un vecteur p = (p1, . . . , pn) ∈ Rn, et on note s =^P_i=1ⁿ pi et es =^Pn_i=1|pi|. Le nombre de conditionnement pour le problème du calcul de la somme des n valeurs p₁, . . . , p_n est déni dans [70] de la manière suivante,

condX p^:= P_n i=1|pi| P_n i=1p_i ⁼ es |s|^{. (3.10)} Soit maintenant p = (p1, . . . , pn) ∈ Fnun vecteur de n ottants. On considère ci-dessous l'algorithme classique de sommation récursive.

36 Chapitre 3. Transformations arithmétiques exactes Algorithme 3.17. Sommation récursive de n ottants

function bsn = Sum(p) bs1 = p1

for i = 2 : n bsi = bsi−1⊕ pi

end

Pour cet algorithme de sommation, notons σi−1 l'erreur d'arrondi commise lors de l'addition ottante bs_i−1⊕ p_i. D'après le théorème 3.6, on sait que σ_i−1 ∈ F et bs_i−1+ p_i = bsi+ σi−1. Ainsi on a

pi = bsi− bsi−1+ σi−1. Comme bs1 = p1, on peut montrer par récurrence que

n X i=1 pi = bsn+ n−1 X i=0 σi.

En notant de plus σ_n = bs_n= Sum(p), on obtient l'égalité suivante,

n X i=1 pi = n X i=1 σi, avec σn = Sum(p), (3.11) Le vecteur σ = (σ1, . . . , σn) ∈ Fn peut être calculé, comme indiqué dans [70], par l'algo-rithme VecSum ci-dessous.

Algorithme 3.18. Transformation exacte pour la somme de n ottants (Algorithme 4.4 dans [70]).

function σ = VecSum(p) bs1 = p1

for i = 2 : n

[bs_i, σ_i−1] = TwoSum(bs_i−1, p_i) end

σn= bsn

La relation (3.11) démontre que l'algorithme VecSum est une transformation exacte la sommation de n nombre ottants. Cette transformation exacte est utilisée de la manière suivante pour compenser l'algorithme de sommation récursive [70].

Algorithme 3.19. Somme compensée de n ottants (Algorithme 4.4 dans [70]).

function s = Sum2(p) σ = VecSum(p)

bc = Sum σ₁, . . . , σ_n−1
s = σn⊕ bc

Puisque σn = Sum(p), et d'après l'égalité (3.11), l'idée de l'algorithme Sum2 est de calculer une valeur approchée bc de ^Pn−1_i=1 σ_i, puis d'en déduire un résultat compensé s = σ_n⊕ bc. Puisque le terme correctif bc prend en compte les erreurs d'arrondi générées lors du calcul de σn = Sum(p), on peut s'attendre à ce que le résultat compensé s soit plus précis que le résultat initial Sum(p). Les auteurs de [70] démontrent en eet le théorème suivant.

3.3. Sommation et produit scalaire compensés 37 Théorème 3.20 (proposition 4.4 dans [70]). Étant donné un vecteur p = (p1, . . . , pn) de n nombres ottants, soit s = ^Pn_i=1pi et soit es = ^Pn_i=1|pi|. On suppose que nu < 1, et on note s le ottant tel que s = Sum2(p). Alors, même en présence d'underow,

|s − s| ≤ u|s| + γ2

n−1es. (3.12)

Pour interpréter la borne d'erreur (3.12), on fait intervenir le nombre de conditionne-ment (3.10),

|s − s|

|s| ^{≤ u + γ2}n−1condX

p^. (3.13) Le premier terme u, dans borne (3.13) sur l'erreur relative entachant le résultat calculé s reète l'arrondi nal vers la précision de travail. Le second terme est essentiellement de l'ordre de n2u2 fois le conditionnement de la somme. Ce résultat indique donc que la qualité du résultat compensé s est la même que s'il avait été calculé par la méthode de sommation récursive classique en précision doublée u2, avec un arrondi nal vers la précision u.

Les auteurs de [70] généralisent ensuite cette méthode en appliquant K − 1 fois la transformation exacte VecSum. Cela donne l'algorithme SumK, qui eectue (6K −5)(n−1) opérations ottantes.

Algorithme 3.21. Sommation compensée K − 1 fois. function s = SumK(p, K) for k = 1 : K − 1 p = VecSum(p) end c = Sum p1, . . . , pn−1
s = p_n⊕ c

Le théorème suivant montre que le résultat calculé par l'algorithme SumK est mainte-nant aussi précis que si la somme avait été calculée en K fois la précision de travail. Théorème 3.22 (proposition 4.10 dans [70]). Étant donné un vecteur p = (p₁, . . . , p_n) de n nombres ottants, soit s = ^Pn_i=1pi et soit es = ^Pn_i=1|pi|. On suppose que 4nu ≤ 1 et K ≥ 3. On note s le ottant tel que s = SumK(p, K). Alors, même en présence d'underow,

|s − s| ≤ (u + 3γ2

n−1)|s| + γK

2n−2es. (3.14) À nouveau, ce théorème s'interprète à l'aide du nombre de conditionnement (3.10). La précision du résultat compensé s calculé par SumK est majorée de la façon suivante,

|s − s|

|s| ^{≤ (u + 3γ}n−1² ) + γK

2n−2condX

p^. (3.15) Le facteur γK

2n−2, de l'ordre de 4nKuK, indique maintenant que les calculs sont aussi précis que s'ils avaient été calculée en K fois la précision de travail [70]. Le terme u + 3γ2

n−1, de l'ordre de u reète simplement l'arrondi nal vers la précision de travail.

38 Chapitre 3. Transformations arithmétiques exactes

3.3.2 Produit scalaire compensé

Nous passons plus rapidement sur le cas du produit scalaire compensé, qui est très similaire à celui de la somme compensée. L'algorithme Dot2 rappelé ici sera utilisé au chapitre 9.

Soient x = (x₁, . . . , x_n)T ∈ Rn et x = (y₁, . . . , y_n)T ∈ Rn deux vecteurs de longueur n. On note s = xTy le produit scalaire de x et de y, et es = |xT||y| = ^Pn_i=1|xiyi|. Le nombre de conditionnement pour le problème du calcul du produit scalaire xTy est déni de la manière suivante dans [70],

cond(xTy) := 2^|x_|x^T_T^||y|_y| = _|s|^es. (3.16) On suppose maintenant que x = (x₁, . . . , x_n)T ∈ Fn et x = (y₁, . . . , y_n)T ∈ Fn sont deux vecteurs de ottants. Les auteurs de [70] considèrent l'algorithme de produit scalaire suivant, dans lequel les erreurs commises lors du calcul classique du produit scalaire sont compensées à l'aide de TwoProd et de TwoSum.

Algorithme 3.23. Produit scalaire compensé de deux vecteurs de n ottants. function s = Dot2(x, y) [bs1, c1] = TwoProd(x1, y1) for i = 2 : n [bp_i, σ_i] = TwoProd(x_i, y_i) [bsi, σi] = TwoSum(bsi−1, bpi) bci = bci−1⊕ (πi⊕ σi) end s = bsn⊕ bcn

Théorème 3.24 (proposition 5.5 dans [70]). Étant donnés x = (x₁, . . . , x_n)T ∈ Fn et x = (y1, . . . , yn)T ∈ Fn sont deux vecteurs de ottants, soit s = Dot2(x, y) la valeur approchée de xTy calculée par algorithme 3.23. On suppose que nu ≤ 1. Alors, en l'absence d'underow,

|s − s| ≤ u|xTy| + γ2

n|xT||y|. (3.17) En faisant intervenir le nombre de conditionnement déni par la relation (3.16), on constate facilement que la borne d'erreur (3.17) signie à nouveau que le résultat compensé calculé par Dot2 est aussi précis que s'il avait été calculé par l'algorithme classique de produit scalaire en précision doublée u2, puis arrondi vers la précision de travail u.